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> 381da177e4SLinus Torvalds 39970c4e46SJohan Hedberg #include "smp.h" 40970c4e46SJohan Hedberg 41b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work); 42c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work); 433eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work); 441da177e4SLinus Torvalds 451da177e4SLinus Torvalds /* HCI device list */ 461da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 471da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 481da177e4SLinus Torvalds 491da177e4SLinus Torvalds /* HCI callback list */ 501da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 511da177e4SLinus Torvalds DEFINE_RWLOCK(hci_cb_list_lock); 521da177e4SLinus Torvalds 533df92b31SSasha Levin /* HCI ID Numbering */ 543df92b31SSasha Levin static DEFINE_IDA(hci_index_ida); 553df92b31SSasha Levin 561da177e4SLinus Torvalds /* ---- HCI notifications ---- */ 571da177e4SLinus Torvalds 586516455dSMarcel Holtmann static void hci_notify(struct hci_dev *hdev, int event) 591da177e4SLinus Torvalds { 60040030efSMarcel Holtmann hci_sock_dev_event(hdev, event); 611da177e4SLinus Torvalds } 621da177e4SLinus Torvalds 63baf27f6eSMarcel Holtmann /* ---- HCI debugfs entries ---- */ 64baf27f6eSMarcel Holtmann 654b4148e9SMarcel Holtmann static ssize_t dut_mode_read(struct file *file, char __user *user_buf, 664b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 674b4148e9SMarcel Holtmann { 684b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 694b4148e9SMarcel Holtmann char buf[3]; 704b4148e9SMarcel Holtmann 71111902f7SMarcel Holtmann buf[0] = test_bit(HCI_DUT_MODE, &hdev->dbg_flags) ? 'Y': 'N'; 724b4148e9SMarcel Holtmann buf[1] = '\n'; 734b4148e9SMarcel Holtmann buf[2] = '\0'; 744b4148e9SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 754b4148e9SMarcel Holtmann } 764b4148e9SMarcel Holtmann 774b4148e9SMarcel Holtmann static ssize_t dut_mode_write(struct file *file, const char __user *user_buf, 784b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 794b4148e9SMarcel Holtmann { 804b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 814b4148e9SMarcel Holtmann struct sk_buff *skb; 824b4148e9SMarcel Holtmann char buf[32]; 834b4148e9SMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 844b4148e9SMarcel Holtmann bool enable; 854b4148e9SMarcel Holtmann int err; 864b4148e9SMarcel Holtmann 874b4148e9SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 884b4148e9SMarcel Holtmann return -ENETDOWN; 894b4148e9SMarcel Holtmann 904b4148e9SMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 914b4148e9SMarcel Holtmann return -EFAULT; 924b4148e9SMarcel Holtmann 934b4148e9SMarcel Holtmann buf[buf_size] = '\0'; 944b4148e9SMarcel Holtmann if (strtobool(buf, &enable)) 954b4148e9SMarcel Holtmann return -EINVAL; 964b4148e9SMarcel Holtmann 97111902f7SMarcel Holtmann if (enable == test_bit(HCI_DUT_MODE, &hdev->dbg_flags)) 984b4148e9SMarcel Holtmann return -EALREADY; 994b4148e9SMarcel Holtmann 1004b4148e9SMarcel Holtmann hci_req_lock(hdev); 1014b4148e9SMarcel Holtmann if (enable) 1024b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_ENABLE_DUT_MODE, 0, NULL, 1034b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 1044b4148e9SMarcel Holtmann else 1054b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, 1064b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 1074b4148e9SMarcel Holtmann hci_req_unlock(hdev); 1084b4148e9SMarcel Holtmann 1094b4148e9SMarcel Holtmann if (IS_ERR(skb)) 1104b4148e9SMarcel Holtmann return PTR_ERR(skb); 1114b4148e9SMarcel Holtmann 1124b4148e9SMarcel Holtmann err = -bt_to_errno(skb->data[0]); 1134b4148e9SMarcel Holtmann kfree_skb(skb); 1144b4148e9SMarcel Holtmann 1154b4148e9SMarcel Holtmann if (err < 0) 1164b4148e9SMarcel Holtmann return err; 1174b4148e9SMarcel Holtmann 118111902f7SMarcel Holtmann change_bit(HCI_DUT_MODE, &hdev->dbg_flags); 1194b4148e9SMarcel Holtmann 1204b4148e9SMarcel Holtmann return count; 1214b4148e9SMarcel Holtmann } 1224b4148e9SMarcel Holtmann 1234b4148e9SMarcel Holtmann static const struct file_operations dut_mode_fops = { 1244b4148e9SMarcel Holtmann .open = simple_open, 1254b4148e9SMarcel Holtmann .read = dut_mode_read, 1264b4148e9SMarcel Holtmann .write = dut_mode_write, 1274b4148e9SMarcel Holtmann .llseek = default_llseek, 1284b4148e9SMarcel Holtmann }; 1294b4148e9SMarcel Holtmann 130dfb826a8SMarcel Holtmann static int features_show(struct seq_file *f, void *ptr) 131dfb826a8SMarcel Holtmann { 132dfb826a8SMarcel Holtmann struct hci_dev *hdev = f->private; 133dfb826a8SMarcel Holtmann u8 p; 134dfb826a8SMarcel Holtmann 135dfb826a8SMarcel Holtmann hci_dev_lock(hdev); 136dfb826a8SMarcel Holtmann for (p = 0; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 137cfbb2b5bSMarcel Holtmann seq_printf(f, "%2u: 0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x " 138dfb826a8SMarcel Holtmann "0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x\n", p, 139dfb826a8SMarcel Holtmann hdev->features[p][0], hdev->features[p][1], 140dfb826a8SMarcel Holtmann hdev->features[p][2], hdev->features[p][3], 141dfb826a8SMarcel Holtmann hdev->features[p][4], hdev->features[p][5], 142dfb826a8SMarcel Holtmann hdev->features[p][6], hdev->features[p][7]); 143dfb826a8SMarcel Holtmann } 144cfbb2b5bSMarcel Holtmann if (lmp_le_capable(hdev)) 145cfbb2b5bSMarcel Holtmann seq_printf(f, "LE: 0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x " 146cfbb2b5bSMarcel Holtmann "0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x\n", 147cfbb2b5bSMarcel Holtmann hdev->le_features[0], hdev->le_features[1], 148cfbb2b5bSMarcel Holtmann hdev->le_features[2], hdev->le_features[3], 149cfbb2b5bSMarcel Holtmann hdev->le_features[4], hdev->le_features[5], 150cfbb2b5bSMarcel Holtmann hdev->le_features[6], hdev->le_features[7]); 151dfb826a8SMarcel Holtmann hci_dev_unlock(hdev); 152dfb826a8SMarcel Holtmann 153dfb826a8SMarcel Holtmann return 0; 154dfb826a8SMarcel Holtmann } 155dfb826a8SMarcel Holtmann 156dfb826a8SMarcel Holtmann static int features_open(struct inode *inode, struct file *file) 157dfb826a8SMarcel Holtmann { 158dfb826a8SMarcel Holtmann return single_open(file, features_show, inode->i_private); 159dfb826a8SMarcel Holtmann } 160dfb826a8SMarcel Holtmann 161dfb826a8SMarcel Holtmann static const struct file_operations features_fops = { 162dfb826a8SMarcel Holtmann .open = features_open, 163dfb826a8SMarcel Holtmann .read = seq_read, 164dfb826a8SMarcel Holtmann .llseek = seq_lseek, 165dfb826a8SMarcel Holtmann .release = single_release, 166dfb826a8SMarcel Holtmann }; 167dfb826a8SMarcel Holtmann 16870afe0b8SMarcel Holtmann static int blacklist_show(struct seq_file *f, void *p) 16970afe0b8SMarcel Holtmann { 17070afe0b8SMarcel Holtmann struct hci_dev *hdev = f->private; 17170afe0b8SMarcel Holtmann struct bdaddr_list *b; 17270afe0b8SMarcel Holtmann 17370afe0b8SMarcel Holtmann hci_dev_lock(hdev); 17470afe0b8SMarcel Holtmann list_for_each_entry(b, &hdev->blacklist, list) 175b25f0785SMarcel Holtmann seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 17670afe0b8SMarcel Holtmann hci_dev_unlock(hdev); 17770afe0b8SMarcel Holtmann 17870afe0b8SMarcel Holtmann return 0; 17970afe0b8SMarcel Holtmann } 18070afe0b8SMarcel Holtmann 18170afe0b8SMarcel Holtmann static int blacklist_open(struct inode *inode, struct file *file) 18270afe0b8SMarcel Holtmann { 18370afe0b8SMarcel Holtmann return single_open(file, blacklist_show, inode->i_private); 18470afe0b8SMarcel Holtmann } 18570afe0b8SMarcel Holtmann 18670afe0b8SMarcel Holtmann static const struct file_operations blacklist_fops = { 18770afe0b8SMarcel Holtmann .open = blacklist_open, 18870afe0b8SMarcel Holtmann .read = seq_read, 18970afe0b8SMarcel Holtmann .llseek = seq_lseek, 19070afe0b8SMarcel Holtmann .release = single_release, 19170afe0b8SMarcel Holtmann }; 19270afe0b8SMarcel Holtmann 19347219839SMarcel Holtmann static int uuids_show(struct seq_file *f, void *p) 19447219839SMarcel Holtmann { 19547219839SMarcel Holtmann struct hci_dev *hdev = f->private; 19647219839SMarcel Holtmann struct bt_uuid *uuid; 19747219839SMarcel Holtmann 19847219839SMarcel Holtmann hci_dev_lock(hdev); 19947219839SMarcel Holtmann list_for_each_entry(uuid, &hdev->uuids, list) { 20058f01aa9SMarcel Holtmann u8 i, val[16]; 20147219839SMarcel Holtmann 20258f01aa9SMarcel Holtmann /* The Bluetooth UUID values are stored in big endian, 20358f01aa9SMarcel Holtmann * but with reversed byte order. So convert them into 20458f01aa9SMarcel Holtmann * the right order for the %pUb modifier. 20558f01aa9SMarcel Holtmann */ 20658f01aa9SMarcel Holtmann for (i = 0; i < 16; i++) 20758f01aa9SMarcel Holtmann val[i] = uuid->uuid[15 - i]; 20847219839SMarcel Holtmann 20958f01aa9SMarcel Holtmann seq_printf(f, "%pUb\n", val); 21047219839SMarcel Holtmann } 21147219839SMarcel Holtmann hci_dev_unlock(hdev); 21247219839SMarcel Holtmann 21347219839SMarcel Holtmann return 0; 21447219839SMarcel Holtmann } 21547219839SMarcel Holtmann 21647219839SMarcel Holtmann static int uuids_open(struct inode *inode, struct file *file) 21747219839SMarcel Holtmann { 21847219839SMarcel Holtmann return single_open(file, uuids_show, inode->i_private); 21947219839SMarcel Holtmann } 22047219839SMarcel Holtmann 22147219839SMarcel Holtmann static const struct file_operations uuids_fops = { 22247219839SMarcel Holtmann .open = uuids_open, 22347219839SMarcel Holtmann .read = seq_read, 22447219839SMarcel Holtmann .llseek = seq_lseek, 22547219839SMarcel Holtmann .release = single_release, 22647219839SMarcel Holtmann }; 22747219839SMarcel Holtmann 228baf27f6eSMarcel Holtmann static int inquiry_cache_show(struct seq_file *f, void *p) 229baf27f6eSMarcel Holtmann { 230baf27f6eSMarcel Holtmann struct hci_dev *hdev = f->private; 231baf27f6eSMarcel Holtmann struct discovery_state *cache = &hdev->discovery; 232baf27f6eSMarcel Holtmann struct inquiry_entry *e; 233baf27f6eSMarcel Holtmann 234baf27f6eSMarcel Holtmann hci_dev_lock(hdev); 235baf27f6eSMarcel Holtmann 236baf27f6eSMarcel Holtmann list_for_each_entry(e, &cache->all, all) { 237baf27f6eSMarcel Holtmann struct inquiry_data *data = &e->data; 238baf27f6eSMarcel Holtmann seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n", 239baf27f6eSMarcel Holtmann &data->bdaddr, 240baf27f6eSMarcel Holtmann data->pscan_rep_mode, data->pscan_period_mode, 241baf27f6eSMarcel Holtmann data->pscan_mode, data->dev_class[2], 242baf27f6eSMarcel Holtmann data->dev_class[1], data->dev_class[0], 243baf27f6eSMarcel Holtmann __le16_to_cpu(data->clock_offset), 244baf27f6eSMarcel Holtmann data->rssi, data->ssp_mode, e->timestamp); 245baf27f6eSMarcel Holtmann } 246baf27f6eSMarcel Holtmann 247baf27f6eSMarcel Holtmann hci_dev_unlock(hdev); 248baf27f6eSMarcel Holtmann 249baf27f6eSMarcel Holtmann return 0; 250baf27f6eSMarcel Holtmann } 251baf27f6eSMarcel Holtmann 252baf27f6eSMarcel Holtmann static int inquiry_cache_open(struct inode *inode, struct file *file) 253baf27f6eSMarcel Holtmann { 254baf27f6eSMarcel Holtmann return single_open(file, inquiry_cache_show, inode->i_private); 255baf27f6eSMarcel Holtmann } 256baf27f6eSMarcel Holtmann 257baf27f6eSMarcel Holtmann static const struct file_operations inquiry_cache_fops = { 258baf27f6eSMarcel Holtmann .open = inquiry_cache_open, 259baf27f6eSMarcel Holtmann .read = seq_read, 260baf27f6eSMarcel Holtmann .llseek = seq_lseek, 261baf27f6eSMarcel Holtmann .release = single_release, 262baf27f6eSMarcel Holtmann }; 263baf27f6eSMarcel Holtmann 26402d08d15SMarcel Holtmann static int link_keys_show(struct seq_file *f, void *ptr) 26502d08d15SMarcel Holtmann { 26602d08d15SMarcel Holtmann struct hci_dev *hdev = f->private; 26702d08d15SMarcel Holtmann struct list_head *p, *n; 26802d08d15SMarcel Holtmann 26902d08d15SMarcel Holtmann hci_dev_lock(hdev); 27002d08d15SMarcel Holtmann list_for_each_safe(p, n, &hdev->link_keys) { 27102d08d15SMarcel Holtmann struct link_key *key = list_entry(p, struct link_key, list); 27202d08d15SMarcel Holtmann seq_printf(f, "%pMR %u %*phN %u\n", &key->bdaddr, key->type, 27302d08d15SMarcel Holtmann HCI_LINK_KEY_SIZE, key->val, key->pin_len); 27402d08d15SMarcel Holtmann } 27502d08d15SMarcel Holtmann hci_dev_unlock(hdev); 27602d08d15SMarcel Holtmann 27702d08d15SMarcel Holtmann return 0; 27802d08d15SMarcel Holtmann } 27902d08d15SMarcel Holtmann 28002d08d15SMarcel Holtmann static int link_keys_open(struct inode *inode, struct file *file) 28102d08d15SMarcel Holtmann { 28202d08d15SMarcel Holtmann return single_open(file, link_keys_show, inode->i_private); 28302d08d15SMarcel Holtmann } 28402d08d15SMarcel Holtmann 28502d08d15SMarcel Holtmann static const struct file_operations link_keys_fops = { 28602d08d15SMarcel Holtmann .open = link_keys_open, 28702d08d15SMarcel Holtmann .read = seq_read, 28802d08d15SMarcel Holtmann .llseek = seq_lseek, 28902d08d15SMarcel Holtmann .release = single_release, 29002d08d15SMarcel Holtmann }; 29102d08d15SMarcel Holtmann 292babdbb3cSMarcel Holtmann static int dev_class_show(struct seq_file *f, void *ptr) 293babdbb3cSMarcel Holtmann { 294babdbb3cSMarcel Holtmann struct hci_dev *hdev = f->private; 295babdbb3cSMarcel Holtmann 296babdbb3cSMarcel Holtmann hci_dev_lock(hdev); 297babdbb3cSMarcel Holtmann seq_printf(f, "0x%.2x%.2x%.2x\n", hdev->dev_class[2], 298babdbb3cSMarcel Holtmann hdev->dev_class[1], hdev->dev_class[0]); 299babdbb3cSMarcel Holtmann hci_dev_unlock(hdev); 300babdbb3cSMarcel Holtmann 301babdbb3cSMarcel Holtmann return 0; 302babdbb3cSMarcel Holtmann } 303babdbb3cSMarcel Holtmann 304babdbb3cSMarcel Holtmann static int dev_class_open(struct inode *inode, struct file *file) 305babdbb3cSMarcel Holtmann { 306babdbb3cSMarcel Holtmann return single_open(file, dev_class_show, inode->i_private); 307babdbb3cSMarcel Holtmann } 308babdbb3cSMarcel Holtmann 309babdbb3cSMarcel Holtmann static const struct file_operations dev_class_fops = { 310babdbb3cSMarcel Holtmann .open = dev_class_open, 311babdbb3cSMarcel Holtmann .read = seq_read, 312babdbb3cSMarcel Holtmann .llseek = seq_lseek, 313babdbb3cSMarcel Holtmann .release = single_release, 314babdbb3cSMarcel Holtmann }; 315babdbb3cSMarcel Holtmann 316041000b9SMarcel Holtmann static int voice_setting_get(void *data, u64 *val) 317041000b9SMarcel Holtmann { 318041000b9SMarcel Holtmann struct hci_dev *hdev = data; 319041000b9SMarcel Holtmann 320041000b9SMarcel Holtmann hci_dev_lock(hdev); 321041000b9SMarcel Holtmann *val = hdev->voice_setting; 322041000b9SMarcel Holtmann hci_dev_unlock(hdev); 323041000b9SMarcel Holtmann 324041000b9SMarcel Holtmann return 0; 325041000b9SMarcel Holtmann } 326041000b9SMarcel Holtmann 327041000b9SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get, 328041000b9SMarcel Holtmann NULL, "0x%4.4llx\n"); 329041000b9SMarcel Holtmann 330ebd1e33bSMarcel Holtmann static int auto_accept_delay_set(void *data, u64 val) 331ebd1e33bSMarcel Holtmann { 332ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 333ebd1e33bSMarcel Holtmann 334ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 335ebd1e33bSMarcel Holtmann hdev->auto_accept_delay = val; 336ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 337ebd1e33bSMarcel Holtmann 338ebd1e33bSMarcel Holtmann return 0; 339ebd1e33bSMarcel Holtmann } 340ebd1e33bSMarcel Holtmann 341ebd1e33bSMarcel Holtmann static int auto_accept_delay_get(void *data, u64 *val) 342ebd1e33bSMarcel Holtmann { 343ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 344ebd1e33bSMarcel Holtmann 345ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 346ebd1e33bSMarcel Holtmann *val = hdev->auto_accept_delay; 347ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 348ebd1e33bSMarcel Holtmann 349ebd1e33bSMarcel Holtmann return 0; 350ebd1e33bSMarcel Holtmann } 351ebd1e33bSMarcel Holtmann 352ebd1e33bSMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get, 353ebd1e33bSMarcel Holtmann auto_accept_delay_set, "%llu\n"); 354ebd1e33bSMarcel Holtmann 3555afeac14SMarcel Holtmann static ssize_t force_sc_support_read(struct file *file, char __user *user_buf, 3565afeac14SMarcel Holtmann size_t count, loff_t *ppos) 3575afeac14SMarcel Holtmann { 3585afeac14SMarcel Holtmann struct hci_dev *hdev = file->private_data; 3595afeac14SMarcel Holtmann char buf[3]; 3605afeac14SMarcel Holtmann 361111902f7SMarcel Holtmann buf[0] = test_bit(HCI_FORCE_SC, &hdev->dbg_flags) ? 'Y': 'N'; 3625afeac14SMarcel Holtmann buf[1] = '\n'; 3635afeac14SMarcel Holtmann buf[2] = '\0'; 3645afeac14SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 3655afeac14SMarcel Holtmann } 3665afeac14SMarcel Holtmann 3675afeac14SMarcel Holtmann static ssize_t force_sc_support_write(struct file *file, 3685afeac14SMarcel Holtmann const char __user *user_buf, 3695afeac14SMarcel Holtmann size_t count, loff_t *ppos) 3705afeac14SMarcel Holtmann { 3715afeac14SMarcel Holtmann struct hci_dev *hdev = file->private_data; 3725afeac14SMarcel Holtmann char buf[32]; 3735afeac14SMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 3745afeac14SMarcel Holtmann bool enable; 3755afeac14SMarcel Holtmann 3765afeac14SMarcel Holtmann if (test_bit(HCI_UP, &hdev->flags)) 3775afeac14SMarcel Holtmann return -EBUSY; 3785afeac14SMarcel Holtmann 3795afeac14SMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 3805afeac14SMarcel Holtmann return -EFAULT; 3815afeac14SMarcel Holtmann 3825afeac14SMarcel Holtmann buf[buf_size] = '\0'; 3835afeac14SMarcel Holtmann if (strtobool(buf, &enable)) 3845afeac14SMarcel Holtmann return -EINVAL; 3855afeac14SMarcel Holtmann 386111902f7SMarcel Holtmann if (enable == test_bit(HCI_FORCE_SC, &hdev->dbg_flags)) 3875afeac14SMarcel Holtmann return -EALREADY; 3885afeac14SMarcel Holtmann 389111902f7SMarcel Holtmann change_bit(HCI_FORCE_SC, &hdev->dbg_flags); 3905afeac14SMarcel Holtmann 3915afeac14SMarcel Holtmann return count; 3925afeac14SMarcel Holtmann } 3935afeac14SMarcel Holtmann 3945afeac14SMarcel Holtmann static const struct file_operations force_sc_support_fops = { 3955afeac14SMarcel Holtmann .open = simple_open, 3965afeac14SMarcel Holtmann .read = force_sc_support_read, 3975afeac14SMarcel Holtmann .write = force_sc_support_write, 3985afeac14SMarcel Holtmann .llseek = default_llseek, 3995afeac14SMarcel Holtmann }; 4005afeac14SMarcel Holtmann 401134c2a89SMarcel Holtmann static ssize_t sc_only_mode_read(struct file *file, char __user *user_buf, 402134c2a89SMarcel Holtmann size_t count, loff_t *ppos) 403134c2a89SMarcel Holtmann { 404134c2a89SMarcel Holtmann struct hci_dev *hdev = file->private_data; 405134c2a89SMarcel Holtmann char buf[3]; 406134c2a89SMarcel Holtmann 407134c2a89SMarcel Holtmann buf[0] = test_bit(HCI_SC_ONLY, &hdev->dev_flags) ? 'Y': 'N'; 408134c2a89SMarcel Holtmann buf[1] = '\n'; 409134c2a89SMarcel Holtmann buf[2] = '\0'; 410134c2a89SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 411134c2a89SMarcel Holtmann } 412134c2a89SMarcel Holtmann 413134c2a89SMarcel Holtmann static const struct file_operations sc_only_mode_fops = { 414134c2a89SMarcel Holtmann .open = simple_open, 415134c2a89SMarcel Holtmann .read = sc_only_mode_read, 416134c2a89SMarcel Holtmann .llseek = default_llseek, 417134c2a89SMarcel Holtmann }; 418134c2a89SMarcel Holtmann 4192bfa3531SMarcel Holtmann static int idle_timeout_set(void *data, u64 val) 4202bfa3531SMarcel Holtmann { 4212bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4222bfa3531SMarcel Holtmann 4232bfa3531SMarcel Holtmann if (val != 0 && (val < 500 || val > 3600000)) 4242bfa3531SMarcel Holtmann return -EINVAL; 4252bfa3531SMarcel Holtmann 4262bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4272bfa3531SMarcel Holtmann hdev->idle_timeout = val; 4282bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4292bfa3531SMarcel Holtmann 4302bfa3531SMarcel Holtmann return 0; 4312bfa3531SMarcel Holtmann } 4322bfa3531SMarcel Holtmann 4332bfa3531SMarcel Holtmann static int idle_timeout_get(void *data, u64 *val) 4342bfa3531SMarcel Holtmann { 4352bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4362bfa3531SMarcel Holtmann 4372bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4382bfa3531SMarcel Holtmann *val = hdev->idle_timeout; 4392bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4402bfa3531SMarcel Holtmann 4412bfa3531SMarcel Holtmann return 0; 4422bfa3531SMarcel Holtmann } 4432bfa3531SMarcel Holtmann 4442bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get, 4452bfa3531SMarcel Holtmann idle_timeout_set, "%llu\n"); 4462bfa3531SMarcel Holtmann 447c982b2eaSJohan Hedberg static int rpa_timeout_set(void *data, u64 val) 448c982b2eaSJohan Hedberg { 449c982b2eaSJohan Hedberg struct hci_dev *hdev = data; 450c982b2eaSJohan Hedberg 451c982b2eaSJohan Hedberg /* Require the RPA timeout to be at least 30 seconds and at most 452c982b2eaSJohan Hedberg * 24 hours. 453c982b2eaSJohan Hedberg */ 454c982b2eaSJohan Hedberg if (val < 30 || val > (60 * 60 * 24)) 455c982b2eaSJohan Hedberg return -EINVAL; 456c982b2eaSJohan Hedberg 457c982b2eaSJohan Hedberg hci_dev_lock(hdev); 458c982b2eaSJohan Hedberg hdev->rpa_timeout = val; 459c982b2eaSJohan Hedberg hci_dev_unlock(hdev); 460c982b2eaSJohan Hedberg 461c982b2eaSJohan Hedberg return 0; 462c982b2eaSJohan Hedberg } 463c982b2eaSJohan Hedberg 464c982b2eaSJohan Hedberg static int rpa_timeout_get(void *data, u64 *val) 465c982b2eaSJohan Hedberg { 466c982b2eaSJohan Hedberg struct hci_dev *hdev = data; 467c982b2eaSJohan Hedberg 468c982b2eaSJohan Hedberg hci_dev_lock(hdev); 469c982b2eaSJohan Hedberg *val = hdev->rpa_timeout; 470c982b2eaSJohan Hedberg hci_dev_unlock(hdev); 471c982b2eaSJohan Hedberg 472c982b2eaSJohan Hedberg return 0; 473c982b2eaSJohan Hedberg } 474c982b2eaSJohan Hedberg 475c982b2eaSJohan Hedberg DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get, 476c982b2eaSJohan Hedberg rpa_timeout_set, "%llu\n"); 477c982b2eaSJohan Hedberg 4782bfa3531SMarcel Holtmann static int sniff_min_interval_set(void *data, u64 val) 4792bfa3531SMarcel Holtmann { 4802bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4812bfa3531SMarcel Holtmann 4822bfa3531SMarcel Holtmann if (val == 0 || val % 2 || val > hdev->sniff_max_interval) 4832bfa3531SMarcel Holtmann return -EINVAL; 4842bfa3531SMarcel Holtmann 4852bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4862bfa3531SMarcel Holtmann hdev->sniff_min_interval = val; 4872bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4882bfa3531SMarcel Holtmann 4892bfa3531SMarcel Holtmann return 0; 4902bfa3531SMarcel Holtmann } 4912bfa3531SMarcel Holtmann 4922bfa3531SMarcel Holtmann static int sniff_min_interval_get(void *data, u64 *val) 4932bfa3531SMarcel Holtmann { 4942bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4952bfa3531SMarcel Holtmann 4962bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4972bfa3531SMarcel Holtmann *val = hdev->sniff_min_interval; 4982bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4992bfa3531SMarcel Holtmann 5002bfa3531SMarcel Holtmann return 0; 5012bfa3531SMarcel Holtmann } 5022bfa3531SMarcel Holtmann 5032bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get, 5042bfa3531SMarcel Holtmann sniff_min_interval_set, "%llu\n"); 5052bfa3531SMarcel Holtmann 5062bfa3531SMarcel Holtmann static int sniff_max_interval_set(void *data, u64 val) 5072bfa3531SMarcel Holtmann { 5082bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 5092bfa3531SMarcel Holtmann 5102bfa3531SMarcel Holtmann if (val == 0 || val % 2 || val < hdev->sniff_min_interval) 5112bfa3531SMarcel Holtmann return -EINVAL; 5122bfa3531SMarcel Holtmann 5132bfa3531SMarcel Holtmann hci_dev_lock(hdev); 5142bfa3531SMarcel Holtmann hdev->sniff_max_interval = val; 5152bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 5162bfa3531SMarcel Holtmann 5172bfa3531SMarcel Holtmann return 0; 5182bfa3531SMarcel Holtmann } 5192bfa3531SMarcel Holtmann 5202bfa3531SMarcel Holtmann static int sniff_max_interval_get(void *data, u64 *val) 5212bfa3531SMarcel Holtmann { 5222bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 5232bfa3531SMarcel Holtmann 5242bfa3531SMarcel Holtmann hci_dev_lock(hdev); 5252bfa3531SMarcel Holtmann *val = hdev->sniff_max_interval; 5262bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 5272bfa3531SMarcel Holtmann 5282bfa3531SMarcel Holtmann return 0; 5292bfa3531SMarcel Holtmann } 5302bfa3531SMarcel Holtmann 5312bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get, 5322bfa3531SMarcel Holtmann sniff_max_interval_set, "%llu\n"); 5332bfa3531SMarcel Holtmann 53431ad1691SAndrzej Kaczmarek static int conn_info_min_age_set(void *data, u64 val) 53531ad1691SAndrzej Kaczmarek { 53631ad1691SAndrzej Kaczmarek struct hci_dev *hdev = data; 53731ad1691SAndrzej Kaczmarek 53831ad1691SAndrzej Kaczmarek if (val == 0 || val > hdev->conn_info_max_age) 53931ad1691SAndrzej Kaczmarek return -EINVAL; 54031ad1691SAndrzej Kaczmarek 54131ad1691SAndrzej Kaczmarek hci_dev_lock(hdev); 54231ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = val; 54331ad1691SAndrzej Kaczmarek hci_dev_unlock(hdev); 54431ad1691SAndrzej Kaczmarek 54531ad1691SAndrzej Kaczmarek return 0; 54631ad1691SAndrzej Kaczmarek } 54731ad1691SAndrzej Kaczmarek 54831ad1691SAndrzej Kaczmarek static int conn_info_min_age_get(void *data, u64 *val) 54931ad1691SAndrzej Kaczmarek { 55031ad1691SAndrzej Kaczmarek struct hci_dev *hdev = data; 55131ad1691SAndrzej Kaczmarek 55231ad1691SAndrzej Kaczmarek hci_dev_lock(hdev); 55331ad1691SAndrzej Kaczmarek *val = hdev->conn_info_min_age; 55431ad1691SAndrzej Kaczmarek hci_dev_unlock(hdev); 55531ad1691SAndrzej Kaczmarek 55631ad1691SAndrzej Kaczmarek return 0; 55731ad1691SAndrzej Kaczmarek } 55831ad1691SAndrzej Kaczmarek 55931ad1691SAndrzej Kaczmarek DEFINE_SIMPLE_ATTRIBUTE(conn_info_min_age_fops, conn_info_min_age_get, 56031ad1691SAndrzej Kaczmarek conn_info_min_age_set, "%llu\n"); 56131ad1691SAndrzej Kaczmarek 56231ad1691SAndrzej Kaczmarek static int conn_info_max_age_set(void *data, u64 val) 56331ad1691SAndrzej Kaczmarek { 56431ad1691SAndrzej Kaczmarek struct hci_dev *hdev = data; 56531ad1691SAndrzej Kaczmarek 56631ad1691SAndrzej Kaczmarek if (val == 0 || val < hdev->conn_info_min_age) 56731ad1691SAndrzej Kaczmarek return -EINVAL; 56831ad1691SAndrzej Kaczmarek 56931ad1691SAndrzej Kaczmarek hci_dev_lock(hdev); 57031ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = val; 57131ad1691SAndrzej Kaczmarek hci_dev_unlock(hdev); 57231ad1691SAndrzej Kaczmarek 57331ad1691SAndrzej Kaczmarek return 0; 57431ad1691SAndrzej Kaczmarek } 57531ad1691SAndrzej Kaczmarek 57631ad1691SAndrzej Kaczmarek static int conn_info_max_age_get(void *data, u64 *val) 57731ad1691SAndrzej Kaczmarek { 57831ad1691SAndrzej Kaczmarek struct hci_dev *hdev = data; 57931ad1691SAndrzej Kaczmarek 58031ad1691SAndrzej Kaczmarek hci_dev_lock(hdev); 58131ad1691SAndrzej Kaczmarek *val = hdev->conn_info_max_age; 58231ad1691SAndrzej Kaczmarek hci_dev_unlock(hdev); 58331ad1691SAndrzej Kaczmarek 58431ad1691SAndrzej Kaczmarek return 0; 58531ad1691SAndrzej Kaczmarek } 58631ad1691SAndrzej Kaczmarek 58731ad1691SAndrzej Kaczmarek DEFINE_SIMPLE_ATTRIBUTE(conn_info_max_age_fops, conn_info_max_age_get, 58831ad1691SAndrzej Kaczmarek conn_info_max_age_set, "%llu\n"); 58931ad1691SAndrzej Kaczmarek 590ac345813SMarcel Holtmann static int identity_show(struct seq_file *f, void *p) 591ac345813SMarcel Holtmann { 592ac345813SMarcel Holtmann struct hci_dev *hdev = f->private; 593a1f4c318SJohan Hedberg bdaddr_t addr; 594ac345813SMarcel Holtmann u8 addr_type; 595ac345813SMarcel Holtmann 596ac345813SMarcel Holtmann hci_dev_lock(hdev); 597ac345813SMarcel Holtmann 598a1f4c318SJohan Hedberg hci_copy_identity_address(hdev, &addr, &addr_type); 599ac345813SMarcel Holtmann 600a1f4c318SJohan Hedberg seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type, 601473deef2SMarcel Holtmann 16, hdev->irk, &hdev->rpa); 602ac345813SMarcel Holtmann 603ac345813SMarcel Holtmann hci_dev_unlock(hdev); 604ac345813SMarcel Holtmann 605ac345813SMarcel Holtmann return 0; 606ac345813SMarcel Holtmann } 607ac345813SMarcel Holtmann 608ac345813SMarcel Holtmann static int identity_open(struct inode *inode, struct file *file) 609ac345813SMarcel Holtmann { 610ac345813SMarcel Holtmann return single_open(file, identity_show, inode->i_private); 611ac345813SMarcel Holtmann } 612ac345813SMarcel Holtmann 613ac345813SMarcel Holtmann static const struct file_operations identity_fops = { 614ac345813SMarcel Holtmann .open = identity_open, 615ac345813SMarcel Holtmann .read = seq_read, 616ac345813SMarcel Holtmann .llseek = seq_lseek, 617ac345813SMarcel Holtmann .release = single_release, 618ac345813SMarcel Holtmann }; 619ac345813SMarcel Holtmann 6207a4cd51dSMarcel Holtmann static int random_address_show(struct seq_file *f, void *p) 6217a4cd51dSMarcel Holtmann { 6227a4cd51dSMarcel Holtmann struct hci_dev *hdev = f->private; 6237a4cd51dSMarcel Holtmann 6247a4cd51dSMarcel Holtmann hci_dev_lock(hdev); 6257a4cd51dSMarcel Holtmann seq_printf(f, "%pMR\n", &hdev->random_addr); 6267a4cd51dSMarcel Holtmann hci_dev_unlock(hdev); 6277a4cd51dSMarcel Holtmann 6287a4cd51dSMarcel Holtmann return 0; 6297a4cd51dSMarcel Holtmann } 6307a4cd51dSMarcel Holtmann 6317a4cd51dSMarcel Holtmann static int random_address_open(struct inode *inode, struct file *file) 6327a4cd51dSMarcel Holtmann { 6337a4cd51dSMarcel Holtmann return single_open(file, random_address_show, inode->i_private); 6347a4cd51dSMarcel Holtmann } 6357a4cd51dSMarcel Holtmann 6367a4cd51dSMarcel Holtmann static const struct file_operations random_address_fops = { 6377a4cd51dSMarcel Holtmann .open = random_address_open, 6387a4cd51dSMarcel Holtmann .read = seq_read, 6397a4cd51dSMarcel Holtmann .llseek = seq_lseek, 6407a4cd51dSMarcel Holtmann .release = single_release, 6417a4cd51dSMarcel Holtmann }; 6427a4cd51dSMarcel Holtmann 643e7b8fc92SMarcel Holtmann static int static_address_show(struct seq_file *f, void *p) 644e7b8fc92SMarcel Holtmann { 645e7b8fc92SMarcel Holtmann struct hci_dev *hdev = f->private; 646e7b8fc92SMarcel Holtmann 647e7b8fc92SMarcel Holtmann hci_dev_lock(hdev); 648e7b8fc92SMarcel Holtmann seq_printf(f, "%pMR\n", &hdev->static_addr); 649e7b8fc92SMarcel Holtmann hci_dev_unlock(hdev); 650e7b8fc92SMarcel Holtmann 651e7b8fc92SMarcel Holtmann return 0; 652e7b8fc92SMarcel Holtmann } 653e7b8fc92SMarcel Holtmann 654e7b8fc92SMarcel Holtmann static int static_address_open(struct inode *inode, struct file *file) 655e7b8fc92SMarcel Holtmann { 656e7b8fc92SMarcel Holtmann return single_open(file, static_address_show, inode->i_private); 657e7b8fc92SMarcel Holtmann } 658e7b8fc92SMarcel Holtmann 659e7b8fc92SMarcel Holtmann static const struct file_operations static_address_fops = { 660e7b8fc92SMarcel Holtmann .open = static_address_open, 661e7b8fc92SMarcel Holtmann .read = seq_read, 662e7b8fc92SMarcel Holtmann .llseek = seq_lseek, 663e7b8fc92SMarcel Holtmann .release = single_release, 664e7b8fc92SMarcel Holtmann }; 665e7b8fc92SMarcel Holtmann 666b32bba6cSMarcel Holtmann static ssize_t force_static_address_read(struct file *file, 667b32bba6cSMarcel Holtmann char __user *user_buf, 668b32bba6cSMarcel Holtmann size_t count, loff_t *ppos) 66992202185SMarcel Holtmann { 670b32bba6cSMarcel Holtmann struct hci_dev *hdev = file->private_data; 671b32bba6cSMarcel Holtmann char buf[3]; 67292202185SMarcel Holtmann 673111902f7SMarcel Holtmann buf[0] = test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) ? 'Y': 'N'; 674b32bba6cSMarcel Holtmann buf[1] = '\n'; 675b32bba6cSMarcel Holtmann buf[2] = '\0'; 676b32bba6cSMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 677b32bba6cSMarcel Holtmann } 678b32bba6cSMarcel Holtmann 679b32bba6cSMarcel Holtmann static ssize_t force_static_address_write(struct file *file, 680b32bba6cSMarcel Holtmann const char __user *user_buf, 681b32bba6cSMarcel Holtmann size_t count, loff_t *ppos) 682b32bba6cSMarcel Holtmann { 683b32bba6cSMarcel Holtmann struct hci_dev *hdev = file->private_data; 684b32bba6cSMarcel Holtmann char buf[32]; 685b32bba6cSMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 686b32bba6cSMarcel Holtmann bool enable; 687b32bba6cSMarcel Holtmann 688b32bba6cSMarcel Holtmann if (test_bit(HCI_UP, &hdev->flags)) 689b32bba6cSMarcel Holtmann return -EBUSY; 690b32bba6cSMarcel Holtmann 691b32bba6cSMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 692b32bba6cSMarcel Holtmann return -EFAULT; 693b32bba6cSMarcel Holtmann 694b32bba6cSMarcel Holtmann buf[buf_size] = '\0'; 695b32bba6cSMarcel Holtmann if (strtobool(buf, &enable)) 69692202185SMarcel Holtmann return -EINVAL; 69792202185SMarcel Holtmann 698111902f7SMarcel Holtmann if (enable == test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags)) 699b32bba6cSMarcel Holtmann return -EALREADY; 70092202185SMarcel Holtmann 701111902f7SMarcel Holtmann change_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags); 702b32bba6cSMarcel Holtmann 703b32bba6cSMarcel Holtmann return count; 70492202185SMarcel Holtmann } 70592202185SMarcel Holtmann 706b32bba6cSMarcel Holtmann static const struct file_operations force_static_address_fops = { 707b32bba6cSMarcel Holtmann .open = simple_open, 708b32bba6cSMarcel Holtmann .read = force_static_address_read, 709b32bba6cSMarcel Holtmann .write = force_static_address_write, 710b32bba6cSMarcel Holtmann .llseek = default_llseek, 711b32bba6cSMarcel Holtmann }; 71292202185SMarcel Holtmann 713d2ab0ac1SMarcel Holtmann static int white_list_show(struct seq_file *f, void *ptr) 714d2ab0ac1SMarcel Holtmann { 715d2ab0ac1SMarcel Holtmann struct hci_dev *hdev = f->private; 716d2ab0ac1SMarcel Holtmann struct bdaddr_list *b; 717d2ab0ac1SMarcel Holtmann 718d2ab0ac1SMarcel Holtmann hci_dev_lock(hdev); 719d2ab0ac1SMarcel Holtmann list_for_each_entry(b, &hdev->le_white_list, list) 720d2ab0ac1SMarcel Holtmann seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 721d2ab0ac1SMarcel Holtmann hci_dev_unlock(hdev); 722d2ab0ac1SMarcel Holtmann 723d2ab0ac1SMarcel Holtmann return 0; 724d2ab0ac1SMarcel Holtmann } 725d2ab0ac1SMarcel Holtmann 726d2ab0ac1SMarcel Holtmann static int white_list_open(struct inode *inode, struct file *file) 727d2ab0ac1SMarcel Holtmann { 728d2ab0ac1SMarcel Holtmann return single_open(file, white_list_show, inode->i_private); 729d2ab0ac1SMarcel Holtmann } 730d2ab0ac1SMarcel Holtmann 731d2ab0ac1SMarcel Holtmann static const struct file_operations white_list_fops = { 732d2ab0ac1SMarcel Holtmann .open = white_list_open, 733d2ab0ac1SMarcel Holtmann .read = seq_read, 734d2ab0ac1SMarcel Holtmann .llseek = seq_lseek, 735d2ab0ac1SMarcel Holtmann .release = single_release, 736d2ab0ac1SMarcel Holtmann }; 737d2ab0ac1SMarcel Holtmann 7383698d704SMarcel Holtmann static int identity_resolving_keys_show(struct seq_file *f, void *ptr) 7393698d704SMarcel Holtmann { 7403698d704SMarcel Holtmann struct hci_dev *hdev = f->private; 7413698d704SMarcel Holtmann struct list_head *p, *n; 7423698d704SMarcel Holtmann 7433698d704SMarcel Holtmann hci_dev_lock(hdev); 7443698d704SMarcel Holtmann list_for_each_safe(p, n, &hdev->identity_resolving_keys) { 7453698d704SMarcel Holtmann struct smp_irk *irk = list_entry(p, struct smp_irk, list); 7463698d704SMarcel Holtmann seq_printf(f, "%pMR (type %u) %*phN %pMR\n", 7473698d704SMarcel Holtmann &irk->bdaddr, irk->addr_type, 7483698d704SMarcel Holtmann 16, irk->val, &irk->rpa); 7493698d704SMarcel Holtmann } 7503698d704SMarcel Holtmann hci_dev_unlock(hdev); 7513698d704SMarcel Holtmann 7523698d704SMarcel Holtmann return 0; 7533698d704SMarcel Holtmann } 7543698d704SMarcel Holtmann 7553698d704SMarcel Holtmann static int identity_resolving_keys_open(struct inode *inode, struct file *file) 7563698d704SMarcel Holtmann { 7573698d704SMarcel Holtmann return single_open(file, identity_resolving_keys_show, 7583698d704SMarcel Holtmann inode->i_private); 7593698d704SMarcel Holtmann } 7603698d704SMarcel Holtmann 7613698d704SMarcel Holtmann static const struct file_operations identity_resolving_keys_fops = { 7623698d704SMarcel Holtmann .open = identity_resolving_keys_open, 7633698d704SMarcel Holtmann .read = seq_read, 7643698d704SMarcel Holtmann .llseek = seq_lseek, 7653698d704SMarcel Holtmann .release = single_release, 7663698d704SMarcel Holtmann }; 7673698d704SMarcel Holtmann 7688f8625cdSMarcel Holtmann static int long_term_keys_show(struct seq_file *f, void *ptr) 7698f8625cdSMarcel Holtmann { 7708f8625cdSMarcel Holtmann struct hci_dev *hdev = f->private; 7718f8625cdSMarcel Holtmann struct list_head *p, *n; 7728f8625cdSMarcel Holtmann 7738f8625cdSMarcel Holtmann hci_dev_lock(hdev); 774f813f1beSJohan Hedberg list_for_each_safe(p, n, &hdev->long_term_keys) { 7758f8625cdSMarcel Holtmann struct smp_ltk *ltk = list_entry(p, struct smp_ltk, list); 776fe39c7b2SMarcel Holtmann seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n", 7778f8625cdSMarcel Holtmann <k->bdaddr, ltk->bdaddr_type, ltk->authenticated, 7788f8625cdSMarcel Holtmann ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv), 779fe39c7b2SMarcel Holtmann __le64_to_cpu(ltk->rand), 16, ltk->val); 7808f8625cdSMarcel Holtmann } 7818f8625cdSMarcel Holtmann hci_dev_unlock(hdev); 7828f8625cdSMarcel Holtmann 7838f8625cdSMarcel Holtmann return 0; 7848f8625cdSMarcel Holtmann } 7858f8625cdSMarcel Holtmann 7868f8625cdSMarcel Holtmann static int long_term_keys_open(struct inode *inode, struct file *file) 7878f8625cdSMarcel Holtmann { 7888f8625cdSMarcel Holtmann return single_open(file, long_term_keys_show, inode->i_private); 7898f8625cdSMarcel Holtmann } 7908f8625cdSMarcel Holtmann 7918f8625cdSMarcel Holtmann static const struct file_operations long_term_keys_fops = { 7928f8625cdSMarcel Holtmann .open = long_term_keys_open, 7938f8625cdSMarcel Holtmann .read = seq_read, 7948f8625cdSMarcel Holtmann .llseek = seq_lseek, 7958f8625cdSMarcel Holtmann .release = single_release, 7968f8625cdSMarcel Holtmann }; 7978f8625cdSMarcel Holtmann 7984e70c7e7SMarcel Holtmann static int conn_min_interval_set(void *data, u64 val) 7994e70c7e7SMarcel Holtmann { 8004e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 8014e70c7e7SMarcel Holtmann 8024e70c7e7SMarcel Holtmann if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval) 8034e70c7e7SMarcel Holtmann return -EINVAL; 8044e70c7e7SMarcel Holtmann 8054e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 8064e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = val; 8074e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 8084e70c7e7SMarcel Holtmann 8094e70c7e7SMarcel Holtmann return 0; 8104e70c7e7SMarcel Holtmann } 8114e70c7e7SMarcel Holtmann 8124e70c7e7SMarcel Holtmann static int conn_min_interval_get(void *data, u64 *val) 8134e70c7e7SMarcel Holtmann { 8144e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 8154e70c7e7SMarcel Holtmann 8164e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 8174e70c7e7SMarcel Holtmann *val = hdev->le_conn_min_interval; 8184e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 8194e70c7e7SMarcel Holtmann 8204e70c7e7SMarcel Holtmann return 0; 8214e70c7e7SMarcel Holtmann } 8224e70c7e7SMarcel Holtmann 8234e70c7e7SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get, 8244e70c7e7SMarcel Holtmann conn_min_interval_set, "%llu\n"); 8254e70c7e7SMarcel Holtmann 8264e70c7e7SMarcel Holtmann static int conn_max_interval_set(void *data, u64 val) 8274e70c7e7SMarcel Holtmann { 8284e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 8294e70c7e7SMarcel Holtmann 8304e70c7e7SMarcel Holtmann if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval) 8314e70c7e7SMarcel Holtmann return -EINVAL; 8324e70c7e7SMarcel Holtmann 8334e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 8344e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = val; 8354e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 8364e70c7e7SMarcel Holtmann 8374e70c7e7SMarcel Holtmann return 0; 8384e70c7e7SMarcel Holtmann } 8394e70c7e7SMarcel Holtmann 8404e70c7e7SMarcel Holtmann static int conn_max_interval_get(void *data, u64 *val) 8414e70c7e7SMarcel Holtmann { 8424e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 8434e70c7e7SMarcel Holtmann 8444e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 8454e70c7e7SMarcel Holtmann *val = hdev->le_conn_max_interval; 8464e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 8474e70c7e7SMarcel Holtmann 8484e70c7e7SMarcel Holtmann return 0; 8494e70c7e7SMarcel Holtmann } 8504e70c7e7SMarcel Holtmann 8514e70c7e7SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get, 8524e70c7e7SMarcel Holtmann conn_max_interval_set, "%llu\n"); 8534e70c7e7SMarcel Holtmann 854816a93d1SMarcel Holtmann static int conn_latency_set(void *data, u64 val) 855816a93d1SMarcel Holtmann { 856816a93d1SMarcel Holtmann struct hci_dev *hdev = data; 857816a93d1SMarcel Holtmann 858816a93d1SMarcel Holtmann if (val > 0x01f3) 859816a93d1SMarcel Holtmann return -EINVAL; 860816a93d1SMarcel Holtmann 861816a93d1SMarcel Holtmann hci_dev_lock(hdev); 862816a93d1SMarcel Holtmann hdev->le_conn_latency = val; 863816a93d1SMarcel Holtmann hci_dev_unlock(hdev); 864816a93d1SMarcel Holtmann 865816a93d1SMarcel Holtmann return 0; 866816a93d1SMarcel Holtmann } 867816a93d1SMarcel Holtmann 868816a93d1SMarcel Holtmann static int conn_latency_get(void *data, u64 *val) 869816a93d1SMarcel Holtmann { 870816a93d1SMarcel Holtmann struct hci_dev *hdev = data; 871816a93d1SMarcel Holtmann 872816a93d1SMarcel Holtmann hci_dev_lock(hdev); 873816a93d1SMarcel Holtmann *val = hdev->le_conn_latency; 874816a93d1SMarcel Holtmann hci_dev_unlock(hdev); 875816a93d1SMarcel Holtmann 876816a93d1SMarcel Holtmann return 0; 877816a93d1SMarcel Holtmann } 878816a93d1SMarcel Holtmann 879816a93d1SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get, 880816a93d1SMarcel Holtmann conn_latency_set, "%llu\n"); 881816a93d1SMarcel Holtmann 882f1649577SMarcel Holtmann static int supervision_timeout_set(void *data, u64 val) 883f1649577SMarcel Holtmann { 884f1649577SMarcel Holtmann struct hci_dev *hdev = data; 885f1649577SMarcel Holtmann 886f1649577SMarcel Holtmann if (val < 0x000a || val > 0x0c80) 887f1649577SMarcel Holtmann return -EINVAL; 888f1649577SMarcel Holtmann 889f1649577SMarcel Holtmann hci_dev_lock(hdev); 890f1649577SMarcel Holtmann hdev->le_supv_timeout = val; 891f1649577SMarcel Holtmann hci_dev_unlock(hdev); 892f1649577SMarcel Holtmann 893f1649577SMarcel Holtmann return 0; 894f1649577SMarcel Holtmann } 895f1649577SMarcel Holtmann 896f1649577SMarcel Holtmann static int supervision_timeout_get(void *data, u64 *val) 897f1649577SMarcel Holtmann { 898f1649577SMarcel Holtmann struct hci_dev *hdev = data; 899f1649577SMarcel Holtmann 900f1649577SMarcel Holtmann hci_dev_lock(hdev); 901f1649577SMarcel Holtmann *val = hdev->le_supv_timeout; 902f1649577SMarcel Holtmann hci_dev_unlock(hdev); 903f1649577SMarcel Holtmann 904f1649577SMarcel Holtmann return 0; 905f1649577SMarcel Holtmann } 906f1649577SMarcel Holtmann 907f1649577SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get, 908f1649577SMarcel Holtmann supervision_timeout_set, "%llu\n"); 909f1649577SMarcel Holtmann 9103f959d46SMarcel Holtmann static int adv_channel_map_set(void *data, u64 val) 9113f959d46SMarcel Holtmann { 9123f959d46SMarcel Holtmann struct hci_dev *hdev = data; 9133f959d46SMarcel Holtmann 9143f959d46SMarcel Holtmann if (val < 0x01 || val > 0x07) 9153f959d46SMarcel Holtmann return -EINVAL; 9163f959d46SMarcel Holtmann 9173f959d46SMarcel Holtmann hci_dev_lock(hdev); 9183f959d46SMarcel Holtmann hdev->le_adv_channel_map = val; 9193f959d46SMarcel Holtmann hci_dev_unlock(hdev); 9203f959d46SMarcel Holtmann 9213f959d46SMarcel Holtmann return 0; 9223f959d46SMarcel Holtmann } 9233f959d46SMarcel Holtmann 9243f959d46SMarcel Holtmann static int adv_channel_map_get(void *data, u64 *val) 9253f959d46SMarcel Holtmann { 9263f959d46SMarcel Holtmann struct hci_dev *hdev = data; 9273f959d46SMarcel Holtmann 9283f959d46SMarcel Holtmann hci_dev_lock(hdev); 9293f959d46SMarcel Holtmann *val = hdev->le_adv_channel_map; 9303f959d46SMarcel Holtmann hci_dev_unlock(hdev); 9313f959d46SMarcel Holtmann 9323f959d46SMarcel Holtmann return 0; 9333f959d46SMarcel Holtmann } 9343f959d46SMarcel Holtmann 9353f959d46SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get, 9363f959d46SMarcel Holtmann adv_channel_map_set, "%llu\n"); 9373f959d46SMarcel Holtmann 9380b3c7d37SMarcel Holtmann static int device_list_show(struct seq_file *f, void *ptr) 9397d474e06SAndre Guedes { 9400b3c7d37SMarcel Holtmann struct hci_dev *hdev = f->private; 9417d474e06SAndre Guedes struct hci_conn_params *p; 9427d474e06SAndre Guedes 9437d474e06SAndre Guedes hci_dev_lock(hdev); 9447d474e06SAndre Guedes list_for_each_entry(p, &hdev->le_conn_params, list) { 9450b3c7d37SMarcel Holtmann seq_printf(f, "%pMR %u %u\n", &p->addr, p->addr_type, 9467d474e06SAndre Guedes p->auto_connect); 9477d474e06SAndre Guedes } 9487d474e06SAndre Guedes hci_dev_unlock(hdev); 9497d474e06SAndre Guedes 9507d474e06SAndre Guedes return 0; 9517d474e06SAndre Guedes } 9527d474e06SAndre Guedes 9530b3c7d37SMarcel Holtmann static int device_list_open(struct inode *inode, struct file *file) 9547d474e06SAndre Guedes { 9550b3c7d37SMarcel Holtmann return single_open(file, device_list_show, inode->i_private); 9567d474e06SAndre Guedes } 9577d474e06SAndre Guedes 9580b3c7d37SMarcel Holtmann static const struct file_operations device_list_fops = { 9590b3c7d37SMarcel Holtmann .open = device_list_open, 9607d474e06SAndre Guedes .read = seq_read, 9617d474e06SAndre Guedes .llseek = seq_lseek, 9627d474e06SAndre Guedes .release = single_release, 9637d474e06SAndre Guedes }; 9647d474e06SAndre Guedes 9651da177e4SLinus Torvalds /* ---- HCI requests ---- */ 9661da177e4SLinus Torvalds 96742c6b129SJohan Hedberg static void hci_req_sync_complete(struct hci_dev *hdev, u8 result) 9681da177e4SLinus Torvalds { 96942c6b129SJohan Hedberg BT_DBG("%s result 0x%2.2x", hdev->name, result); 97075fb0e32SJohan Hedberg 9711da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 9721da177e4SLinus Torvalds hdev->req_result = result; 9731da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 9741da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 9751da177e4SLinus Torvalds } 9761da177e4SLinus Torvalds } 9771da177e4SLinus Torvalds 9781da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 9791da177e4SLinus Torvalds { 9801da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 9811da177e4SLinus Torvalds 9821da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 9831da177e4SLinus Torvalds hdev->req_result = err; 9841da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 9851da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 9861da177e4SLinus Torvalds } 9871da177e4SLinus Torvalds } 9881da177e4SLinus Torvalds 98977a63e0aSFengguang Wu static struct sk_buff *hci_get_cmd_complete(struct hci_dev *hdev, u16 opcode, 99077a63e0aSFengguang Wu u8 event) 99175e84b7cSJohan Hedberg { 99275e84b7cSJohan Hedberg struct hci_ev_cmd_complete *ev; 99375e84b7cSJohan Hedberg struct hci_event_hdr *hdr; 99475e84b7cSJohan Hedberg struct sk_buff *skb; 99575e84b7cSJohan Hedberg 99675e84b7cSJohan Hedberg hci_dev_lock(hdev); 99775e84b7cSJohan Hedberg 99875e84b7cSJohan Hedberg skb = hdev->recv_evt; 99975e84b7cSJohan Hedberg hdev->recv_evt = NULL; 100075e84b7cSJohan Hedberg 100175e84b7cSJohan Hedberg hci_dev_unlock(hdev); 100275e84b7cSJohan Hedberg 100375e84b7cSJohan Hedberg if (!skb) 100475e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 100575e84b7cSJohan Hedberg 100675e84b7cSJohan Hedberg if (skb->len < sizeof(*hdr)) { 100775e84b7cSJohan Hedberg BT_ERR("Too short HCI event"); 100875e84b7cSJohan Hedberg goto failed; 100975e84b7cSJohan Hedberg } 101075e84b7cSJohan Hedberg 101175e84b7cSJohan Hedberg hdr = (void *) skb->data; 101275e84b7cSJohan Hedberg skb_pull(skb, HCI_EVENT_HDR_SIZE); 101375e84b7cSJohan Hedberg 10147b1abbbeSJohan Hedberg if (event) { 10157b1abbbeSJohan Hedberg if (hdr->evt != event) 10167b1abbbeSJohan Hedberg goto failed; 10177b1abbbeSJohan Hedberg return skb; 10187b1abbbeSJohan Hedberg } 10197b1abbbeSJohan Hedberg 102075e84b7cSJohan Hedberg if (hdr->evt != HCI_EV_CMD_COMPLETE) { 102175e84b7cSJohan Hedberg BT_DBG("Last event is not cmd complete (0x%2.2x)", hdr->evt); 102275e84b7cSJohan Hedberg goto failed; 102375e84b7cSJohan Hedberg } 102475e84b7cSJohan Hedberg 102575e84b7cSJohan Hedberg if (skb->len < sizeof(*ev)) { 102675e84b7cSJohan Hedberg BT_ERR("Too short cmd_complete event"); 102775e84b7cSJohan Hedberg goto failed; 102875e84b7cSJohan Hedberg } 102975e84b7cSJohan Hedberg 103075e84b7cSJohan Hedberg ev = (void *) skb->data; 103175e84b7cSJohan Hedberg skb_pull(skb, sizeof(*ev)); 103275e84b7cSJohan Hedberg 103375e84b7cSJohan Hedberg if (opcode == __le16_to_cpu(ev->opcode)) 103475e84b7cSJohan Hedberg return skb; 103575e84b7cSJohan Hedberg 103675e84b7cSJohan Hedberg BT_DBG("opcode doesn't match (0x%2.2x != 0x%2.2x)", opcode, 103775e84b7cSJohan Hedberg __le16_to_cpu(ev->opcode)); 103875e84b7cSJohan Hedberg 103975e84b7cSJohan Hedberg failed: 104075e84b7cSJohan Hedberg kfree_skb(skb); 104175e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 104275e84b7cSJohan Hedberg } 104375e84b7cSJohan Hedberg 10447b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, 104507dc93ddSJohan Hedberg const void *param, u8 event, u32 timeout) 104675e84b7cSJohan Hedberg { 104775e84b7cSJohan Hedberg DECLARE_WAITQUEUE(wait, current); 104875e84b7cSJohan Hedberg struct hci_request req; 104975e84b7cSJohan Hedberg int err = 0; 105075e84b7cSJohan Hedberg 105175e84b7cSJohan Hedberg BT_DBG("%s", hdev->name); 105275e84b7cSJohan Hedberg 105375e84b7cSJohan Hedberg hci_req_init(&req, hdev); 105475e84b7cSJohan Hedberg 10557b1abbbeSJohan Hedberg hci_req_add_ev(&req, opcode, plen, param, event); 105675e84b7cSJohan Hedberg 105775e84b7cSJohan Hedberg hdev->req_status = HCI_REQ_PEND; 105875e84b7cSJohan Hedberg 105975e84b7cSJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 106075e84b7cSJohan Hedberg if (err < 0) 106175e84b7cSJohan Hedberg return ERR_PTR(err); 106275e84b7cSJohan Hedberg 106375e84b7cSJohan Hedberg add_wait_queue(&hdev->req_wait_q, &wait); 106475e84b7cSJohan Hedberg set_current_state(TASK_INTERRUPTIBLE); 106575e84b7cSJohan Hedberg 106675e84b7cSJohan Hedberg schedule_timeout(timeout); 106775e84b7cSJohan Hedberg 106875e84b7cSJohan Hedberg remove_wait_queue(&hdev->req_wait_q, &wait); 106975e84b7cSJohan Hedberg 107075e84b7cSJohan Hedberg if (signal_pending(current)) 107175e84b7cSJohan Hedberg return ERR_PTR(-EINTR); 107275e84b7cSJohan Hedberg 107375e84b7cSJohan Hedberg switch (hdev->req_status) { 107475e84b7cSJohan Hedberg case HCI_REQ_DONE: 107575e84b7cSJohan Hedberg err = -bt_to_errno(hdev->req_result); 107675e84b7cSJohan Hedberg break; 107775e84b7cSJohan Hedberg 107875e84b7cSJohan Hedberg case HCI_REQ_CANCELED: 107975e84b7cSJohan Hedberg err = -hdev->req_result; 108075e84b7cSJohan Hedberg break; 108175e84b7cSJohan Hedberg 108275e84b7cSJohan Hedberg default: 108375e84b7cSJohan Hedberg err = -ETIMEDOUT; 108475e84b7cSJohan Hedberg break; 108575e84b7cSJohan Hedberg } 108675e84b7cSJohan Hedberg 108775e84b7cSJohan Hedberg hdev->req_status = hdev->req_result = 0; 108875e84b7cSJohan Hedberg 108975e84b7cSJohan Hedberg BT_DBG("%s end: err %d", hdev->name, err); 109075e84b7cSJohan Hedberg 109175e84b7cSJohan Hedberg if (err < 0) 109275e84b7cSJohan Hedberg return ERR_PTR(err); 109375e84b7cSJohan Hedberg 10947b1abbbeSJohan Hedberg return hci_get_cmd_complete(hdev, opcode, event); 10957b1abbbeSJohan Hedberg } 10967b1abbbeSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync_ev); 10977b1abbbeSJohan Hedberg 10987b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 109907dc93ddSJohan Hedberg const void *param, u32 timeout) 11007b1abbbeSJohan Hedberg { 11017b1abbbeSJohan Hedberg return __hci_cmd_sync_ev(hdev, opcode, plen, param, 0, timeout); 110275e84b7cSJohan Hedberg } 110375e84b7cSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync); 110475e84b7cSJohan Hedberg 11051da177e4SLinus Torvalds /* Execute request and wait for completion. */ 110601178cd4SJohan Hedberg static int __hci_req_sync(struct hci_dev *hdev, 110742c6b129SJohan Hedberg void (*func)(struct hci_request *req, 110842c6b129SJohan Hedberg unsigned long opt), 11091da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 11101da177e4SLinus Torvalds { 111142c6b129SJohan Hedberg struct hci_request req; 11121da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 11131da177e4SLinus Torvalds int err = 0; 11141da177e4SLinus Torvalds 11151da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 11161da177e4SLinus Torvalds 111742c6b129SJohan Hedberg hci_req_init(&req, hdev); 111842c6b129SJohan Hedberg 11191da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 11201da177e4SLinus Torvalds 112142c6b129SJohan Hedberg func(&req, opt); 112253cce22dSJohan Hedberg 112342c6b129SJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 112442c6b129SJohan Hedberg if (err < 0) { 112553cce22dSJohan Hedberg hdev->req_status = 0; 1126920c8300SAndre Guedes 1127920c8300SAndre Guedes /* ENODATA means the HCI request command queue is empty. 1128920c8300SAndre Guedes * This can happen when a request with conditionals doesn't 1129920c8300SAndre Guedes * trigger any commands to be sent. This is normal behavior 1130920c8300SAndre Guedes * and should not trigger an error return. 113142c6b129SJohan Hedberg */ 1132920c8300SAndre Guedes if (err == -ENODATA) 113342c6b129SJohan Hedberg return 0; 1134920c8300SAndre Guedes 1135920c8300SAndre Guedes return err; 113653cce22dSJohan Hedberg } 113753cce22dSJohan Hedberg 1138bc4445c7SAndre Guedes add_wait_queue(&hdev->req_wait_q, &wait); 1139bc4445c7SAndre Guedes set_current_state(TASK_INTERRUPTIBLE); 1140bc4445c7SAndre Guedes 11411da177e4SLinus Torvalds schedule_timeout(timeout); 11421da177e4SLinus Torvalds 11431da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 11441da177e4SLinus Torvalds 11451da177e4SLinus Torvalds if (signal_pending(current)) 11461da177e4SLinus Torvalds return -EINTR; 11471da177e4SLinus Torvalds 11481da177e4SLinus Torvalds switch (hdev->req_status) { 11491da177e4SLinus Torvalds case HCI_REQ_DONE: 1150e175072fSJoe Perches err = -bt_to_errno(hdev->req_result); 11511da177e4SLinus Torvalds break; 11521da177e4SLinus Torvalds 11531da177e4SLinus Torvalds case HCI_REQ_CANCELED: 11541da177e4SLinus Torvalds err = -hdev->req_result; 11551da177e4SLinus Torvalds break; 11561da177e4SLinus Torvalds 11571da177e4SLinus Torvalds default: 11581da177e4SLinus Torvalds err = -ETIMEDOUT; 11591da177e4SLinus Torvalds break; 11603ff50b79SStephen Hemminger } 11611da177e4SLinus Torvalds 1162a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 11631da177e4SLinus Torvalds 11641da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 11651da177e4SLinus Torvalds 11661da177e4SLinus Torvalds return err; 11671da177e4SLinus Torvalds } 11681da177e4SLinus Torvalds 116901178cd4SJohan Hedberg static int hci_req_sync(struct hci_dev *hdev, 117042c6b129SJohan Hedberg void (*req)(struct hci_request *req, 117142c6b129SJohan Hedberg unsigned long opt), 11721da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 11731da177e4SLinus Torvalds { 11741da177e4SLinus Torvalds int ret; 11751da177e4SLinus Torvalds 11767c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 11777c6a329eSMarcel Holtmann return -ENETDOWN; 11787c6a329eSMarcel Holtmann 11791da177e4SLinus Torvalds /* Serialize all requests */ 11801da177e4SLinus Torvalds hci_req_lock(hdev); 118101178cd4SJohan Hedberg ret = __hci_req_sync(hdev, req, opt, timeout); 11821da177e4SLinus Torvalds hci_req_unlock(hdev); 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds return ret; 11851da177e4SLinus Torvalds } 11861da177e4SLinus Torvalds 118742c6b129SJohan Hedberg static void hci_reset_req(struct hci_request *req, unsigned long opt) 11881da177e4SLinus Torvalds { 118942c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 11901da177e4SLinus Torvalds 11911da177e4SLinus Torvalds /* Reset device */ 119242c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 119342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 11941da177e4SLinus Torvalds } 11951da177e4SLinus Torvalds 119642c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 11971da177e4SLinus Torvalds { 119842c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 11992455a3eaSAndrei Emeltchenko 12001da177e4SLinus Torvalds /* Read Local Supported Features */ 120142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 12021da177e4SLinus Torvalds 12031143e5a6SMarcel Holtmann /* Read Local Version */ 120442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 12052177bab5SJohan Hedberg 12062177bab5SJohan Hedberg /* Read BD Address */ 120742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 12081da177e4SLinus Torvalds } 12091da177e4SLinus Torvalds 121042c6b129SJohan Hedberg static void amp_init(struct hci_request *req) 1211e61ef499SAndrei Emeltchenko { 121242c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 12132455a3eaSAndrei Emeltchenko 1214e61ef499SAndrei Emeltchenko /* Read Local Version */ 121542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 12166bcbc489SAndrei Emeltchenko 1217f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 1218f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 1219f6996cfeSMarcel Holtmann 1220f6996cfeSMarcel Holtmann /* Read Local Supported Features */ 1221f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 1222f6996cfeSMarcel Holtmann 12236bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 122442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 1225e71dfabaSAndrei Emeltchenko 1226e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 122742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 12287528ca1cSMarcel Holtmann 1229f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 1230f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 1231f38ba941SMarcel Holtmann 12327528ca1cSMarcel Holtmann /* Read Location Data */ 12337528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 1234e61ef499SAndrei Emeltchenko } 1235e61ef499SAndrei Emeltchenko 123642c6b129SJohan Hedberg static void hci_init1_req(struct hci_request *req, unsigned long opt) 1237e61ef499SAndrei Emeltchenko { 123842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 1239e61ef499SAndrei Emeltchenko 1240e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 1241e61ef499SAndrei Emeltchenko 124211778716SAndrei Emeltchenko /* Reset */ 124311778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 124442c6b129SJohan Hedberg hci_reset_req(req, 0); 124511778716SAndrei Emeltchenko 1246e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 1247e61ef499SAndrei Emeltchenko case HCI_BREDR: 124842c6b129SJohan Hedberg bredr_init(req); 1249e61ef499SAndrei Emeltchenko break; 1250e61ef499SAndrei Emeltchenko 1251e61ef499SAndrei Emeltchenko case HCI_AMP: 125242c6b129SJohan Hedberg amp_init(req); 1253e61ef499SAndrei Emeltchenko break; 1254e61ef499SAndrei Emeltchenko 1255e61ef499SAndrei Emeltchenko default: 1256e61ef499SAndrei Emeltchenko BT_ERR("Unknown device type %d", hdev->dev_type); 1257e61ef499SAndrei Emeltchenko break; 1258e61ef499SAndrei Emeltchenko } 1259e61ef499SAndrei Emeltchenko } 1260e61ef499SAndrei Emeltchenko 126142c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 12622177bab5SJohan Hedberg { 12634ca048e3SMarcel Holtmann struct hci_dev *hdev = req->hdev; 12644ca048e3SMarcel Holtmann 12652177bab5SJohan Hedberg __le16 param; 12662177bab5SJohan Hedberg __u8 flt_type; 12672177bab5SJohan Hedberg 12682177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 126942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 12702177bab5SJohan Hedberg 12712177bab5SJohan Hedberg /* Read Class of Device */ 127242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 12732177bab5SJohan Hedberg 12742177bab5SJohan Hedberg /* Read Local Name */ 127542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 12762177bab5SJohan Hedberg 12772177bab5SJohan Hedberg /* Read Voice Setting */ 127842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 12792177bab5SJohan Hedberg 1280b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 1281b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 1282b4cb9fb2SMarcel Holtmann 12834b836f39SMarcel Holtmann /* Read Current IAC LAP */ 12844b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 12854b836f39SMarcel Holtmann 12862177bab5SJohan Hedberg /* Clear Event Filters */ 12872177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 128842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 12892177bab5SJohan Hedberg 12902177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 1291dcf4adbfSJoe Perches param = cpu_to_le16(0x7d00); 129242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 12932177bab5SJohan Hedberg 12944ca048e3SMarcel Holtmann /* AVM Berlin (31), aka "BlueFRITZ!", reports version 1.2, 12954ca048e3SMarcel Holtmann * but it does not support page scan related HCI commands. 12964ca048e3SMarcel Holtmann */ 12974ca048e3SMarcel Holtmann if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) { 1298f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 1299f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 1300f332ec66SJohan Hedberg } 13012177bab5SJohan Hedberg } 13022177bab5SJohan Hedberg 130342c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 13042177bab5SJohan Hedberg { 1305c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 1306c73eee91SJohan Hedberg 13072177bab5SJohan Hedberg /* Read LE Buffer Size */ 130842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 13092177bab5SJohan Hedberg 13102177bab5SJohan Hedberg /* Read LE Local Supported Features */ 131142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 13122177bab5SJohan Hedberg 1313747d3f03SMarcel Holtmann /* Read LE Supported States */ 1314747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 1315747d3f03SMarcel Holtmann 13162177bab5SJohan Hedberg /* Read LE Advertising Channel TX Power */ 131742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 13182177bab5SJohan Hedberg 13192177bab5SJohan Hedberg /* Read LE White List Size */ 132042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 0, NULL); 13212177bab5SJohan Hedberg 1322747d3f03SMarcel Holtmann /* Clear LE White List */ 1323747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 1324c73eee91SJohan Hedberg 1325c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 1326c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1327c73eee91SJohan Hedberg set_bit(HCI_LE_ENABLED, &hdev->dev_flags); 13282177bab5SJohan Hedberg } 13292177bab5SJohan Hedberg 13302177bab5SJohan Hedberg static u8 hci_get_inquiry_mode(struct hci_dev *hdev) 13312177bab5SJohan Hedberg { 13322177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 13332177bab5SJohan Hedberg return 0x02; 13342177bab5SJohan Hedberg 13352177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 13362177bab5SJohan Hedberg return 0x01; 13372177bab5SJohan Hedberg 13382177bab5SJohan Hedberg if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 && 13392177bab5SJohan Hedberg hdev->lmp_subver == 0x0757) 13402177bab5SJohan Hedberg return 0x01; 13412177bab5SJohan Hedberg 13422177bab5SJohan Hedberg if (hdev->manufacturer == 15) { 13432177bab5SJohan Hedberg if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963) 13442177bab5SJohan Hedberg return 0x01; 13452177bab5SJohan Hedberg if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963) 13462177bab5SJohan Hedberg return 0x01; 13472177bab5SJohan Hedberg if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965) 13482177bab5SJohan Hedberg return 0x01; 13492177bab5SJohan Hedberg } 13502177bab5SJohan Hedberg 13512177bab5SJohan Hedberg if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 && 13522177bab5SJohan Hedberg hdev->lmp_subver == 0x1805) 13532177bab5SJohan Hedberg return 0x01; 13542177bab5SJohan Hedberg 13552177bab5SJohan Hedberg return 0x00; 13562177bab5SJohan Hedberg } 13572177bab5SJohan Hedberg 135842c6b129SJohan Hedberg static void hci_setup_inquiry_mode(struct hci_request *req) 13592177bab5SJohan Hedberg { 13602177bab5SJohan Hedberg u8 mode; 13612177bab5SJohan Hedberg 136242c6b129SJohan Hedberg mode = hci_get_inquiry_mode(req->hdev); 13632177bab5SJohan Hedberg 136442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 13652177bab5SJohan Hedberg } 13662177bab5SJohan Hedberg 136742c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 13682177bab5SJohan Hedberg { 136942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 137042c6b129SJohan Hedberg 13712177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 13722177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 13732177bab5SJohan Hedberg * command otherwise. 13742177bab5SJohan Hedberg */ 13752177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 13762177bab5SJohan Hedberg 13772177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 13782177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 13792177bab5SJohan Hedberg */ 13802177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 13812177bab5SJohan Hedberg return; 13822177bab5SJohan Hedberg 13832177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 13842177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 13852177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 13862177bab5SJohan Hedberg events[4] |= 0x04; /* Read Remote Extended Features Complete */ 13872177bab5SJohan Hedberg events[5] |= 0x08; /* Synchronous Connection Complete */ 13882177bab5SJohan Hedberg events[5] |= 0x10; /* Synchronous Connection Changed */ 1389c7882cbdSMarcel Holtmann } else { 1390c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 1391c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 1392c7882cbdSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 1393c7882cbdSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 1394c7882cbdSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information Complete */ 1395c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 1396c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 1397c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 1398c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 1399c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 1400c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 14012177bab5SJohan Hedberg } 14022177bab5SJohan Hedberg 14032177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 14042177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 14052177bab5SJohan Hedberg 14062177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 14072177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 14082177bab5SJohan Hedberg 14092177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 14102177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 14112177bab5SJohan Hedberg 14122177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 14132177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 14142177bab5SJohan Hedberg 14152177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 14162177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 14172177bab5SJohan Hedberg 14182177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 14192177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 14202177bab5SJohan Hedberg 14212177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 14222177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 14232177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 14242177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 14252177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 14262177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 14272177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 14282177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 14292177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 14302177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 14312177bab5SJohan Hedberg * Features Notification 14322177bab5SJohan Hedberg */ 14332177bab5SJohan Hedberg } 14342177bab5SJohan Hedberg 14352177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 14362177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 14372177bab5SJohan Hedberg 143842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 14392177bab5SJohan Hedberg 14402177bab5SJohan Hedberg if (lmp_le_capable(hdev)) { 14412177bab5SJohan Hedberg memset(events, 0, sizeof(events)); 14422177bab5SJohan Hedberg events[0] = 0x1f; 144342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, 14442177bab5SJohan Hedberg sizeof(events), events); 14452177bab5SJohan Hedberg } 14462177bab5SJohan Hedberg } 14472177bab5SJohan Hedberg 144842c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 14492177bab5SJohan Hedberg { 145042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 145142c6b129SJohan Hedberg 14522177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 145342c6b129SJohan Hedberg bredr_setup(req); 145456f87901SJohan Hedberg else 145556f87901SJohan Hedberg clear_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 14562177bab5SJohan Hedberg 14572177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 145842c6b129SJohan Hedberg le_setup(req); 14592177bab5SJohan Hedberg 146042c6b129SJohan Hedberg hci_setup_event_mask(req); 14612177bab5SJohan Hedberg 14623f8e2d75SJohan Hedberg /* AVM Berlin (31), aka "BlueFRITZ!", doesn't support the read 14633f8e2d75SJohan Hedberg * local supported commands HCI command. 14643f8e2d75SJohan Hedberg */ 14653f8e2d75SJohan Hedberg if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) 146642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 14672177bab5SJohan Hedberg 14682177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 146957af75a8SMarcel Holtmann /* When SSP is available, then the host features page 147057af75a8SMarcel Holtmann * should also be available as well. However some 147157af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 147257af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 147357af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 147457af75a8SMarcel Holtmann */ 147557af75a8SMarcel Holtmann hdev->max_page = 0x01; 147657af75a8SMarcel Holtmann 14772177bab5SJohan Hedberg if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) { 14782177bab5SJohan Hedberg u8 mode = 0x01; 147942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 14802177bab5SJohan Hedberg sizeof(mode), &mode); 14812177bab5SJohan Hedberg } else { 14822177bab5SJohan Hedberg struct hci_cp_write_eir cp; 14832177bab5SJohan Hedberg 14842177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 14852177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 14862177bab5SJohan Hedberg 148742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 14882177bab5SJohan Hedberg } 14892177bab5SJohan Hedberg } 14902177bab5SJohan Hedberg 14912177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 149242c6b129SJohan Hedberg hci_setup_inquiry_mode(req); 14932177bab5SJohan Hedberg 14942177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 149542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 14962177bab5SJohan Hedberg 14972177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 14982177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 14992177bab5SJohan Hedberg 15002177bab5SJohan Hedberg cp.page = 0x01; 150142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 150242c6b129SJohan Hedberg sizeof(cp), &cp); 15032177bab5SJohan Hedberg } 15042177bab5SJohan Hedberg 15052177bab5SJohan Hedberg if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) { 15062177bab5SJohan Hedberg u8 enable = 1; 150742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 15082177bab5SJohan Hedberg &enable); 15092177bab5SJohan Hedberg } 15102177bab5SJohan Hedberg } 15112177bab5SJohan Hedberg 151242c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 15132177bab5SJohan Hedberg { 151442c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 15152177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 15162177bab5SJohan Hedberg u16 link_policy = 0; 15172177bab5SJohan Hedberg 15182177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 15192177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 15202177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 15212177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 15222177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 15232177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 15242177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 15252177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 15262177bab5SJohan Hedberg 15272177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 152842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 15292177bab5SJohan Hedberg } 15302177bab5SJohan Hedberg 153142c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 15322177bab5SJohan Hedberg { 153342c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 15342177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 15352177bab5SJohan Hedberg 1536c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 1537c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1538c73eee91SJohan Hedberg return; 1539c73eee91SJohan Hedberg 15402177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 15412177bab5SJohan Hedberg 15422177bab5SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) { 15432177bab5SJohan Hedberg cp.le = 0x01; 15442177bab5SJohan Hedberg cp.simul = lmp_le_br_capable(hdev); 15452177bab5SJohan Hedberg } 15462177bab5SJohan Hedberg 15472177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 154842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 15492177bab5SJohan Hedberg &cp); 15502177bab5SJohan Hedberg } 15512177bab5SJohan Hedberg 1552d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 1553d62e6d67SJohan Hedberg { 1554d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 1555d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 1556d62e6d67SJohan Hedberg 1557d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 1558d62e6d67SJohan Hedberg * enable all necessary events for it. 1559d62e6d67SJohan Hedberg */ 156053b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 1561d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 1562d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 1563d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 1564d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 1565d62e6d67SJohan Hedberg } 1566d62e6d67SJohan Hedberg 1567d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 1568d62e6d67SJohan Hedberg * enable all necessary events for it. 1569d62e6d67SJohan Hedberg */ 157053b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 1571d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 1572d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 1573d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 1574d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 1575d62e6d67SJohan Hedberg } 1576d62e6d67SJohan Hedberg 157740c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 157840c59fcbSMarcel Holtmann if (lmp_ping_capable(hdev)) 157940c59fcbSMarcel Holtmann events[2] |= 0x80; 158040c59fcbSMarcel Holtmann 1581d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 1582d62e6d67SJohan Hedberg } 1583d62e6d67SJohan Hedberg 158442c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 15852177bab5SJohan Hedberg { 158642c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 1587d2c5d77fSJohan Hedberg u8 p; 158842c6b129SJohan Hedberg 1589b8f4e068SGustavo Padovan /* Some Broadcom based Bluetooth controllers do not support the 1590b8f4e068SGustavo Padovan * Delete Stored Link Key command. They are clearly indicating its 1591b8f4e068SGustavo Padovan * absence in the bit mask of supported commands. 1592b8f4e068SGustavo Padovan * 1593b8f4e068SGustavo Padovan * Check the supported commands and only if the the command is marked 1594b8f4e068SGustavo Padovan * as supported send it. If not supported assume that the controller 1595b8f4e068SGustavo Padovan * does not have actual support for stored link keys which makes this 1596b8f4e068SGustavo Padovan * command redundant anyway. 1597f9f462faSMarcel Holtmann * 1598f9f462faSMarcel Holtmann * Some controllers indicate that they support handling deleting 1599f9f462faSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 1600f9f462faSMarcel Holtmann * just disable this command. 1601b8f4e068SGustavo Padovan */ 1602f9f462faSMarcel Holtmann if (hdev->commands[6] & 0x80 && 1603f9f462faSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 160459f45d57SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 160559f45d57SJohan Hedberg 160659f45d57SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 160759f45d57SJohan Hedberg cp.delete_all = 0x01; 160859f45d57SJohan Hedberg hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 160959f45d57SJohan Hedberg sizeof(cp), &cp); 161059f45d57SJohan Hedberg } 161159f45d57SJohan Hedberg 16122177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 161342c6b129SJohan Hedberg hci_setup_link_policy(req); 16142177bab5SJohan Hedberg 16157bf32048SJohan Hedberg if (lmp_le_capable(hdev)) 161642c6b129SJohan Hedberg hci_set_le_support(req); 1617d2c5d77fSJohan Hedberg 1618d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 1619d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 1620d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 1621d2c5d77fSJohan Hedberg 1622d2c5d77fSJohan Hedberg cp.page = p; 1623d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 1624d2c5d77fSJohan Hedberg sizeof(cp), &cp); 1625d2c5d77fSJohan Hedberg } 16262177bab5SJohan Hedberg } 16272177bab5SJohan Hedberg 16285d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 16295d4e7e8dSJohan Hedberg { 16305d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 16315d4e7e8dSJohan Hedberg 1632d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 1633d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 1634d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 1635d62e6d67SJohan Hedberg 16365d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 163753b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 16385d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 1639a6d0d690SMarcel Holtmann 1640a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 16415afeac14SMarcel Holtmann if ((lmp_sc_capable(hdev) || 1642111902f7SMarcel Holtmann test_bit(HCI_FORCE_SC, &hdev->dbg_flags)) && 1643a6d0d690SMarcel Holtmann test_bit(HCI_SC_ENABLED, &hdev->dev_flags)) { 1644a6d0d690SMarcel Holtmann u8 support = 0x01; 1645a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 1646a6d0d690SMarcel Holtmann sizeof(support), &support); 1647a6d0d690SMarcel Holtmann } 16485d4e7e8dSJohan Hedberg } 16495d4e7e8dSJohan Hedberg 16502177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 16512177bab5SJohan Hedberg { 16522177bab5SJohan Hedberg int err; 16532177bab5SJohan Hedberg 16542177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 16552177bab5SJohan Hedberg if (err < 0) 16562177bab5SJohan Hedberg return err; 16572177bab5SJohan Hedberg 16584b4148e9SMarcel Holtmann /* The Device Under Test (DUT) mode is special and available for 16594b4148e9SMarcel Holtmann * all controller types. So just create it early on. 16604b4148e9SMarcel Holtmann */ 16614b4148e9SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 16624b4148e9SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 16634b4148e9SMarcel Holtmann &dut_mode_fops); 16644b4148e9SMarcel Holtmann } 16654b4148e9SMarcel Holtmann 16662177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 16672177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 16682177bab5SJohan Hedberg * first stage init. 16692177bab5SJohan Hedberg */ 16702177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 16712177bab5SJohan Hedberg return 0; 16722177bab5SJohan Hedberg 16732177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 16742177bab5SJohan Hedberg if (err < 0) 16752177bab5SJohan Hedberg return err; 16762177bab5SJohan Hedberg 16775d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 16785d4e7e8dSJohan Hedberg if (err < 0) 16795d4e7e8dSJohan Hedberg return err; 16805d4e7e8dSJohan Hedberg 1681baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 1682baf27f6eSMarcel Holtmann if (err < 0) 1683baf27f6eSMarcel Holtmann return err; 1684baf27f6eSMarcel Holtmann 1685baf27f6eSMarcel Holtmann /* Only create debugfs entries during the initial setup 1686baf27f6eSMarcel Holtmann * phase and not every time the controller gets powered on. 1687baf27f6eSMarcel Holtmann */ 1688baf27f6eSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 1689baf27f6eSMarcel Holtmann return 0; 1690baf27f6eSMarcel Holtmann 1691dfb826a8SMarcel Holtmann debugfs_create_file("features", 0444, hdev->debugfs, hdev, 1692dfb826a8SMarcel Holtmann &features_fops); 1693ceeb3bc0SMarcel Holtmann debugfs_create_u16("manufacturer", 0444, hdev->debugfs, 1694ceeb3bc0SMarcel Holtmann &hdev->manufacturer); 1695ceeb3bc0SMarcel Holtmann debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver); 1696ceeb3bc0SMarcel Holtmann debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev); 169770afe0b8SMarcel Holtmann debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev, 169870afe0b8SMarcel Holtmann &blacklist_fops); 169947219839SMarcel Holtmann debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 170047219839SMarcel Holtmann 170131ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev, 170231ad1691SAndrzej Kaczmarek &conn_info_min_age_fops); 170331ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev, 170431ad1691SAndrzej Kaczmarek &conn_info_max_age_fops); 170531ad1691SAndrzej Kaczmarek 1706baf27f6eSMarcel Holtmann if (lmp_bredr_capable(hdev)) { 1707baf27f6eSMarcel Holtmann debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, 1708baf27f6eSMarcel Holtmann hdev, &inquiry_cache_fops); 170902d08d15SMarcel Holtmann debugfs_create_file("link_keys", 0400, hdev->debugfs, 171002d08d15SMarcel Holtmann hdev, &link_keys_fops); 1711babdbb3cSMarcel Holtmann debugfs_create_file("dev_class", 0444, hdev->debugfs, 1712babdbb3cSMarcel Holtmann hdev, &dev_class_fops); 1713041000b9SMarcel Holtmann debugfs_create_file("voice_setting", 0444, hdev->debugfs, 1714041000b9SMarcel Holtmann hdev, &voice_setting_fops); 1715baf27f6eSMarcel Holtmann } 1716baf27f6eSMarcel Holtmann 171706f5b778SMarcel Holtmann if (lmp_ssp_capable(hdev)) { 1718ebd1e33bSMarcel Holtmann debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 1719ebd1e33bSMarcel Holtmann hdev, &auto_accept_delay_fops); 17205afeac14SMarcel Holtmann debugfs_create_file("force_sc_support", 0644, hdev->debugfs, 17215afeac14SMarcel Holtmann hdev, &force_sc_support_fops); 1722134c2a89SMarcel Holtmann debugfs_create_file("sc_only_mode", 0444, hdev->debugfs, 1723134c2a89SMarcel Holtmann hdev, &sc_only_mode_fops); 172406f5b778SMarcel Holtmann } 1725ebd1e33bSMarcel Holtmann 17262bfa3531SMarcel Holtmann if (lmp_sniff_capable(hdev)) { 17272bfa3531SMarcel Holtmann debugfs_create_file("idle_timeout", 0644, hdev->debugfs, 17282bfa3531SMarcel Holtmann hdev, &idle_timeout_fops); 17292bfa3531SMarcel Holtmann debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs, 17302bfa3531SMarcel Holtmann hdev, &sniff_min_interval_fops); 17312bfa3531SMarcel Holtmann debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs, 17322bfa3531SMarcel Holtmann hdev, &sniff_max_interval_fops); 17332bfa3531SMarcel Holtmann } 17342bfa3531SMarcel Holtmann 1735d0f729b8SMarcel Holtmann if (lmp_le_capable(hdev)) { 1736ac345813SMarcel Holtmann debugfs_create_file("identity", 0400, hdev->debugfs, 1737ac345813SMarcel Holtmann hdev, &identity_fops); 1738ac345813SMarcel Holtmann debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, 1739ac345813SMarcel Holtmann hdev, &rpa_timeout_fops); 17407a4cd51dSMarcel Holtmann debugfs_create_file("random_address", 0444, hdev->debugfs, 17417a4cd51dSMarcel Holtmann hdev, &random_address_fops); 1742e7b8fc92SMarcel Holtmann debugfs_create_file("static_address", 0444, hdev->debugfs, 1743e7b8fc92SMarcel Holtmann hdev, &static_address_fops); 1744b32bba6cSMarcel Holtmann 1745b32bba6cSMarcel Holtmann /* For controllers with a public address, provide a debug 1746b32bba6cSMarcel Holtmann * option to force the usage of the configured static 1747b32bba6cSMarcel Holtmann * address. By default the public address is used. 1748b32bba6cSMarcel Holtmann */ 1749b32bba6cSMarcel Holtmann if (bacmp(&hdev->bdaddr, BDADDR_ANY)) 1750b32bba6cSMarcel Holtmann debugfs_create_file("force_static_address", 0644, 1751b32bba6cSMarcel Holtmann hdev->debugfs, hdev, 1752b32bba6cSMarcel Holtmann &force_static_address_fops); 1753b32bba6cSMarcel Holtmann 1754b32bba6cSMarcel Holtmann debugfs_create_u8("white_list_size", 0444, hdev->debugfs, 1755b32bba6cSMarcel Holtmann &hdev->le_white_list_size); 1756d2ab0ac1SMarcel Holtmann debugfs_create_file("white_list", 0444, hdev->debugfs, hdev, 1757d2ab0ac1SMarcel Holtmann &white_list_fops); 17583698d704SMarcel Holtmann debugfs_create_file("identity_resolving_keys", 0400, 17593698d704SMarcel Holtmann hdev->debugfs, hdev, 17603698d704SMarcel Holtmann &identity_resolving_keys_fops); 17618f8625cdSMarcel Holtmann debugfs_create_file("long_term_keys", 0400, hdev->debugfs, 17628f8625cdSMarcel Holtmann hdev, &long_term_keys_fops); 17634e70c7e7SMarcel Holtmann debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, 17644e70c7e7SMarcel Holtmann hdev, &conn_min_interval_fops); 17654e70c7e7SMarcel Holtmann debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, 17664e70c7e7SMarcel Holtmann hdev, &conn_max_interval_fops); 1767816a93d1SMarcel Holtmann debugfs_create_file("conn_latency", 0644, hdev->debugfs, 1768816a93d1SMarcel Holtmann hdev, &conn_latency_fops); 1769f1649577SMarcel Holtmann debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, 1770f1649577SMarcel Holtmann hdev, &supervision_timeout_fops); 17713f959d46SMarcel Holtmann debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, 17723f959d46SMarcel Holtmann hdev, &adv_channel_map_fops); 17730b3c7d37SMarcel Holtmann debugfs_create_file("device_list", 0444, hdev->debugfs, hdev, 17740b3c7d37SMarcel Holtmann &device_list_fops); 1775b9a7a61eSLukasz Rymanowski debugfs_create_u16("discov_interleaved_timeout", 0644, 1776b9a7a61eSLukasz Rymanowski hdev->debugfs, 1777b9a7a61eSLukasz Rymanowski &hdev->discov_interleaved_timeout); 1778d0f729b8SMarcel Holtmann } 1779e7b8fc92SMarcel Holtmann 1780baf27f6eSMarcel Holtmann return 0; 17812177bab5SJohan Hedberg } 17822177bab5SJohan Hedberg 178342c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 17841da177e4SLinus Torvalds { 17851da177e4SLinus Torvalds __u8 scan = opt; 17861da177e4SLinus Torvalds 178742c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 17881da177e4SLinus Torvalds 17891da177e4SLinus Torvalds /* Inquiry and Page scans */ 179042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 17911da177e4SLinus Torvalds } 17921da177e4SLinus Torvalds 179342c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 17941da177e4SLinus Torvalds { 17951da177e4SLinus Torvalds __u8 auth = opt; 17961da177e4SLinus Torvalds 179742c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 17981da177e4SLinus Torvalds 17991da177e4SLinus Torvalds /* Authentication */ 180042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 18011da177e4SLinus Torvalds } 18021da177e4SLinus Torvalds 180342c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 18041da177e4SLinus Torvalds { 18051da177e4SLinus Torvalds __u8 encrypt = opt; 18061da177e4SLinus Torvalds 180742c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 18081da177e4SLinus Torvalds 1809e4e8e37cSMarcel Holtmann /* Encryption */ 181042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 18111da177e4SLinus Torvalds } 18121da177e4SLinus Torvalds 181342c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1814e4e8e37cSMarcel Holtmann { 1815e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1816e4e8e37cSMarcel Holtmann 181742c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1818e4e8e37cSMarcel Holtmann 1819e4e8e37cSMarcel Holtmann /* Default link policy */ 182042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1821e4e8e37cSMarcel Holtmann } 1822e4e8e37cSMarcel Holtmann 18231da177e4SLinus Torvalds /* Get HCI device by index. 18241da177e4SLinus Torvalds * Device is held on return. */ 18251da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 18261da177e4SLinus Torvalds { 18278035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 18281da177e4SLinus Torvalds 18291da177e4SLinus Torvalds BT_DBG("%d", index); 18301da177e4SLinus Torvalds 18311da177e4SLinus Torvalds if (index < 0) 18321da177e4SLinus Torvalds return NULL; 18331da177e4SLinus Torvalds 18341da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 18358035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 18361da177e4SLinus Torvalds if (d->id == index) { 18371da177e4SLinus Torvalds hdev = hci_dev_hold(d); 18381da177e4SLinus Torvalds break; 18391da177e4SLinus Torvalds } 18401da177e4SLinus Torvalds } 18411da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 18421da177e4SLinus Torvalds return hdev; 18431da177e4SLinus Torvalds } 18441da177e4SLinus Torvalds 18451da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1846ff9ef578SJohan Hedberg 184730dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 184830dc78e1SJohan Hedberg { 184930dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 185030dc78e1SJohan Hedberg 18516fbe195dSAndre Guedes switch (discov->state) { 1852343f935bSAndre Guedes case DISCOVERY_FINDING: 18536fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 185430dc78e1SJohan Hedberg return true; 185530dc78e1SJohan Hedberg 18566fbe195dSAndre Guedes default: 185730dc78e1SJohan Hedberg return false; 185830dc78e1SJohan Hedberg } 18596fbe195dSAndre Guedes } 186030dc78e1SJohan Hedberg 1861ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1862ff9ef578SJohan Hedberg { 1863ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1864ff9ef578SJohan Hedberg 1865ff9ef578SJohan Hedberg if (hdev->discovery.state == state) 1866ff9ef578SJohan Hedberg return; 1867ff9ef578SJohan Hedberg 1868ff9ef578SJohan Hedberg switch (state) { 1869ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1870c54c3860SAndre Guedes hci_update_background_scan(hdev); 1871c54c3860SAndre Guedes 18727b99b659SAndre Guedes if (hdev->discovery.state != DISCOVERY_STARTING) 1873ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1874ff9ef578SJohan Hedberg break; 1875ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1876ff9ef578SJohan Hedberg break; 1877343f935bSAndre Guedes case DISCOVERY_FINDING: 1878ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1879ff9ef578SJohan Hedberg break; 188030dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 188130dc78e1SJohan Hedberg break; 1882ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1883ff9ef578SJohan Hedberg break; 1884ff9ef578SJohan Hedberg } 1885ff9ef578SJohan Hedberg 1886ff9ef578SJohan Hedberg hdev->discovery.state = state; 1887ff9ef578SJohan Hedberg } 1888ff9ef578SJohan Hedberg 18891f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 18901da177e4SLinus Torvalds { 189130883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1892b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 18931da177e4SLinus Torvalds 1894561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1895561aafbcSJohan Hedberg list_del(&p->all); 1896b57c1a56SJohan Hedberg kfree(p); 18971da177e4SLinus Torvalds } 1898561aafbcSJohan Hedberg 1899561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1900561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 19011da177e4SLinus Torvalds } 19021da177e4SLinus Torvalds 1903a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1904a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 19051da177e4SLinus Torvalds { 190630883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 19071da177e4SLinus Torvalds struct inquiry_entry *e; 19081da177e4SLinus Torvalds 19096ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 19101da177e4SLinus Torvalds 1911561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 19121da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 19131da177e4SLinus Torvalds return e; 19141da177e4SLinus Torvalds } 19151da177e4SLinus Torvalds 1916b57c1a56SJohan Hedberg return NULL; 1917b57c1a56SJohan Hedberg } 1918b57c1a56SJohan Hedberg 1919561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1920561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1921561aafbcSJohan Hedberg { 192230883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1923561aafbcSJohan Hedberg struct inquiry_entry *e; 1924561aafbcSJohan Hedberg 19256ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1926561aafbcSJohan Hedberg 1927561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1928561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1929561aafbcSJohan Hedberg return e; 1930561aafbcSJohan Hedberg } 1931561aafbcSJohan Hedberg 1932561aafbcSJohan Hedberg return NULL; 1933561aafbcSJohan Hedberg } 1934561aafbcSJohan Hedberg 193530dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 193630dc78e1SJohan Hedberg bdaddr_t *bdaddr, 193730dc78e1SJohan Hedberg int state) 193830dc78e1SJohan Hedberg { 193930dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 194030dc78e1SJohan Hedberg struct inquiry_entry *e; 194130dc78e1SJohan Hedberg 19426ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 194330dc78e1SJohan Hedberg 194430dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 194530dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 194630dc78e1SJohan Hedberg return e; 194730dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 194830dc78e1SJohan Hedberg return e; 194930dc78e1SJohan Hedberg } 195030dc78e1SJohan Hedberg 195130dc78e1SJohan Hedberg return NULL; 195230dc78e1SJohan Hedberg } 195330dc78e1SJohan Hedberg 1954a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1955a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1956a3d4e20aSJohan Hedberg { 1957a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1958a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1959a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1960a3d4e20aSJohan Hedberg 1961a3d4e20aSJohan Hedberg list_del(&ie->list); 1962a3d4e20aSJohan Hedberg 1963a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1964a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1965a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1966a3d4e20aSJohan Hedberg break; 1967a3d4e20aSJohan Hedberg pos = &p->list; 1968a3d4e20aSJohan Hedberg } 1969a3d4e20aSJohan Hedberg 1970a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1971a3d4e20aSJohan Hedberg } 1972a3d4e20aSJohan Hedberg 19733175405bSJohan Hedberg bool hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1974388fc8faSJohan Hedberg bool name_known, bool *ssp) 19751da177e4SLinus Torvalds { 197630883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 197770f23020SAndrei Emeltchenko struct inquiry_entry *ie; 19781da177e4SLinus Torvalds 19796ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 19801da177e4SLinus Torvalds 19812b2fec4dSSzymon Janc hci_remove_remote_oob_data(hdev, &data->bdaddr); 19822b2fec4dSSzymon Janc 1983388fc8faSJohan Hedberg *ssp = data->ssp_mode; 1984388fc8faSJohan Hedberg 198570f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1986a3d4e20aSJohan Hedberg if (ie) { 19878002d77cSJohan Hedberg if (ie->data.ssp_mode) 1988388fc8faSJohan Hedberg *ssp = true; 1989388fc8faSJohan Hedberg 1990a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1991a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1992a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1993a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1994a3d4e20aSJohan Hedberg } 1995a3d4e20aSJohan Hedberg 1996561aafbcSJohan Hedberg goto update; 1997a3d4e20aSJohan Hedberg } 1998561aafbcSJohan Hedberg 19991da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 200070f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 200170f23020SAndrei Emeltchenko if (!ie) 20023175405bSJohan Hedberg return false; 200370f23020SAndrei Emeltchenko 2004561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 2005561aafbcSJohan Hedberg 2006561aafbcSJohan Hedberg if (name_known) { 2007561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2008561aafbcSJohan Hedberg } else { 2009561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 2010561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 2011561aafbcSJohan Hedberg } 2012561aafbcSJohan Hedberg 2013561aafbcSJohan Hedberg update: 2014561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 2015561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 2016561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2017561aafbcSJohan Hedberg list_del(&ie->list); 20181da177e4SLinus Torvalds } 20191da177e4SLinus Torvalds 202070f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 202170f23020SAndrei Emeltchenko ie->timestamp = jiffies; 20221da177e4SLinus Torvalds cache->timestamp = jiffies; 20233175405bSJohan Hedberg 20243175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 20253175405bSJohan Hedberg return false; 20263175405bSJohan Hedberg 20273175405bSJohan Hedberg return true; 20281da177e4SLinus Torvalds } 20291da177e4SLinus Torvalds 20301da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 20311da177e4SLinus Torvalds { 203230883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 20331da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 20341da177e4SLinus Torvalds struct inquiry_entry *e; 20351da177e4SLinus Torvalds int copied = 0; 20361da177e4SLinus Torvalds 2037561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 20381da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 2039b57c1a56SJohan Hedberg 2040b57c1a56SJohan Hedberg if (copied >= num) 2041b57c1a56SJohan Hedberg break; 2042b57c1a56SJohan Hedberg 20431da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 20441da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 20451da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 20461da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 20471da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 20481da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 2049b57c1a56SJohan Hedberg 20501da177e4SLinus Torvalds info++; 2051b57c1a56SJohan Hedberg copied++; 20521da177e4SLinus Torvalds } 20531da177e4SLinus Torvalds 20541da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 20551da177e4SLinus Torvalds return copied; 20561da177e4SLinus Torvalds } 20571da177e4SLinus Torvalds 205842c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 20591da177e4SLinus Torvalds { 20601da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 206142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 20621da177e4SLinus Torvalds struct hci_cp_inquiry cp; 20631da177e4SLinus Torvalds 20641da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 20651da177e4SLinus Torvalds 20661da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 20671da177e4SLinus Torvalds return; 20681da177e4SLinus Torvalds 20691da177e4SLinus Torvalds /* Start Inquiry */ 20701da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 20711da177e4SLinus Torvalds cp.length = ir->length; 20721da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 207342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 20741da177e4SLinus Torvalds } 20751da177e4SLinus Torvalds 20763e13fa1eSAndre Guedes static int wait_inquiry(void *word) 20773e13fa1eSAndre Guedes { 20783e13fa1eSAndre Guedes schedule(); 20793e13fa1eSAndre Guedes return signal_pending(current); 20803e13fa1eSAndre Guedes } 20813e13fa1eSAndre Guedes 20821da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 20831da177e4SLinus Torvalds { 20841da177e4SLinus Torvalds __u8 __user *ptr = arg; 20851da177e4SLinus Torvalds struct hci_inquiry_req ir; 20861da177e4SLinus Torvalds struct hci_dev *hdev; 20871da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 20881da177e4SLinus Torvalds long timeo; 20891da177e4SLinus Torvalds __u8 *buf; 20901da177e4SLinus Torvalds 20911da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 20921da177e4SLinus Torvalds return -EFAULT; 20931da177e4SLinus Torvalds 20945a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 20955a08ecceSAndrei Emeltchenko if (!hdev) 20961da177e4SLinus Torvalds return -ENODEV; 20971da177e4SLinus Torvalds 20980736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 20990736cfa8SMarcel Holtmann err = -EBUSY; 21000736cfa8SMarcel Holtmann goto done; 21010736cfa8SMarcel Holtmann } 21020736cfa8SMarcel Holtmann 2103fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) { 2104fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2105fee746b0SMarcel Holtmann goto done; 2106fee746b0SMarcel Holtmann } 2107fee746b0SMarcel Holtmann 21085b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 21095b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 21105b69bef5SMarcel Holtmann goto done; 21115b69bef5SMarcel Holtmann } 21125b69bef5SMarcel Holtmann 211356f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 211456f87901SJohan Hedberg err = -EOPNOTSUPP; 211556f87901SJohan Hedberg goto done; 211656f87901SJohan Hedberg } 211756f87901SJohan Hedberg 211809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 21191da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 2120a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 21211f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 21221da177e4SLinus Torvalds do_inquiry = 1; 21231da177e4SLinus Torvalds } 212409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 21251da177e4SLinus Torvalds 212604837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 212770f23020SAndrei Emeltchenko 212870f23020SAndrei Emeltchenko if (do_inquiry) { 212901178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 213001178cd4SJohan Hedberg timeo); 213170f23020SAndrei Emeltchenko if (err < 0) 21321da177e4SLinus Torvalds goto done; 21333e13fa1eSAndre Guedes 21343e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 21353e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 21363e13fa1eSAndre Guedes */ 21373e13fa1eSAndre Guedes if (wait_on_bit(&hdev->flags, HCI_INQUIRY, wait_inquiry, 21383e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 21393e13fa1eSAndre Guedes return -EINTR; 214070f23020SAndrei Emeltchenko } 21411da177e4SLinus Torvalds 21428fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 21438fc9ced3SGustavo Padovan * 255 entries 21448fc9ced3SGustavo Padovan */ 21451da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 21461da177e4SLinus Torvalds 21471da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 21481da177e4SLinus Torvalds * copy it to the user space. 21491da177e4SLinus Torvalds */ 215070f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 215170f23020SAndrei Emeltchenko if (!buf) { 21521da177e4SLinus Torvalds err = -ENOMEM; 21531da177e4SLinus Torvalds goto done; 21541da177e4SLinus Torvalds } 21551da177e4SLinus Torvalds 215609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 21571da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 215809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 21591da177e4SLinus Torvalds 21601da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 21611da177e4SLinus Torvalds 21621da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 21631da177e4SLinus Torvalds ptr += sizeof(ir); 21641da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 21651da177e4SLinus Torvalds ir.num_rsp)) 21661da177e4SLinus Torvalds err = -EFAULT; 21671da177e4SLinus Torvalds } else 21681da177e4SLinus Torvalds err = -EFAULT; 21691da177e4SLinus Torvalds 21701da177e4SLinus Torvalds kfree(buf); 21711da177e4SLinus Torvalds 21721da177e4SLinus Torvalds done: 21731da177e4SLinus Torvalds hci_dev_put(hdev); 21741da177e4SLinus Torvalds return err; 21751da177e4SLinus Torvalds } 21761da177e4SLinus Torvalds 2177cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 21781da177e4SLinus Torvalds { 21791da177e4SLinus Torvalds int ret = 0; 21801da177e4SLinus Torvalds 21811da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 21821da177e4SLinus Torvalds 21831da177e4SLinus Torvalds hci_req_lock(hdev); 21841da177e4SLinus Torvalds 218594324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 218694324962SJohan Hovold ret = -ENODEV; 218794324962SJohan Hovold goto done; 218894324962SJohan Hovold } 218994324962SJohan Hovold 2190a5c8f270SMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) { 2191a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 2192a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 2193bf543036SJohan Hedberg */ 2194a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 2195611b30f7SMarcel Holtmann ret = -ERFKILL; 2196611b30f7SMarcel Holtmann goto done; 2197611b30f7SMarcel Holtmann } 2198611b30f7SMarcel Holtmann 2199a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 2200a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 2201a5c8f270SMarcel Holtmann * be able to determine if there is a public address 2202a5c8f270SMarcel Holtmann * or not. 2203a5c8f270SMarcel Holtmann * 2204c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 2205c6beca0eSMarcel Holtmann * if a public address or static random address is 2206c6beca0eSMarcel Holtmann * available. 2207c6beca0eSMarcel Holtmann * 2208a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 2209a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 2210a5c8f270SMarcel Holtmann */ 2211c6beca0eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 2212c6beca0eSMarcel Holtmann hdev->dev_type == HCI_BREDR && 2213a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2214a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 2215a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 2216a5c8f270SMarcel Holtmann goto done; 2217a5c8f270SMarcel Holtmann } 2218a5c8f270SMarcel Holtmann } 2219a5c8f270SMarcel Holtmann 22201da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 22211da177e4SLinus Torvalds ret = -EALREADY; 22221da177e4SLinus Torvalds goto done; 22231da177e4SLinus Torvalds } 22241da177e4SLinus Torvalds 22251da177e4SLinus Torvalds if (hdev->open(hdev)) { 22261da177e4SLinus Torvalds ret = -EIO; 22271da177e4SLinus Torvalds goto done; 22281da177e4SLinus Torvalds } 22291da177e4SLinus Torvalds 22301da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 22311da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 2232f41c70c4SMarcel Holtmann 2233f41c70c4SMarcel Holtmann if (hdev->setup && test_bit(HCI_SETUP, &hdev->dev_flags)) 2234f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 2235f41c70c4SMarcel Holtmann 2236f41c70c4SMarcel Holtmann if (!ret) { 2237fee746b0SMarcel Holtmann if (!test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks) && 22380736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 22392177bab5SJohan Hedberg ret = __hci_init(hdev); 22401da177e4SLinus Torvalds } 22411da177e4SLinus Torvalds 2242f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 2243f41c70c4SMarcel Holtmann 22441da177e4SLinus Torvalds if (!ret) { 22451da177e4SLinus Torvalds hci_dev_hold(hdev); 2246d6bfd59cSJohan Hedberg set_bit(HCI_RPA_EXPIRED, &hdev->dev_flags); 22471da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 22481da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 2249bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 22500736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 22511514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 225209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2253744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 225409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 225556e5cb86SJohan Hedberg } 22561da177e4SLinus Torvalds } else { 22571da177e4SLinus Torvalds /* Init failed, cleanup */ 22583eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2259c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 2260b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 22611da177e4SLinus Torvalds 22621da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 22631da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 22641da177e4SLinus Torvalds 22651da177e4SLinus Torvalds if (hdev->flush) 22661da177e4SLinus Torvalds hdev->flush(hdev); 22671da177e4SLinus Torvalds 22681da177e4SLinus Torvalds if (hdev->sent_cmd) { 22691da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 22701da177e4SLinus Torvalds hdev->sent_cmd = NULL; 22711da177e4SLinus Torvalds } 22721da177e4SLinus Torvalds 22731da177e4SLinus Torvalds hdev->close(hdev); 2274fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 22751da177e4SLinus Torvalds } 22761da177e4SLinus Torvalds 22771da177e4SLinus Torvalds done: 22781da177e4SLinus Torvalds hci_req_unlock(hdev); 22791da177e4SLinus Torvalds return ret; 22801da177e4SLinus Torvalds } 22811da177e4SLinus Torvalds 2282cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 2283cbed0ca1SJohan Hedberg 2284cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 2285cbed0ca1SJohan Hedberg { 2286cbed0ca1SJohan Hedberg struct hci_dev *hdev; 2287cbed0ca1SJohan Hedberg int err; 2288cbed0ca1SJohan Hedberg 2289cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 2290cbed0ca1SJohan Hedberg if (!hdev) 2291cbed0ca1SJohan Hedberg return -ENODEV; 2292cbed0ca1SJohan Hedberg 2293fee746b0SMarcel Holtmann /* Devices that are marked for raw-only usage can only be powered 2294fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 2295fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 2296fee746b0SMarcel Holtmann * possible. 2297fee746b0SMarcel Holtmann * 2298fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 2299fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 2300fee746b0SMarcel Holtmann * open the device. 2301fee746b0SMarcel Holtmann */ 2302fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks) && 2303fee746b0SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 2304fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2305fee746b0SMarcel Holtmann goto done; 2306fee746b0SMarcel Holtmann } 2307fee746b0SMarcel Holtmann 2308e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 2309e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 2310e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 2311e1d08f40SJohan Hedberg * completed. 2312e1d08f40SJohan Hedberg */ 2313e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 2314e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 2315e1d08f40SJohan Hedberg 2316a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 2317a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 2318a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 2319a5c8f270SMarcel Holtmann */ 2320e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 2321e1d08f40SJohan Hedberg 2322cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 2323cbed0ca1SJohan Hedberg 2324fee746b0SMarcel Holtmann done: 2325cbed0ca1SJohan Hedberg hci_dev_put(hdev); 2326cbed0ca1SJohan Hedberg return err; 2327cbed0ca1SJohan Hedberg } 2328cbed0ca1SJohan Hedberg 23291da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 23301da177e4SLinus Torvalds { 23311da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 23321da177e4SLinus Torvalds 233378c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 233478c04c0bSVinicius Costa Gomes 23351da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 23361da177e4SLinus Torvalds hci_req_lock(hdev); 23371da177e4SLinus Torvalds 23381da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 233965cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 23401da177e4SLinus Torvalds hci_req_unlock(hdev); 23411da177e4SLinus Torvalds return 0; 23421da177e4SLinus Torvalds } 23431da177e4SLinus Torvalds 23443eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 23453eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2346b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 23471da177e4SLinus Torvalds 234816ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 2349e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 235016ab91abSJohan Hedberg hdev->discov_timeout = 0; 23515e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 2352310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 235316ab91abSJohan Hedberg } 235416ab91abSJohan Hedberg 2355a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 23567d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 23577d78525dSJohan Hedberg 23587ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 23594518bb0fSJohan Hedberg 23604518bb0fSJohan Hedberg if (test_bit(HCI_MGMT, &hdev->dev_flags)) 2361d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 23627ba8b4beSAndre Guedes 236309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 23641f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 23651da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 23666046dc3eSAndre Guedes hci_pend_le_conns_clear(hdev); 236709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 23681da177e4SLinus Torvalds 23691da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 23701da177e4SLinus Torvalds 23711da177e4SLinus Torvalds if (hdev->flush) 23721da177e4SLinus Torvalds hdev->flush(hdev); 23731da177e4SLinus Torvalds 23741da177e4SLinus Torvalds /* Reset device */ 23751da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 23761da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 2377fee746b0SMarcel Holtmann if (!test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks) && 23783a6afbd2SMarcel Holtmann !test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 2379a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 23801da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 238101178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 23821da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 23831da177e4SLinus Torvalds } 23841da177e4SLinus Torvalds 2385c347b765SGustavo F. Padovan /* flush cmd work */ 2386c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 23871da177e4SLinus Torvalds 23881da177e4SLinus Torvalds /* Drop queues */ 23891da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 23901da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 23911da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 23921da177e4SLinus Torvalds 23931da177e4SLinus Torvalds /* Drop last sent command */ 23941da177e4SLinus Torvalds if (hdev->sent_cmd) { 239565cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 23961da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 23971da177e4SLinus Torvalds hdev->sent_cmd = NULL; 23981da177e4SLinus Torvalds } 23991da177e4SLinus Torvalds 2400b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 2401b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 2402b6ddb638SJohan Hedberg 24031da177e4SLinus Torvalds /* After this point our queues are empty 24041da177e4SLinus Torvalds * and no tasks are scheduled. */ 24051da177e4SLinus Torvalds hdev->close(hdev); 24061da177e4SLinus Torvalds 240735b973c9SJohan Hedberg /* Clear flags */ 2408fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 240935b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 241035b973c9SJohan Hedberg 241193c311a0SMarcel Holtmann if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 241293c311a0SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 241309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2414744cf19eSJohan Hedberg mgmt_powered(hdev, 0); 241509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 24168ee56540SMarcel Holtmann } 241793c311a0SMarcel Holtmann } 24185add6af8SJohan Hedberg 2419ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 2420536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 2421ced5c338SAndrei Emeltchenko 2422e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 242309b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 24247a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 2425e59fda8dSJohan Hedberg 24261da177e4SLinus Torvalds hci_req_unlock(hdev); 24271da177e4SLinus Torvalds 24281da177e4SLinus Torvalds hci_dev_put(hdev); 24291da177e4SLinus Torvalds return 0; 24301da177e4SLinus Torvalds } 24311da177e4SLinus Torvalds 24321da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 24331da177e4SLinus Torvalds { 24341da177e4SLinus Torvalds struct hci_dev *hdev; 24351da177e4SLinus Torvalds int err; 24361da177e4SLinus Torvalds 243770f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 243870f23020SAndrei Emeltchenko if (!hdev) 24391da177e4SLinus Torvalds return -ENODEV; 24408ee56540SMarcel Holtmann 24410736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 24420736cfa8SMarcel Holtmann err = -EBUSY; 24430736cfa8SMarcel Holtmann goto done; 24440736cfa8SMarcel Holtmann } 24450736cfa8SMarcel Holtmann 24468ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 24478ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 24488ee56540SMarcel Holtmann 24491da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 24508ee56540SMarcel Holtmann 24510736cfa8SMarcel Holtmann done: 24521da177e4SLinus Torvalds hci_dev_put(hdev); 24531da177e4SLinus Torvalds return err; 24541da177e4SLinus Torvalds } 24551da177e4SLinus Torvalds 24561da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 24571da177e4SLinus Torvalds { 24581da177e4SLinus Torvalds struct hci_dev *hdev; 24591da177e4SLinus Torvalds int ret = 0; 24601da177e4SLinus Torvalds 246170f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 246270f23020SAndrei Emeltchenko if (!hdev) 24631da177e4SLinus Torvalds return -ENODEV; 24641da177e4SLinus Torvalds 24651da177e4SLinus Torvalds hci_req_lock(hdev); 24661da177e4SLinus Torvalds 2467808a049eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 2468808a049eSMarcel Holtmann ret = -ENETDOWN; 24691da177e4SLinus Torvalds goto done; 2470808a049eSMarcel Holtmann } 24711da177e4SLinus Torvalds 24720736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 24730736cfa8SMarcel Holtmann ret = -EBUSY; 24740736cfa8SMarcel Holtmann goto done; 24750736cfa8SMarcel Holtmann } 24760736cfa8SMarcel Holtmann 2477fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) { 2478fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2479fee746b0SMarcel Holtmann goto done; 2480fee746b0SMarcel Holtmann } 2481fee746b0SMarcel Holtmann 24821da177e4SLinus Torvalds /* Drop queues */ 24831da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 24841da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 24851da177e4SLinus Torvalds 248609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 24871f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 24881da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 248909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 24901da177e4SLinus Torvalds 24911da177e4SLinus Torvalds if (hdev->flush) 24921da177e4SLinus Torvalds hdev->flush(hdev); 24931da177e4SLinus Torvalds 24941da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 24956ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 24961da177e4SLinus Torvalds 249701178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 24981da177e4SLinus Torvalds 24991da177e4SLinus Torvalds done: 25001da177e4SLinus Torvalds hci_req_unlock(hdev); 25011da177e4SLinus Torvalds hci_dev_put(hdev); 25021da177e4SLinus Torvalds return ret; 25031da177e4SLinus Torvalds } 25041da177e4SLinus Torvalds 25051da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 25061da177e4SLinus Torvalds { 25071da177e4SLinus Torvalds struct hci_dev *hdev; 25081da177e4SLinus Torvalds int ret = 0; 25091da177e4SLinus Torvalds 251070f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 251170f23020SAndrei Emeltchenko if (!hdev) 25121da177e4SLinus Torvalds return -ENODEV; 25131da177e4SLinus Torvalds 25140736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 25150736cfa8SMarcel Holtmann ret = -EBUSY; 25160736cfa8SMarcel Holtmann goto done; 25170736cfa8SMarcel Holtmann } 25180736cfa8SMarcel Holtmann 2519fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) { 2520fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2521fee746b0SMarcel Holtmann goto done; 2522fee746b0SMarcel Holtmann } 2523fee746b0SMarcel Holtmann 25241da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 25251da177e4SLinus Torvalds 25260736cfa8SMarcel Holtmann done: 25271da177e4SLinus Torvalds hci_dev_put(hdev); 25281da177e4SLinus Torvalds return ret; 25291da177e4SLinus Torvalds } 25301da177e4SLinus Torvalds 25311da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 25321da177e4SLinus Torvalds { 25331da177e4SLinus Torvalds struct hci_dev *hdev; 25341da177e4SLinus Torvalds struct hci_dev_req dr; 25351da177e4SLinus Torvalds int err = 0; 25361da177e4SLinus Torvalds 25371da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 25381da177e4SLinus Torvalds return -EFAULT; 25391da177e4SLinus Torvalds 254070f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 254170f23020SAndrei Emeltchenko if (!hdev) 25421da177e4SLinus Torvalds return -ENODEV; 25431da177e4SLinus Torvalds 25440736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 25450736cfa8SMarcel Holtmann err = -EBUSY; 25460736cfa8SMarcel Holtmann goto done; 25470736cfa8SMarcel Holtmann } 25480736cfa8SMarcel Holtmann 2549fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) { 2550fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2551fee746b0SMarcel Holtmann goto done; 2552fee746b0SMarcel Holtmann } 2553fee746b0SMarcel Holtmann 25545b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 25555b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 25565b69bef5SMarcel Holtmann goto done; 25575b69bef5SMarcel Holtmann } 25585b69bef5SMarcel Holtmann 255956f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 256056f87901SJohan Hedberg err = -EOPNOTSUPP; 256156f87901SJohan Hedberg goto done; 256256f87901SJohan Hedberg } 256356f87901SJohan Hedberg 25641da177e4SLinus Torvalds switch (cmd) { 25651da177e4SLinus Torvalds case HCISETAUTH: 256601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 25675f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 25681da177e4SLinus Torvalds break; 25691da177e4SLinus Torvalds 25701da177e4SLinus Torvalds case HCISETENCRYPT: 25711da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 25721da177e4SLinus Torvalds err = -EOPNOTSUPP; 25731da177e4SLinus Torvalds break; 25741da177e4SLinus Torvalds } 25751da177e4SLinus Torvalds 25761da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 25771da177e4SLinus Torvalds /* Auth must be enabled first */ 257801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 25795f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 25801da177e4SLinus Torvalds if (err) 25811da177e4SLinus Torvalds break; 25821da177e4SLinus Torvalds } 25831da177e4SLinus Torvalds 258401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 25855f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 25861da177e4SLinus Torvalds break; 25871da177e4SLinus Torvalds 25881da177e4SLinus Torvalds case HCISETSCAN: 258901178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 25905f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 25911da177e4SLinus Torvalds break; 25921da177e4SLinus Torvalds 25931da177e4SLinus Torvalds case HCISETLINKPOL: 259401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 25955f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 25961da177e4SLinus Torvalds break; 25971da177e4SLinus Torvalds 25981da177e4SLinus Torvalds case HCISETLINKMODE: 2599e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 2600e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 2601e4e8e37cSMarcel Holtmann break; 2602e4e8e37cSMarcel Holtmann 2603e4e8e37cSMarcel Holtmann case HCISETPTYPE: 2604e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 26051da177e4SLinus Torvalds break; 26061da177e4SLinus Torvalds 26071da177e4SLinus Torvalds case HCISETACLMTU: 26081da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 26091da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 26101da177e4SLinus Torvalds break; 26111da177e4SLinus Torvalds 26121da177e4SLinus Torvalds case HCISETSCOMTU: 26131da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 26141da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 26151da177e4SLinus Torvalds break; 26161da177e4SLinus Torvalds 26171da177e4SLinus Torvalds default: 26181da177e4SLinus Torvalds err = -EINVAL; 26191da177e4SLinus Torvalds break; 26201da177e4SLinus Torvalds } 2621e4e8e37cSMarcel Holtmann 26220736cfa8SMarcel Holtmann done: 26231da177e4SLinus Torvalds hci_dev_put(hdev); 26241da177e4SLinus Torvalds return err; 26251da177e4SLinus Torvalds } 26261da177e4SLinus Torvalds 26271da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 26281da177e4SLinus Torvalds { 26298035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 26301da177e4SLinus Torvalds struct hci_dev_list_req *dl; 26311da177e4SLinus Torvalds struct hci_dev_req *dr; 26321da177e4SLinus Torvalds int n = 0, size, err; 26331da177e4SLinus Torvalds __u16 dev_num; 26341da177e4SLinus Torvalds 26351da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 26361da177e4SLinus Torvalds return -EFAULT; 26371da177e4SLinus Torvalds 26381da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 26391da177e4SLinus Torvalds return -EINVAL; 26401da177e4SLinus Torvalds 26411da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 26421da177e4SLinus Torvalds 264370f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 264470f23020SAndrei Emeltchenko if (!dl) 26451da177e4SLinus Torvalds return -ENOMEM; 26461da177e4SLinus Torvalds 26471da177e4SLinus Torvalds dr = dl->dev_req; 26481da177e4SLinus Torvalds 2649f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 26508035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 2651a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 2652e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->power_off); 2653c542a06cSJohan Hedberg 2654a8b2d5c2SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 2655a8b2d5c2SJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->dev_flags); 2656c542a06cSJohan Hedberg 26571da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 26581da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 2659c542a06cSJohan Hedberg 26601da177e4SLinus Torvalds if (++n >= dev_num) 26611da177e4SLinus Torvalds break; 26621da177e4SLinus Torvalds } 2663f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 26641da177e4SLinus Torvalds 26651da177e4SLinus Torvalds dl->dev_num = n; 26661da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 26671da177e4SLinus Torvalds 26681da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 26691da177e4SLinus Torvalds kfree(dl); 26701da177e4SLinus Torvalds 26711da177e4SLinus Torvalds return err ? -EFAULT : 0; 26721da177e4SLinus Torvalds } 26731da177e4SLinus Torvalds 26741da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 26751da177e4SLinus Torvalds { 26761da177e4SLinus Torvalds struct hci_dev *hdev; 26771da177e4SLinus Torvalds struct hci_dev_info di; 26781da177e4SLinus Torvalds int err = 0; 26791da177e4SLinus Torvalds 26801da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 26811da177e4SLinus Torvalds return -EFAULT; 26821da177e4SLinus Torvalds 268370f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 268470f23020SAndrei Emeltchenko if (!hdev) 26851da177e4SLinus Torvalds return -ENODEV; 26861da177e4SLinus Torvalds 2687a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 26883243553fSJohan Hedberg cancel_delayed_work_sync(&hdev->power_off); 2689ab81cbf9SJohan Hedberg 2690a8b2d5c2SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 2691a8b2d5c2SJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->dev_flags); 2692c542a06cSJohan Hedberg 26931da177e4SLinus Torvalds strcpy(di.name, hdev->name); 26941da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 269560f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 26961da177e4SLinus Torvalds di.flags = hdev->flags; 26971da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2698572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 26991da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 27001da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 27011da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 27021da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2703572c7f84SJohan Hedberg } else { 2704572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2705572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2706572c7f84SJohan Hedberg di.sco_mtu = 0; 2707572c7f84SJohan Hedberg di.sco_pkts = 0; 2708572c7f84SJohan Hedberg } 27091da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 27101da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 27111da177e4SLinus Torvalds 27121da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 27131da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 27141da177e4SLinus Torvalds 27151da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 27161da177e4SLinus Torvalds err = -EFAULT; 27171da177e4SLinus Torvalds 27181da177e4SLinus Torvalds hci_dev_put(hdev); 27191da177e4SLinus Torvalds 27201da177e4SLinus Torvalds return err; 27211da177e4SLinus Torvalds } 27221da177e4SLinus Torvalds 27231da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 27241da177e4SLinus Torvalds 2725611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2726611b30f7SMarcel Holtmann { 2727611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2728611b30f7SMarcel Holtmann 2729611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2730611b30f7SMarcel Holtmann 27310736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 27320736cfa8SMarcel Holtmann return -EBUSY; 27330736cfa8SMarcel Holtmann 27345e130367SJohan Hedberg if (blocked) { 27355e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 2736bf543036SJohan Hedberg if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 2737611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 27385e130367SJohan Hedberg } else { 27395e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 27405e130367SJohan Hedberg } 2741611b30f7SMarcel Holtmann 2742611b30f7SMarcel Holtmann return 0; 2743611b30f7SMarcel Holtmann } 2744611b30f7SMarcel Holtmann 2745611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2746611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2747611b30f7SMarcel Holtmann }; 2748611b30f7SMarcel Holtmann 2749ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2750ab81cbf9SJohan Hedberg { 2751ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 275296570ffcSJohan Hedberg int err; 2753ab81cbf9SJohan Hedberg 2754ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2755ab81cbf9SJohan Hedberg 2756cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 275796570ffcSJohan Hedberg if (err < 0) { 275896570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 2759ab81cbf9SJohan Hedberg return; 276096570ffcSJohan Hedberg } 2761ab81cbf9SJohan Hedberg 2762a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2763a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2764a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2765a5c8f270SMarcel Holtmann */ 2766a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 2767a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 2768a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2769a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2770bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2771bf543036SJohan Hedberg hci_dev_do_close(hdev); 2772bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 277319202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 277419202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2775bf543036SJohan Hedberg } 2776ab81cbf9SJohan Hedberg 2777fee746b0SMarcel Holtmann if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) { 2778fee746b0SMarcel Holtmann if (!test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 2779744cf19eSJohan Hedberg mgmt_index_added(hdev); 2780ab81cbf9SJohan Hedberg } 2781fee746b0SMarcel Holtmann } 2782ab81cbf9SJohan Hedberg 2783ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2784ab81cbf9SJohan Hedberg { 27853243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 27863243553fSJohan Hedberg power_off.work); 2787ab81cbf9SJohan Hedberg 2788ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2789ab81cbf9SJohan Hedberg 27908ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2791ab81cbf9SJohan Hedberg } 2792ab81cbf9SJohan Hedberg 279316ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 279416ab91abSJohan Hedberg { 279516ab91abSJohan Hedberg struct hci_dev *hdev; 279616ab91abSJohan Hedberg 279716ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 279816ab91abSJohan Hedberg 279916ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 280016ab91abSJohan Hedberg 2801d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 280216ab91abSJohan Hedberg } 280316ab91abSJohan Hedberg 280435f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 28052aeb9a1aSJohan Hedberg { 28064821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 28072aeb9a1aSJohan Hedberg 28084821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 28094821002cSJohan Hedberg list_del(&uuid->list); 28102aeb9a1aSJohan Hedberg kfree(uuid); 28112aeb9a1aSJohan Hedberg } 28122aeb9a1aSJohan Hedberg } 28132aeb9a1aSJohan Hedberg 281435f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 281555ed8ca1SJohan Hedberg { 281655ed8ca1SJohan Hedberg struct list_head *p, *n; 281755ed8ca1SJohan Hedberg 281855ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 281955ed8ca1SJohan Hedberg struct link_key *key; 282055ed8ca1SJohan Hedberg 282155ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 282255ed8ca1SJohan Hedberg 282355ed8ca1SJohan Hedberg list_del(p); 282455ed8ca1SJohan Hedberg kfree(key); 282555ed8ca1SJohan Hedberg } 282655ed8ca1SJohan Hedberg } 282755ed8ca1SJohan Hedberg 282835f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 2829b899efafSVinicius Costa Gomes { 2830b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 2831b899efafSVinicius Costa Gomes 2832b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 2833b899efafSVinicius Costa Gomes list_del(&k->list); 2834b899efafSVinicius Costa Gomes kfree(k); 2835b899efafSVinicius Costa Gomes } 2836b899efafSVinicius Costa Gomes } 2837b899efafSVinicius Costa Gomes 2838970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 2839970c4e46SJohan Hedberg { 2840970c4e46SJohan Hedberg struct smp_irk *k, *tmp; 2841970c4e46SJohan Hedberg 2842970c4e46SJohan Hedberg list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) { 2843970c4e46SJohan Hedberg list_del(&k->list); 2844970c4e46SJohan Hedberg kfree(k); 2845970c4e46SJohan Hedberg } 2846970c4e46SJohan Hedberg } 2847970c4e46SJohan Hedberg 284855ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 284955ed8ca1SJohan Hedberg { 285055ed8ca1SJohan Hedberg struct link_key *k; 285155ed8ca1SJohan Hedberg 28528035ded4SLuiz Augusto von Dentz list_for_each_entry(k, &hdev->link_keys, list) 285355ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 285455ed8ca1SJohan Hedberg return k; 285555ed8ca1SJohan Hedberg 285655ed8ca1SJohan Hedberg return NULL; 285755ed8ca1SJohan Hedberg } 285855ed8ca1SJohan Hedberg 2859745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2860d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2861d25e28abSJohan Hedberg { 2862d25e28abSJohan Hedberg /* Legacy key */ 2863d25e28abSJohan Hedberg if (key_type < 0x03) 2864745c0ce3SVishal Agarwal return true; 2865d25e28abSJohan Hedberg 2866d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2867d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2868745c0ce3SVishal Agarwal return false; 2869d25e28abSJohan Hedberg 2870d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2871d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2872745c0ce3SVishal Agarwal return false; 2873d25e28abSJohan Hedberg 2874d25e28abSJohan Hedberg /* Security mode 3 case */ 2875d25e28abSJohan Hedberg if (!conn) 2876745c0ce3SVishal Agarwal return true; 2877d25e28abSJohan Hedberg 2878d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2879d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2880745c0ce3SVishal Agarwal return true; 2881d25e28abSJohan Hedberg 2882d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2883d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2884745c0ce3SVishal Agarwal return true; 2885d25e28abSJohan Hedberg 2886d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2887d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2888745c0ce3SVishal Agarwal return true; 2889d25e28abSJohan Hedberg 2890d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2891d25e28abSJohan Hedberg * persistently */ 2892745c0ce3SVishal Agarwal return false; 2893d25e28abSJohan Hedberg } 2894d25e28abSJohan Hedberg 289598a0b845SJohan Hedberg static bool ltk_type_master(u8 type) 289698a0b845SJohan Hedberg { 2897d97c9fb0SJohan Hedberg return (type == SMP_LTK); 289898a0b845SJohan Hedberg } 289998a0b845SJohan Hedberg 2900fe39c7b2SMarcel Holtmann struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, __le64 rand, 290198a0b845SJohan Hedberg bool master) 290275d262c2SVinicius Costa Gomes { 2903c9839a11SVinicius Costa Gomes struct smp_ltk *k; 290475d262c2SVinicius Costa Gomes 2905c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) { 2906fe39c7b2SMarcel Holtmann if (k->ediv != ediv || k->rand != rand) 290775d262c2SVinicius Costa Gomes continue; 290875d262c2SVinicius Costa Gomes 290998a0b845SJohan Hedberg if (ltk_type_master(k->type) != master) 291098a0b845SJohan Hedberg continue; 291198a0b845SJohan Hedberg 291275d262c2SVinicius Costa Gomes return k; 291375d262c2SVinicius Costa Gomes } 291475d262c2SVinicius Costa Gomes 291575d262c2SVinicius Costa Gomes return NULL; 291675d262c2SVinicius Costa Gomes } 291775d262c2SVinicius Costa Gomes 2918c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 291998a0b845SJohan Hedberg u8 addr_type, bool master) 292075d262c2SVinicius Costa Gomes { 2921c9839a11SVinicius Costa Gomes struct smp_ltk *k; 292275d262c2SVinicius Costa Gomes 2923c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) 2924c9839a11SVinicius Costa Gomes if (addr_type == k->bdaddr_type && 292598a0b845SJohan Hedberg bacmp(bdaddr, &k->bdaddr) == 0 && 292698a0b845SJohan Hedberg ltk_type_master(k->type) == master) 292775d262c2SVinicius Costa Gomes return k; 292875d262c2SVinicius Costa Gomes 292975d262c2SVinicius Costa Gomes return NULL; 293075d262c2SVinicius Costa Gomes } 293175d262c2SVinicius Costa Gomes 2932970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 2933970c4e46SJohan Hedberg { 2934970c4e46SJohan Hedberg struct smp_irk *irk; 2935970c4e46SJohan Hedberg 2936970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 2937970c4e46SJohan Hedberg if (!bacmp(&irk->rpa, rpa)) 2938970c4e46SJohan Hedberg return irk; 2939970c4e46SJohan Hedberg } 2940970c4e46SJohan Hedberg 2941970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 2942970c4e46SJohan Hedberg if (smp_irk_matches(hdev->tfm_aes, irk->val, rpa)) { 2943970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2944970c4e46SJohan Hedberg return irk; 2945970c4e46SJohan Hedberg } 2946970c4e46SJohan Hedberg } 2947970c4e46SJohan Hedberg 2948970c4e46SJohan Hedberg return NULL; 2949970c4e46SJohan Hedberg } 2950970c4e46SJohan Hedberg 2951970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2952970c4e46SJohan Hedberg u8 addr_type) 2953970c4e46SJohan Hedberg { 2954970c4e46SJohan Hedberg struct smp_irk *irk; 2955970c4e46SJohan Hedberg 29566cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 29576cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 29586cfc9988SJohan Hedberg return NULL; 29596cfc9988SJohan Hedberg 2960970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 2961970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 2962970c4e46SJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) 2963970c4e46SJohan Hedberg return irk; 2964970c4e46SJohan Hedberg } 2965970c4e46SJohan Hedberg 2966970c4e46SJohan Hedberg return NULL; 2967970c4e46SJohan Hedberg } 2968970c4e46SJohan Hedberg 2969567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 29707652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 29717652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 297255ed8ca1SJohan Hedberg { 297355ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2974745c0ce3SVishal Agarwal u8 old_key_type; 297555ed8ca1SJohan Hedberg 297655ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 297755ed8ca1SJohan Hedberg if (old_key) { 297855ed8ca1SJohan Hedberg old_key_type = old_key->type; 297955ed8ca1SJohan Hedberg key = old_key; 298055ed8ca1SJohan Hedberg } else { 298112adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 29820a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 298355ed8ca1SJohan Hedberg if (!key) 2984567fa2aaSJohan Hedberg return NULL; 298555ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 298655ed8ca1SJohan Hedberg } 298755ed8ca1SJohan Hedberg 29886ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 298955ed8ca1SJohan Hedberg 2990d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2991d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2992d25e28abSJohan Hedberg * previous key */ 2993d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2994a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2995d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2996655fe6ecSJohan Hedberg if (conn) 2997655fe6ecSJohan Hedberg conn->key_type = type; 2998655fe6ecSJohan Hedberg } 2999d25e28abSJohan Hedberg 300055ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 30019b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 300255ed8ca1SJohan Hedberg key->pin_len = pin_len; 300355ed8ca1SJohan Hedberg 3004b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 300555ed8ca1SJohan Hedberg key->type = old_key_type; 30064748fed2SJohan Hedberg else 30074748fed2SJohan Hedberg key->type = type; 30084748fed2SJohan Hedberg 30097652ff6aSJohan Hedberg if (persistent) 30107652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 30117652ff6aSJohan Hedberg old_key_type); 301255ed8ca1SJohan Hedberg 3013567fa2aaSJohan Hedberg return key; 301455ed8ca1SJohan Hedberg } 301555ed8ca1SJohan Hedberg 3016ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 301735d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 3018fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 301975d262c2SVinicius Costa Gomes { 3020c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 302198a0b845SJohan Hedberg bool master = ltk_type_master(type); 302275d262c2SVinicius Costa Gomes 302398a0b845SJohan Hedberg old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type, master); 3024c9839a11SVinicius Costa Gomes if (old_key) 302575d262c2SVinicius Costa Gomes key = old_key; 3026c9839a11SVinicius Costa Gomes else { 30270a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 302875d262c2SVinicius Costa Gomes if (!key) 3029ca9142b8SJohan Hedberg return NULL; 3030c9839a11SVinicius Costa Gomes list_add(&key->list, &hdev->long_term_keys); 303175d262c2SVinicius Costa Gomes } 303275d262c2SVinicius Costa Gomes 303375d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 3034c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 3035c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 3036c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 3037c9839a11SVinicius Costa Gomes key->ediv = ediv; 3038fe39c7b2SMarcel Holtmann key->rand = rand; 3039c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 3040c9839a11SVinicius Costa Gomes key->type = type; 304175d262c2SVinicius Costa Gomes 3042ca9142b8SJohan Hedberg return key; 304375d262c2SVinicius Costa Gomes } 304475d262c2SVinicius Costa Gomes 3045ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 3046ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 3047970c4e46SJohan Hedberg { 3048970c4e46SJohan Hedberg struct smp_irk *irk; 3049970c4e46SJohan Hedberg 3050970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 3051970c4e46SJohan Hedberg if (!irk) { 3052970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 3053970c4e46SJohan Hedberg if (!irk) 3054ca9142b8SJohan Hedberg return NULL; 3055970c4e46SJohan Hedberg 3056970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 3057970c4e46SJohan Hedberg irk->addr_type = addr_type; 3058970c4e46SJohan Hedberg 3059970c4e46SJohan Hedberg list_add(&irk->list, &hdev->identity_resolving_keys); 3060970c4e46SJohan Hedberg } 3061970c4e46SJohan Hedberg 3062970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 3063970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 3064970c4e46SJohan Hedberg 3065ca9142b8SJohan Hedberg return irk; 3066970c4e46SJohan Hedberg } 3067970c4e46SJohan Hedberg 306855ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 306955ed8ca1SJohan Hedberg { 307055ed8ca1SJohan Hedberg struct link_key *key; 307155ed8ca1SJohan Hedberg 307255ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 307355ed8ca1SJohan Hedberg if (!key) 307455ed8ca1SJohan Hedberg return -ENOENT; 307555ed8ca1SJohan Hedberg 30766ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 307755ed8ca1SJohan Hedberg 307855ed8ca1SJohan Hedberg list_del(&key->list); 307955ed8ca1SJohan Hedberg kfree(key); 308055ed8ca1SJohan Hedberg 308155ed8ca1SJohan Hedberg return 0; 308255ed8ca1SJohan Hedberg } 308355ed8ca1SJohan Hedberg 3084e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 3085b899efafSVinicius Costa Gomes { 3086b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 3087c51ffa0bSJohan Hedberg int removed = 0; 3088b899efafSVinicius Costa Gomes 3089b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 3090e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 3091b899efafSVinicius Costa Gomes continue; 3092b899efafSVinicius Costa Gomes 30936ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3094b899efafSVinicius Costa Gomes 3095b899efafSVinicius Costa Gomes list_del(&k->list); 3096b899efafSVinicius Costa Gomes kfree(k); 3097c51ffa0bSJohan Hedberg removed++; 3098b899efafSVinicius Costa Gomes } 3099b899efafSVinicius Costa Gomes 3100c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 3101b899efafSVinicius Costa Gomes } 3102b899efafSVinicius Costa Gomes 3103a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 3104a7ec7338SJohan Hedberg { 3105a7ec7338SJohan Hedberg struct smp_irk *k, *tmp; 3106a7ec7338SJohan Hedberg 3107668b7b19SJohan Hedberg list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) { 3108a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 3109a7ec7338SJohan Hedberg continue; 3110a7ec7338SJohan Hedberg 3111a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3112a7ec7338SJohan Hedberg 3113a7ec7338SJohan Hedberg list_del(&k->list); 3114a7ec7338SJohan Hedberg kfree(k); 3115a7ec7338SJohan Hedberg } 3116a7ec7338SJohan Hedberg } 3117a7ec7338SJohan Hedberg 31186bd32326SVille Tervo /* HCI command timer function */ 311965cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 31206bd32326SVille Tervo { 312165cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 312265cc2b49SMarcel Holtmann cmd_timer.work); 31236bd32326SVille Tervo 3124bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 3125bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 3126bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 3127bda4f23aSAndrei Emeltchenko 3128bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 3129bda4f23aSAndrei Emeltchenko } else { 31306bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 3131bda4f23aSAndrei Emeltchenko } 3132bda4f23aSAndrei Emeltchenko 31336bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 3134c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 31356bd32326SVille Tervo } 31366bd32326SVille Tervo 31372763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 31382763eda6SSzymon Janc bdaddr_t *bdaddr) 31392763eda6SSzymon Janc { 31402763eda6SSzymon Janc struct oob_data *data; 31412763eda6SSzymon Janc 31422763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 31432763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 31442763eda6SSzymon Janc return data; 31452763eda6SSzymon Janc 31462763eda6SSzymon Janc return NULL; 31472763eda6SSzymon Janc } 31482763eda6SSzymon Janc 31492763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 31502763eda6SSzymon Janc { 31512763eda6SSzymon Janc struct oob_data *data; 31522763eda6SSzymon Janc 31532763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 31542763eda6SSzymon Janc if (!data) 31552763eda6SSzymon Janc return -ENOENT; 31562763eda6SSzymon Janc 31576ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 31582763eda6SSzymon Janc 31592763eda6SSzymon Janc list_del(&data->list); 31602763eda6SSzymon Janc kfree(data); 31612763eda6SSzymon Janc 31622763eda6SSzymon Janc return 0; 31632763eda6SSzymon Janc } 31642763eda6SSzymon Janc 316535f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 31662763eda6SSzymon Janc { 31672763eda6SSzymon Janc struct oob_data *data, *n; 31682763eda6SSzymon Janc 31692763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 31702763eda6SSzymon Janc list_del(&data->list); 31712763eda6SSzymon Janc kfree(data); 31722763eda6SSzymon Janc } 31732763eda6SSzymon Janc } 31742763eda6SSzymon Janc 31750798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 31760798872eSMarcel Holtmann u8 *hash, u8 *randomizer) 31772763eda6SSzymon Janc { 31782763eda6SSzymon Janc struct oob_data *data; 31792763eda6SSzymon Janc 31802763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 31812763eda6SSzymon Janc if (!data) { 31820a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 31832763eda6SSzymon Janc if (!data) 31842763eda6SSzymon Janc return -ENOMEM; 31852763eda6SSzymon Janc 31862763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 31872763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 31882763eda6SSzymon Janc } 31892763eda6SSzymon Janc 3190519ca9d0SMarcel Holtmann memcpy(data->hash192, hash, sizeof(data->hash192)); 3191519ca9d0SMarcel Holtmann memcpy(data->randomizer192, randomizer, sizeof(data->randomizer192)); 31922763eda6SSzymon Janc 31930798872eSMarcel Holtmann memset(data->hash256, 0, sizeof(data->hash256)); 31940798872eSMarcel Holtmann memset(data->randomizer256, 0, sizeof(data->randomizer256)); 31950798872eSMarcel Holtmann 31960798872eSMarcel Holtmann BT_DBG("%s for %pMR", hdev->name, bdaddr); 31970798872eSMarcel Holtmann 31980798872eSMarcel Holtmann return 0; 31990798872eSMarcel Holtmann } 32000798872eSMarcel Holtmann 32010798872eSMarcel Holtmann int hci_add_remote_oob_ext_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 32020798872eSMarcel Holtmann u8 *hash192, u8 *randomizer192, 32030798872eSMarcel Holtmann u8 *hash256, u8 *randomizer256) 32040798872eSMarcel Holtmann { 32050798872eSMarcel Holtmann struct oob_data *data; 32060798872eSMarcel Holtmann 32070798872eSMarcel Holtmann data = hci_find_remote_oob_data(hdev, bdaddr); 32080798872eSMarcel Holtmann if (!data) { 32090a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 32100798872eSMarcel Holtmann if (!data) 32110798872eSMarcel Holtmann return -ENOMEM; 32120798872eSMarcel Holtmann 32130798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 32140798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 32150798872eSMarcel Holtmann } 32160798872eSMarcel Holtmann 32170798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 32180798872eSMarcel Holtmann memcpy(data->randomizer192, randomizer192, sizeof(data->randomizer192)); 32190798872eSMarcel Holtmann 32200798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 32210798872eSMarcel Holtmann memcpy(data->randomizer256, randomizer256, sizeof(data->randomizer256)); 32220798872eSMarcel Holtmann 32236ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 32242763eda6SSzymon Janc 32252763eda6SSzymon Janc return 0; 32262763eda6SSzymon Janc } 32272763eda6SSzymon Janc 3228b9ee0a78SMarcel Holtmann struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev, 3229b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 3230b2a66aadSAntti Julku { 3231b2a66aadSAntti Julku struct bdaddr_list *b; 3232b2a66aadSAntti Julku 3233b9ee0a78SMarcel Holtmann list_for_each_entry(b, &hdev->blacklist, list) { 3234b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 3235b2a66aadSAntti Julku return b; 3236b9ee0a78SMarcel Holtmann } 3237b2a66aadSAntti Julku 3238b2a66aadSAntti Julku return NULL; 3239b2a66aadSAntti Julku } 3240b2a66aadSAntti Julku 3241c9507490SMarcel Holtmann static void hci_blacklist_clear(struct hci_dev *hdev) 3242b2a66aadSAntti Julku { 3243b2a66aadSAntti Julku struct list_head *p, *n; 3244b2a66aadSAntti Julku 3245b2a66aadSAntti Julku list_for_each_safe(p, n, &hdev->blacklist) { 3246b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 3247b2a66aadSAntti Julku 3248b2a66aadSAntti Julku list_del(p); 3249b2a66aadSAntti Julku kfree(b); 3250b2a66aadSAntti Julku } 3251b2a66aadSAntti Julku } 3252b2a66aadSAntti Julku 325388c1fe4bSJohan Hedberg int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 3254b2a66aadSAntti Julku { 3255b2a66aadSAntti Julku struct bdaddr_list *entry; 3256b2a66aadSAntti Julku 3257b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 3258b2a66aadSAntti Julku return -EBADF; 3259b2a66aadSAntti Julku 3260b9ee0a78SMarcel Holtmann if (hci_blacklist_lookup(hdev, bdaddr, type)) 32615e762444SAntti Julku return -EEXIST; 3262b2a66aadSAntti Julku 3263b2a66aadSAntti Julku entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL); 32645e762444SAntti Julku if (!entry) 32655e762444SAntti Julku return -ENOMEM; 3266b2a66aadSAntti Julku 3267b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 3268b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 3269b2a66aadSAntti Julku 3270b2a66aadSAntti Julku list_add(&entry->list, &hdev->blacklist); 3271b2a66aadSAntti Julku 327288c1fe4bSJohan Hedberg return mgmt_device_blocked(hdev, bdaddr, type); 3273b2a66aadSAntti Julku } 3274b2a66aadSAntti Julku 327588c1fe4bSJohan Hedberg int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 3276b2a66aadSAntti Julku { 3277b2a66aadSAntti Julku struct bdaddr_list *entry; 3278b2a66aadSAntti Julku 327935f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 328035f7498aSJohan Hedberg hci_blacklist_clear(hdev); 328135f7498aSJohan Hedberg return 0; 328235f7498aSJohan Hedberg } 3283b2a66aadSAntti Julku 3284b9ee0a78SMarcel Holtmann entry = hci_blacklist_lookup(hdev, bdaddr, type); 32851ec918ceSSzymon Janc if (!entry) 32865e762444SAntti Julku return -ENOENT; 3287b2a66aadSAntti Julku 3288b2a66aadSAntti Julku list_del(&entry->list); 3289b2a66aadSAntti Julku kfree(entry); 3290b2a66aadSAntti Julku 329188c1fe4bSJohan Hedberg return mgmt_device_unblocked(hdev, bdaddr, type); 3292b2a66aadSAntti Julku } 3293b2a66aadSAntti Julku 3294d2ab0ac1SMarcel Holtmann struct bdaddr_list *hci_white_list_lookup(struct hci_dev *hdev, 3295d2ab0ac1SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 3296d2ab0ac1SMarcel Holtmann { 3297d2ab0ac1SMarcel Holtmann struct bdaddr_list *b; 3298d2ab0ac1SMarcel Holtmann 3299d2ab0ac1SMarcel Holtmann list_for_each_entry(b, &hdev->le_white_list, list) { 3300d2ab0ac1SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 3301d2ab0ac1SMarcel Holtmann return b; 3302d2ab0ac1SMarcel Holtmann } 3303d2ab0ac1SMarcel Holtmann 3304d2ab0ac1SMarcel Holtmann return NULL; 3305d2ab0ac1SMarcel Holtmann } 3306d2ab0ac1SMarcel Holtmann 3307d2ab0ac1SMarcel Holtmann void hci_white_list_clear(struct hci_dev *hdev) 3308d2ab0ac1SMarcel Holtmann { 3309d2ab0ac1SMarcel Holtmann struct list_head *p, *n; 3310d2ab0ac1SMarcel Holtmann 3311d2ab0ac1SMarcel Holtmann list_for_each_safe(p, n, &hdev->le_white_list) { 3312d2ab0ac1SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 3313d2ab0ac1SMarcel Holtmann 3314d2ab0ac1SMarcel Holtmann list_del(p); 3315d2ab0ac1SMarcel Holtmann kfree(b); 3316d2ab0ac1SMarcel Holtmann } 3317d2ab0ac1SMarcel Holtmann } 3318d2ab0ac1SMarcel Holtmann 3319d2ab0ac1SMarcel Holtmann int hci_white_list_add(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 3320d2ab0ac1SMarcel Holtmann { 3321d2ab0ac1SMarcel Holtmann struct bdaddr_list *entry; 3322d2ab0ac1SMarcel Holtmann 3323d2ab0ac1SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 3324d2ab0ac1SMarcel Holtmann return -EBADF; 3325d2ab0ac1SMarcel Holtmann 3326d2ab0ac1SMarcel Holtmann entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL); 3327d2ab0ac1SMarcel Holtmann if (!entry) 3328d2ab0ac1SMarcel Holtmann return -ENOMEM; 3329d2ab0ac1SMarcel Holtmann 3330d2ab0ac1SMarcel Holtmann bacpy(&entry->bdaddr, bdaddr); 3331d2ab0ac1SMarcel Holtmann entry->bdaddr_type = type; 3332d2ab0ac1SMarcel Holtmann 3333d2ab0ac1SMarcel Holtmann list_add(&entry->list, &hdev->le_white_list); 3334d2ab0ac1SMarcel Holtmann 3335d2ab0ac1SMarcel Holtmann return 0; 3336d2ab0ac1SMarcel Holtmann } 3337d2ab0ac1SMarcel Holtmann 3338d2ab0ac1SMarcel Holtmann int hci_white_list_del(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 3339d2ab0ac1SMarcel Holtmann { 3340d2ab0ac1SMarcel Holtmann struct bdaddr_list *entry; 3341d2ab0ac1SMarcel Holtmann 3342d2ab0ac1SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 3343d2ab0ac1SMarcel Holtmann return -EBADF; 3344d2ab0ac1SMarcel Holtmann 3345d2ab0ac1SMarcel Holtmann entry = hci_white_list_lookup(hdev, bdaddr, type); 3346d2ab0ac1SMarcel Holtmann if (!entry) 3347d2ab0ac1SMarcel Holtmann return -ENOENT; 3348d2ab0ac1SMarcel Holtmann 3349d2ab0ac1SMarcel Holtmann list_del(&entry->list); 3350d2ab0ac1SMarcel Holtmann kfree(entry); 3351d2ab0ac1SMarcel Holtmann 3352d2ab0ac1SMarcel Holtmann return 0; 3353d2ab0ac1SMarcel Holtmann } 3354d2ab0ac1SMarcel Holtmann 335515819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 335615819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 335715819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 335815819a70SAndre Guedes { 335915819a70SAndre Guedes struct hci_conn_params *params; 336015819a70SAndre Guedes 336115819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 336215819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 336315819a70SAndre Guedes params->addr_type == addr_type) { 336415819a70SAndre Guedes return params; 336515819a70SAndre Guedes } 336615819a70SAndre Guedes } 336715819a70SAndre Guedes 336815819a70SAndre Guedes return NULL; 336915819a70SAndre Guedes } 337015819a70SAndre Guedes 3371cef952ceSAndre Guedes static bool is_connected(struct hci_dev *hdev, bdaddr_t *addr, u8 type) 3372cef952ceSAndre Guedes { 3373cef952ceSAndre Guedes struct hci_conn *conn; 3374cef952ceSAndre Guedes 3375cef952ceSAndre Guedes conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, addr); 3376cef952ceSAndre Guedes if (!conn) 3377cef952ceSAndre Guedes return false; 3378cef952ceSAndre Guedes 3379cef952ceSAndre Guedes if (conn->dst_type != type) 3380cef952ceSAndre Guedes return false; 3381cef952ceSAndre Guedes 3382cef952ceSAndre Guedes if (conn->state != BT_CONNECTED) 3383cef952ceSAndre Guedes return false; 3384cef952ceSAndre Guedes 3385cef952ceSAndre Guedes return true; 3386cef952ceSAndre Guedes } 3387cef952ceSAndre Guedes 3388a9b0a04cSAndre Guedes static bool is_identity_address(bdaddr_t *addr, u8 addr_type) 3389a9b0a04cSAndre Guedes { 3390a9b0a04cSAndre Guedes if (addr_type == ADDR_LE_DEV_PUBLIC) 3391a9b0a04cSAndre Guedes return true; 3392a9b0a04cSAndre Guedes 3393a9b0a04cSAndre Guedes /* Check for Random Static address type */ 3394a9b0a04cSAndre Guedes if ((addr->b[5] & 0xc0) == 0xc0) 3395a9b0a04cSAndre Guedes return true; 3396a9b0a04cSAndre Guedes 3397a9b0a04cSAndre Guedes return false; 3398a9b0a04cSAndre Guedes } 3399a9b0a04cSAndre Guedes 340015819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 34014b10966fSMarcel Holtmann struct bdaddr_list *hci_pend_le_conn_lookup(struct hci_dev *hdev, 34024b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 34034b10966fSMarcel Holtmann { 34044b10966fSMarcel Holtmann struct bdaddr_list *entry; 34054b10966fSMarcel Holtmann 34064b10966fSMarcel Holtmann list_for_each_entry(entry, &hdev->pend_le_conns, list) { 34074b10966fSMarcel Holtmann if (bacmp(&entry->bdaddr, addr) == 0 && 34084b10966fSMarcel Holtmann entry->bdaddr_type == addr_type) 34094b10966fSMarcel Holtmann return entry; 34104b10966fSMarcel Holtmann } 34114b10966fSMarcel Holtmann 34124b10966fSMarcel Holtmann return NULL; 34134b10966fSMarcel Holtmann } 34144b10966fSMarcel Holtmann 34154b10966fSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 34164b10966fSMarcel Holtmann void hci_pend_le_conn_add(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 34174b10966fSMarcel Holtmann { 34184b10966fSMarcel Holtmann struct bdaddr_list *entry; 34194b10966fSMarcel Holtmann 34204b10966fSMarcel Holtmann entry = hci_pend_le_conn_lookup(hdev, addr, addr_type); 34214b10966fSMarcel Holtmann if (entry) 34224b10966fSMarcel Holtmann goto done; 34234b10966fSMarcel Holtmann 34244b10966fSMarcel Holtmann entry = kzalloc(sizeof(*entry), GFP_KERNEL); 34254b10966fSMarcel Holtmann if (!entry) { 34264b10966fSMarcel Holtmann BT_ERR("Out of memory"); 34274b10966fSMarcel Holtmann return; 34284b10966fSMarcel Holtmann } 34294b10966fSMarcel Holtmann 34304b10966fSMarcel Holtmann bacpy(&entry->bdaddr, addr); 34314b10966fSMarcel Holtmann entry->bdaddr_type = addr_type; 34324b10966fSMarcel Holtmann 34334b10966fSMarcel Holtmann list_add(&entry->list, &hdev->pend_le_conns); 34344b10966fSMarcel Holtmann 34354b10966fSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 34364b10966fSMarcel Holtmann 34374b10966fSMarcel Holtmann done: 34384b10966fSMarcel Holtmann hci_update_background_scan(hdev); 34394b10966fSMarcel Holtmann } 34404b10966fSMarcel Holtmann 34414b10966fSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 34424b10966fSMarcel Holtmann void hci_pend_le_conn_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 34434b10966fSMarcel Holtmann { 34444b10966fSMarcel Holtmann struct bdaddr_list *entry; 34454b10966fSMarcel Holtmann 34464b10966fSMarcel Holtmann entry = hci_pend_le_conn_lookup(hdev, addr, addr_type); 34474b10966fSMarcel Holtmann if (!entry) 34484b10966fSMarcel Holtmann goto done; 34494b10966fSMarcel Holtmann 34504b10966fSMarcel Holtmann list_del(&entry->list); 34514b10966fSMarcel Holtmann kfree(entry); 34524b10966fSMarcel Holtmann 34534b10966fSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 34544b10966fSMarcel Holtmann 34554b10966fSMarcel Holtmann done: 34564b10966fSMarcel Holtmann hci_update_background_scan(hdev); 34574b10966fSMarcel Holtmann } 34584b10966fSMarcel Holtmann 34594b10966fSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 34604b10966fSMarcel Holtmann void hci_pend_le_conns_clear(struct hci_dev *hdev) 34614b10966fSMarcel Holtmann { 34624b10966fSMarcel Holtmann struct bdaddr_list *entry, *tmp; 34634b10966fSMarcel Holtmann 34644b10966fSMarcel Holtmann list_for_each_entry_safe(entry, tmp, &hdev->pend_le_conns, list) { 34654b10966fSMarcel Holtmann list_del(&entry->list); 34664b10966fSMarcel Holtmann kfree(entry); 34674b10966fSMarcel Holtmann } 34684b10966fSMarcel Holtmann 34694b10966fSMarcel Holtmann BT_DBG("All LE pending connections cleared"); 34701c1697c0SMarcel Holtmann 34711c1697c0SMarcel Holtmann hci_update_background_scan(hdev); 34724b10966fSMarcel Holtmann } 34734b10966fSMarcel Holtmann 34744b10966fSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 347551d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 347651d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 3477bf5b3c8bSMarcel Holtmann { 3478bf5b3c8bSMarcel Holtmann struct hci_conn_params *params; 3479bf5b3c8bSMarcel Holtmann 3480bf5b3c8bSMarcel Holtmann if (!is_identity_address(addr, addr_type)) 348151d167c0SMarcel Holtmann return NULL; 3482bf5b3c8bSMarcel Holtmann 3483bf5b3c8bSMarcel Holtmann params = hci_conn_params_lookup(hdev, addr, addr_type); 3484bf5b3c8bSMarcel Holtmann if (params) 348551d167c0SMarcel Holtmann return params; 3486bf5b3c8bSMarcel Holtmann 3487bf5b3c8bSMarcel Holtmann params = kzalloc(sizeof(*params), GFP_KERNEL); 3488bf5b3c8bSMarcel Holtmann if (!params) { 3489bf5b3c8bSMarcel Holtmann BT_ERR("Out of memory"); 349051d167c0SMarcel Holtmann return NULL; 3491bf5b3c8bSMarcel Holtmann } 3492bf5b3c8bSMarcel Holtmann 3493bf5b3c8bSMarcel Holtmann bacpy(¶ms->addr, addr); 3494bf5b3c8bSMarcel Holtmann params->addr_type = addr_type; 3495bf5b3c8bSMarcel Holtmann 3496bf5b3c8bSMarcel Holtmann list_add(¶ms->list, &hdev->le_conn_params); 3497bf5b3c8bSMarcel Holtmann 3498bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 3499bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 3500bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 3501bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 3502bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 3503bf5b3c8bSMarcel Holtmann 3504bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 3505bf5b3c8bSMarcel Holtmann 350651d167c0SMarcel Holtmann return params; 3507bf5b3c8bSMarcel Holtmann } 3508bf5b3c8bSMarcel Holtmann 3509bf5b3c8bSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 3510bf5b3c8bSMarcel Holtmann int hci_conn_params_set(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type, 35119fcb18efSAndre Guedes u8 auto_connect, u16 conn_min_interval, 35129fcb18efSAndre Guedes u16 conn_max_interval) 351315819a70SAndre Guedes { 351415819a70SAndre Guedes struct hci_conn_params *params; 351515819a70SAndre Guedes 35168c87aae1SMarcel Holtmann params = hci_conn_params_add(hdev, addr, addr_type); 35178c87aae1SMarcel Holtmann if (!params) 35188c87aae1SMarcel Holtmann return -EIO; 3519a9b0a04cSAndre Guedes 352015819a70SAndre Guedes params->conn_min_interval = conn_min_interval; 352115819a70SAndre Guedes params->conn_max_interval = conn_max_interval; 35229fcb18efSAndre Guedes params->auto_connect = auto_connect; 352315819a70SAndre Guedes 3524cef952ceSAndre Guedes switch (auto_connect) { 3525cef952ceSAndre Guedes case HCI_AUTO_CONN_DISABLED: 3526cef952ceSAndre Guedes case HCI_AUTO_CONN_LINK_LOSS: 3527cef952ceSAndre Guedes hci_pend_le_conn_del(hdev, addr, addr_type); 3528cef952ceSAndre Guedes break; 3529cef952ceSAndre Guedes case HCI_AUTO_CONN_ALWAYS: 3530cef952ceSAndre Guedes if (!is_connected(hdev, addr, addr_type)) 3531cef952ceSAndre Guedes hci_pend_le_conn_add(hdev, addr, addr_type); 3532cef952ceSAndre Guedes break; 3533cef952ceSAndre Guedes } 353415819a70SAndre Guedes 35359fcb18efSAndre Guedes BT_DBG("addr %pMR (type %u) auto_connect %u conn_min_interval 0x%.4x " 35369fcb18efSAndre Guedes "conn_max_interval 0x%.4x", addr, addr_type, auto_connect, 35379fcb18efSAndre Guedes conn_min_interval, conn_max_interval); 3538a9b0a04cSAndre Guedes 3539a9b0a04cSAndre Guedes return 0; 354015819a70SAndre Guedes } 354115819a70SAndre Guedes 354215819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 354315819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 354415819a70SAndre Guedes { 354515819a70SAndre Guedes struct hci_conn_params *params; 354615819a70SAndre Guedes 354715819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 354815819a70SAndre Guedes if (!params) 354915819a70SAndre Guedes return; 355015819a70SAndre Guedes 3551cef952ceSAndre Guedes hci_pend_le_conn_del(hdev, addr, addr_type); 3552cef952ceSAndre Guedes 355315819a70SAndre Guedes list_del(¶ms->list); 355415819a70SAndre Guedes kfree(params); 355515819a70SAndre Guedes 355615819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 355715819a70SAndre Guedes } 355815819a70SAndre Guedes 355915819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 356015819a70SAndre Guedes void hci_conn_params_clear(struct hci_dev *hdev) 356115819a70SAndre Guedes { 356215819a70SAndre Guedes struct hci_conn_params *params, *tmp; 356315819a70SAndre Guedes 356415819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 356515819a70SAndre Guedes list_del(¶ms->list); 356615819a70SAndre Guedes kfree(params); 356715819a70SAndre Guedes } 356815819a70SAndre Guedes 35691089b67dSMarcel Holtmann hci_pend_le_conns_clear(hdev); 35701089b67dSMarcel Holtmann 357115819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 357215819a70SAndre Guedes } 357315819a70SAndre Guedes 35744c87eaabSAndre Guedes static void inquiry_complete(struct hci_dev *hdev, u8 status) 35757ba8b4beSAndre Guedes { 35764c87eaabSAndre Guedes if (status) { 35774c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 35787ba8b4beSAndre Guedes 35794c87eaabSAndre Guedes hci_dev_lock(hdev); 35804c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 35814c87eaabSAndre Guedes hci_dev_unlock(hdev); 35824c87eaabSAndre Guedes return; 35834c87eaabSAndre Guedes } 35847ba8b4beSAndre Guedes } 35857ba8b4beSAndre Guedes 35864c87eaabSAndre Guedes static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status) 35877ba8b4beSAndre Guedes { 35884c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 35894c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 35904c87eaabSAndre Guedes struct hci_request req; 35914c87eaabSAndre Guedes struct hci_cp_inquiry cp; 35927ba8b4beSAndre Guedes int err; 35937ba8b4beSAndre Guedes 35944c87eaabSAndre Guedes if (status) { 35954c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 35964c87eaabSAndre Guedes return; 35977ba8b4beSAndre Guedes } 35987ba8b4beSAndre Guedes 35994c87eaabSAndre Guedes switch (hdev->discovery.type) { 36004c87eaabSAndre Guedes case DISCOV_TYPE_LE: 36014c87eaabSAndre Guedes hci_dev_lock(hdev); 36024c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 36034c87eaabSAndre Guedes hci_dev_unlock(hdev); 36044c87eaabSAndre Guedes break; 36057dbfac1dSAndre Guedes 36064c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 36074c87eaabSAndre Guedes hci_req_init(&req, hdev); 36087dbfac1dSAndre Guedes 36097dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 36104c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 36114c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 36124c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 36134c87eaabSAndre Guedes 36144c87eaabSAndre Guedes hci_dev_lock(hdev); 36154c87eaabSAndre Guedes 36164c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 36174c87eaabSAndre Guedes 36184c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 36194c87eaabSAndre Guedes if (err) { 36204c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 36214c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 36227dbfac1dSAndre Guedes } 36237dbfac1dSAndre Guedes 36244c87eaabSAndre Guedes hci_dev_unlock(hdev); 36254c87eaabSAndre Guedes break; 36264c87eaabSAndre Guedes } 36277dbfac1dSAndre Guedes } 36287dbfac1dSAndre Guedes 36297ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 36307ba8b4beSAndre Guedes { 36317ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 36327ba8b4beSAndre Guedes le_scan_disable.work); 36334c87eaabSAndre Guedes struct hci_request req; 36344c87eaabSAndre Guedes int err; 36357ba8b4beSAndre Guedes 36367ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 36377ba8b4beSAndre Guedes 36384c87eaabSAndre Guedes hci_req_init(&req, hdev); 36397ba8b4beSAndre Guedes 3640b1efcc28SAndre Guedes hci_req_add_le_scan_disable(&req); 36417ba8b4beSAndre Guedes 36424c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 36434c87eaabSAndre Guedes if (err) 36444c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 364528b75a89SAndre Guedes } 364628b75a89SAndre Guedes 36478d97250eSJohan Hedberg static void set_random_addr(struct hci_request *req, bdaddr_t *rpa) 36488d97250eSJohan Hedberg { 36498d97250eSJohan Hedberg struct hci_dev *hdev = req->hdev; 36508d97250eSJohan Hedberg 36518d97250eSJohan Hedberg /* If we're advertising or initiating an LE connection we can't 36528d97250eSJohan Hedberg * go ahead and change the random address at this time. This is 36538d97250eSJohan Hedberg * because the eventual initiator address used for the 36548d97250eSJohan Hedberg * subsequently created connection will be undefined (some 36558d97250eSJohan Hedberg * controllers use the new address and others the one we had 36568d97250eSJohan Hedberg * when the operation started). 36578d97250eSJohan Hedberg * 36588d97250eSJohan Hedberg * In this kind of scenario skip the update and let the random 36598d97250eSJohan Hedberg * address be updated at the next cycle. 36608d97250eSJohan Hedberg */ 36618d97250eSJohan Hedberg if (test_bit(HCI_ADVERTISING, &hdev->dev_flags) || 36628d97250eSJohan Hedberg hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT)) { 36638d97250eSJohan Hedberg BT_DBG("Deferring random address update"); 36648d97250eSJohan Hedberg return; 36658d97250eSJohan Hedberg } 36668d97250eSJohan Hedberg 36678d97250eSJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, rpa); 36688d97250eSJohan Hedberg } 36698d97250eSJohan Hedberg 367094b1fc92SMarcel Holtmann int hci_update_random_address(struct hci_request *req, bool require_privacy, 367194b1fc92SMarcel Holtmann u8 *own_addr_type) 3672ebd3a747SJohan Hedberg { 3673ebd3a747SJohan Hedberg struct hci_dev *hdev = req->hdev; 3674ebd3a747SJohan Hedberg int err; 3675ebd3a747SJohan Hedberg 3676ebd3a747SJohan Hedberg /* If privacy is enabled use a resolvable private address. If 36772b5224dcSMarcel Holtmann * current RPA has expired or there is something else than 36782b5224dcSMarcel Holtmann * the current RPA in use, then generate a new one. 3679ebd3a747SJohan Hedberg */ 3680ebd3a747SJohan Hedberg if (test_bit(HCI_PRIVACY, &hdev->dev_flags)) { 3681ebd3a747SJohan Hedberg int to; 3682ebd3a747SJohan Hedberg 3683ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3684ebd3a747SJohan Hedberg 3685ebd3a747SJohan Hedberg if (!test_and_clear_bit(HCI_RPA_EXPIRED, &hdev->dev_flags) && 36862b5224dcSMarcel Holtmann !bacmp(&hdev->random_addr, &hdev->rpa)) 3687ebd3a747SJohan Hedberg return 0; 3688ebd3a747SJohan Hedberg 36892b5224dcSMarcel Holtmann err = smp_generate_rpa(hdev->tfm_aes, hdev->irk, &hdev->rpa); 3690ebd3a747SJohan Hedberg if (err < 0) { 3691ebd3a747SJohan Hedberg BT_ERR("%s failed to generate new RPA", hdev->name); 3692ebd3a747SJohan Hedberg return err; 3693ebd3a747SJohan Hedberg } 3694ebd3a747SJohan Hedberg 36958d97250eSJohan Hedberg set_random_addr(req, &hdev->rpa); 3696ebd3a747SJohan Hedberg 3697ebd3a747SJohan Hedberg to = msecs_to_jiffies(hdev->rpa_timeout * 1000); 3698ebd3a747SJohan Hedberg queue_delayed_work(hdev->workqueue, &hdev->rpa_expired, to); 3699ebd3a747SJohan Hedberg 3700ebd3a747SJohan Hedberg return 0; 3701ebd3a747SJohan Hedberg } 3702ebd3a747SJohan Hedberg 370394b1fc92SMarcel Holtmann /* In case of required privacy without resolvable private address, 370494b1fc92SMarcel Holtmann * use an unresolvable private address. This is useful for active 370594b1fc92SMarcel Holtmann * scanning and non-connectable advertising. 370694b1fc92SMarcel Holtmann */ 370794b1fc92SMarcel Holtmann if (require_privacy) { 370894b1fc92SMarcel Holtmann bdaddr_t urpa; 370994b1fc92SMarcel Holtmann 371094b1fc92SMarcel Holtmann get_random_bytes(&urpa, 6); 371194b1fc92SMarcel Holtmann urpa.b[5] &= 0x3f; /* Clear two most significant bits */ 371294b1fc92SMarcel Holtmann 371394b1fc92SMarcel Holtmann *own_addr_type = ADDR_LE_DEV_RANDOM; 37148d97250eSJohan Hedberg set_random_addr(req, &urpa); 371594b1fc92SMarcel Holtmann return 0; 371694b1fc92SMarcel Holtmann } 371794b1fc92SMarcel Holtmann 3718ebd3a747SJohan Hedberg /* If forcing static address is in use or there is no public 3719ebd3a747SJohan Hedberg * address use the static address as random address (but skip 3720ebd3a747SJohan Hedberg * the HCI command if the current random address is already the 3721ebd3a747SJohan Hedberg * static one. 3722ebd3a747SJohan Hedberg */ 3723111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3724ebd3a747SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3725ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3726ebd3a747SJohan Hedberg if (bacmp(&hdev->static_addr, &hdev->random_addr)) 3727ebd3a747SJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, 3728ebd3a747SJohan Hedberg &hdev->static_addr); 3729ebd3a747SJohan Hedberg return 0; 3730ebd3a747SJohan Hedberg } 3731ebd3a747SJohan Hedberg 3732ebd3a747SJohan Hedberg /* Neither privacy nor static address is being used so use a 3733ebd3a747SJohan Hedberg * public address. 3734ebd3a747SJohan Hedberg */ 3735ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_PUBLIC; 3736ebd3a747SJohan Hedberg 3737ebd3a747SJohan Hedberg return 0; 3738ebd3a747SJohan Hedberg } 3739ebd3a747SJohan Hedberg 3740a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 3741a1f4c318SJohan Hedberg * 3742a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 3743a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 3744a1f4c318SJohan Hedberg * the static random address. 3745a1f4c318SJohan Hedberg * 3746a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 3747a1f4c318SJohan Hedberg * public address to use the static random address instead. 3748a1f4c318SJohan Hedberg */ 3749a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 3750a1f4c318SJohan Hedberg u8 *bdaddr_type) 3751a1f4c318SJohan Hedberg { 3752111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3753a1f4c318SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3754a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3755a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3756a1f4c318SJohan Hedberg } else { 3757a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3758a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3759a1f4c318SJohan Hedberg } 3760a1f4c318SJohan Hedberg } 3761a1f4c318SJohan Hedberg 37629be0dab7SDavid Herrmann /* Alloc HCI device */ 37639be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 37649be0dab7SDavid Herrmann { 37659be0dab7SDavid Herrmann struct hci_dev *hdev; 37669be0dab7SDavid Herrmann 37679be0dab7SDavid Herrmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 37689be0dab7SDavid Herrmann if (!hdev) 37699be0dab7SDavid Herrmann return NULL; 37709be0dab7SDavid Herrmann 3771b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3772b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3773b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3774b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3775b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 3776bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3777bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3778b1b813d4SDavid Herrmann 3779b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3780b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3781b1b813d4SDavid Herrmann 37823f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3783bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3784bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 37854e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 37864e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 378704fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 378804fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3789bef64738SMarcel Holtmann 3790d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3791b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 379231ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 379331ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3794d6bfd59cSJohan Hedberg 3795b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3796b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3797b1b813d4SDavid Herrmann 3798b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3799b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 3800b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3801b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3802b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3803970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3804b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3805d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 380615819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 380777a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 38086b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3809b1b813d4SDavid Herrmann 3810b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3811b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3812b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3813b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3814b1b813d4SDavid Herrmann 3815b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3816b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 3817b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 3818b1b813d4SDavid Herrmann 3819b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3820b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3821b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3822b1b813d4SDavid Herrmann 3823b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3824b1b813d4SDavid Herrmann 382565cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3826b1b813d4SDavid Herrmann 3827b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3828b1b813d4SDavid Herrmann discovery_init(hdev); 38299be0dab7SDavid Herrmann 38309be0dab7SDavid Herrmann return hdev; 38319be0dab7SDavid Herrmann } 38329be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 38339be0dab7SDavid Herrmann 38349be0dab7SDavid Herrmann /* Free HCI device */ 38359be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 38369be0dab7SDavid Herrmann { 38379be0dab7SDavid Herrmann /* will free via device release */ 38389be0dab7SDavid Herrmann put_device(&hdev->dev); 38399be0dab7SDavid Herrmann } 38409be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 38419be0dab7SDavid Herrmann 38421da177e4SLinus Torvalds /* Register HCI device */ 38431da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 38441da177e4SLinus Torvalds { 3845b1b813d4SDavid Herrmann int id, error; 38461da177e4SLinus Torvalds 3847010666a1SDavid Herrmann if (!hdev->open || !hdev->close) 38481da177e4SLinus Torvalds return -EINVAL; 38491da177e4SLinus Torvalds 385008add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 385108add513SMat Martineau * so the index can be used as the AMP controller ID. 385208add513SMat Martineau */ 38533df92b31SSasha Levin switch (hdev->dev_type) { 38543df92b31SSasha Levin case HCI_BREDR: 38553df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 38561da177e4SLinus Torvalds break; 38573df92b31SSasha Levin case HCI_AMP: 38583df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 38593df92b31SSasha Levin break; 38603df92b31SSasha Levin default: 38613df92b31SSasha Levin return -EINVAL; 38621da177e4SLinus Torvalds } 38631da177e4SLinus Torvalds 38643df92b31SSasha Levin if (id < 0) 38653df92b31SSasha Levin return id; 38663df92b31SSasha Levin 38671da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 38681da177e4SLinus Torvalds hdev->id = id; 38692d8b3a11SAndrei Emeltchenko 38702d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 38712d8b3a11SAndrei Emeltchenko 3872d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3873d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 387433ca954dSDavid Herrmann if (!hdev->workqueue) { 387533ca954dSDavid Herrmann error = -ENOMEM; 387633ca954dSDavid Herrmann goto err; 387733ca954dSDavid Herrmann } 3878f48fd9c8SMarcel Holtmann 3879d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3880d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 38816ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 38826ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 38836ead1bbcSJohan Hedberg error = -ENOMEM; 38846ead1bbcSJohan Hedberg goto err; 38856ead1bbcSJohan Hedberg } 38866ead1bbcSJohan Hedberg 38870153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 38880153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 38890153e2ecSMarcel Holtmann 3890bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 3891bdc3e0f1SMarcel Holtmann 389299780a7bSJohan Hedberg hdev->tfm_aes = crypto_alloc_blkcipher("ecb(aes)", 0, 389399780a7bSJohan Hedberg CRYPTO_ALG_ASYNC); 389499780a7bSJohan Hedberg if (IS_ERR(hdev->tfm_aes)) { 389599780a7bSJohan Hedberg BT_ERR("Unable to create crypto context"); 389699780a7bSJohan Hedberg error = PTR_ERR(hdev->tfm_aes); 389799780a7bSJohan Hedberg hdev->tfm_aes = NULL; 389899780a7bSJohan Hedberg goto err_wqueue; 389999780a7bSJohan Hedberg } 390099780a7bSJohan Hedberg 3901bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 390233ca954dSDavid Herrmann if (error < 0) 390399780a7bSJohan Hedberg goto err_tfm; 39041da177e4SLinus Torvalds 3905611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 3906a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 3907a8c5fb1aSGustavo Padovan hdev); 3908611b30f7SMarcel Holtmann if (hdev->rfkill) { 3909611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 3910611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3911611b30f7SMarcel Holtmann hdev->rfkill = NULL; 3912611b30f7SMarcel Holtmann } 3913611b30f7SMarcel Holtmann } 3914611b30f7SMarcel Holtmann 39155e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 39165e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 39175e130367SJohan Hedberg 3918a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 3919004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 3920ce2be9acSAndrei Emeltchenko 392101cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 392256f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 392356f87901SJohan Hedberg * through reading supported features during init. 392456f87901SJohan Hedberg */ 392556f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 392656f87901SJohan Hedberg } 3927ce2be9acSAndrei Emeltchenko 3928fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 3929fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 3930fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3931fcee3377SGustavo Padovan 3932fee746b0SMarcel Holtmann /* Devices that are marked for raw-only usage need to set 3933fee746b0SMarcel Holtmann * the HCI_RAW flag to indicate that only user channel is 3934fee746b0SMarcel Holtmann * supported. 3935fee746b0SMarcel Holtmann */ 3936fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 3937fee746b0SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 3938fee746b0SMarcel Holtmann 39391da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 3940dc946bd8SDavid Herrmann hci_dev_hold(hdev); 39411da177e4SLinus Torvalds 394219202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3943fbe96d6fSMarcel Holtmann 39441da177e4SLinus Torvalds return id; 3945f48fd9c8SMarcel Holtmann 394699780a7bSJohan Hedberg err_tfm: 394799780a7bSJohan Hedberg crypto_free_blkcipher(hdev->tfm_aes); 394833ca954dSDavid Herrmann err_wqueue: 394933ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 39506ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 395133ca954dSDavid Herrmann err: 39523df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3953f48fd9c8SMarcel Holtmann 395433ca954dSDavid Herrmann return error; 39551da177e4SLinus Torvalds } 39561da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 39571da177e4SLinus Torvalds 39581da177e4SLinus Torvalds /* Unregister HCI device */ 395959735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 39601da177e4SLinus Torvalds { 39613df92b31SSasha Levin int i, id; 3962ef222013SMarcel Holtmann 3963c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 39641da177e4SLinus Torvalds 396594324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 396694324962SJohan Hovold 39673df92b31SSasha Levin id = hdev->id; 39683df92b31SSasha Levin 3969f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 39701da177e4SLinus Torvalds list_del(&hdev->list); 3971f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 39721da177e4SLinus Torvalds 39731da177e4SLinus Torvalds hci_dev_do_close(hdev); 39741da177e4SLinus Torvalds 3975cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 3976ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 3977ef222013SMarcel Holtmann 3978b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3979b9b5ef18SGustavo Padovan 3980ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3981fee746b0SMarcel Holtmann !test_bit(HCI_SETUP, &hdev->dev_flags) && 3982fee746b0SMarcel Holtmann !test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) { 398309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3984744cf19eSJohan Hedberg mgmt_index_removed(hdev); 398509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 398656e5cb86SJohan Hedberg } 3987ab81cbf9SJohan Hedberg 39882e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 39892e58ef3eSJohan Hedberg * pending list */ 39902e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 39912e58ef3eSJohan Hedberg 39921da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 39931da177e4SLinus Torvalds 3994611b30f7SMarcel Holtmann if (hdev->rfkill) { 3995611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3996611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3997611b30f7SMarcel Holtmann } 3998611b30f7SMarcel Holtmann 399999780a7bSJohan Hedberg if (hdev->tfm_aes) 400099780a7bSJohan Hedberg crypto_free_blkcipher(hdev->tfm_aes); 400199780a7bSJohan Hedberg 4002bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 4003147e2d59SDave Young 40040153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 40050153e2ecSMarcel Holtmann 4006f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 40076ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 4008f48fd9c8SMarcel Holtmann 400909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 4010e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 40112aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 401255ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 4013b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 4014970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 40152763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 4016d2ab0ac1SMarcel Holtmann hci_white_list_clear(hdev); 401715819a70SAndre Guedes hci_conn_params_clear(hdev); 401809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 4019e2e0cacbSJohan Hedberg 4020dc946bd8SDavid Herrmann hci_dev_put(hdev); 40213df92b31SSasha Levin 40223df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 40231da177e4SLinus Torvalds } 40241da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 40251da177e4SLinus Torvalds 40261da177e4SLinus Torvalds /* Suspend HCI device */ 40271da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 40281da177e4SLinus Torvalds { 40291da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 40301da177e4SLinus Torvalds return 0; 40311da177e4SLinus Torvalds } 40321da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 40331da177e4SLinus Torvalds 40341da177e4SLinus Torvalds /* Resume HCI device */ 40351da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 40361da177e4SLinus Torvalds { 40371da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 40381da177e4SLinus Torvalds return 0; 40391da177e4SLinus Torvalds } 40401da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 40411da177e4SLinus Torvalds 404276bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 4043e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 404476bca880SMarcel Holtmann { 404576bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 404676bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 404776bca880SMarcel Holtmann kfree_skb(skb); 404876bca880SMarcel Holtmann return -ENXIO; 404976bca880SMarcel Holtmann } 405076bca880SMarcel Holtmann 4051d82603c6SJorrit Schippers /* Incoming skb */ 405276bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 405376bca880SMarcel Holtmann 405476bca880SMarcel Holtmann /* Time stamp */ 405576bca880SMarcel Holtmann __net_timestamp(skb); 405676bca880SMarcel Holtmann 405776bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 4058b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 4059c78ae283SMarcel Holtmann 406076bca880SMarcel Holtmann return 0; 406176bca880SMarcel Holtmann } 406276bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 406376bca880SMarcel Holtmann 406433e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 40651e429f38SGustavo F. Padovan int count, __u8 index) 406633e882a5SSuraj Sumangala { 406733e882a5SSuraj Sumangala int len = 0; 406833e882a5SSuraj Sumangala int hlen = 0; 406933e882a5SSuraj Sumangala int remain = count; 407033e882a5SSuraj Sumangala struct sk_buff *skb; 407133e882a5SSuraj Sumangala struct bt_skb_cb *scb; 407233e882a5SSuraj Sumangala 407333e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 407433e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 407533e882a5SSuraj Sumangala return -EILSEQ; 407633e882a5SSuraj Sumangala 407733e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 407833e882a5SSuraj Sumangala 407933e882a5SSuraj Sumangala if (!skb) { 408033e882a5SSuraj Sumangala switch (type) { 408133e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 408233e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 408333e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 408433e882a5SSuraj Sumangala break; 408533e882a5SSuraj Sumangala case HCI_EVENT_PKT: 408633e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 408733e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 408833e882a5SSuraj Sumangala break; 408933e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 409033e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 409133e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 409233e882a5SSuraj Sumangala break; 409333e882a5SSuraj Sumangala } 409433e882a5SSuraj Sumangala 40951e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 409633e882a5SSuraj Sumangala if (!skb) 409733e882a5SSuraj Sumangala return -ENOMEM; 409833e882a5SSuraj Sumangala 409933e882a5SSuraj Sumangala scb = (void *) skb->cb; 410033e882a5SSuraj Sumangala scb->expect = hlen; 410133e882a5SSuraj Sumangala scb->pkt_type = type; 410233e882a5SSuraj Sumangala 410333e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 410433e882a5SSuraj Sumangala } 410533e882a5SSuraj Sumangala 410633e882a5SSuraj Sumangala while (count) { 410733e882a5SSuraj Sumangala scb = (void *) skb->cb; 410889bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 410933e882a5SSuraj Sumangala 411033e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 411133e882a5SSuraj Sumangala 411233e882a5SSuraj Sumangala count -= len; 411333e882a5SSuraj Sumangala data += len; 411433e882a5SSuraj Sumangala scb->expect -= len; 411533e882a5SSuraj Sumangala remain = count; 411633e882a5SSuraj Sumangala 411733e882a5SSuraj Sumangala switch (type) { 411833e882a5SSuraj Sumangala case HCI_EVENT_PKT: 411933e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 412033e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 412133e882a5SSuraj Sumangala scb->expect = h->plen; 412233e882a5SSuraj Sumangala 412333e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 412433e882a5SSuraj Sumangala kfree_skb(skb); 412533e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 412633e882a5SSuraj Sumangala return -ENOMEM; 412733e882a5SSuraj Sumangala } 412833e882a5SSuraj Sumangala } 412933e882a5SSuraj Sumangala break; 413033e882a5SSuraj Sumangala 413133e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 413233e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 413333e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 413433e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 413533e882a5SSuraj Sumangala 413633e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 413733e882a5SSuraj Sumangala kfree_skb(skb); 413833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 413933e882a5SSuraj Sumangala return -ENOMEM; 414033e882a5SSuraj Sumangala } 414133e882a5SSuraj Sumangala } 414233e882a5SSuraj Sumangala break; 414333e882a5SSuraj Sumangala 414433e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 414533e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 414633e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 414733e882a5SSuraj Sumangala scb->expect = h->dlen; 414833e882a5SSuraj Sumangala 414933e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 415033e882a5SSuraj Sumangala kfree_skb(skb); 415133e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 415233e882a5SSuraj Sumangala return -ENOMEM; 415333e882a5SSuraj Sumangala } 415433e882a5SSuraj Sumangala } 415533e882a5SSuraj Sumangala break; 415633e882a5SSuraj Sumangala } 415733e882a5SSuraj Sumangala 415833e882a5SSuraj Sumangala if (scb->expect == 0) { 415933e882a5SSuraj Sumangala /* Complete frame */ 416033e882a5SSuraj Sumangala 416133e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 4162e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 416333e882a5SSuraj Sumangala 416433e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 416533e882a5SSuraj Sumangala return remain; 416633e882a5SSuraj Sumangala } 416733e882a5SSuraj Sumangala } 416833e882a5SSuraj Sumangala 416933e882a5SSuraj Sumangala return remain; 417033e882a5SSuraj Sumangala } 417133e882a5SSuraj Sumangala 4172ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 4173ef222013SMarcel Holtmann { 4174f39a3c06SSuraj Sumangala int rem = 0; 4175f39a3c06SSuraj Sumangala 4176ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 4177ef222013SMarcel Holtmann return -EILSEQ; 4178ef222013SMarcel Holtmann 4179da5f6c37SGustavo F. Padovan while (count) { 41801e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, type - 1); 4181f39a3c06SSuraj Sumangala if (rem < 0) 4182f39a3c06SSuraj Sumangala return rem; 4183ef222013SMarcel Holtmann 4184f39a3c06SSuraj Sumangala data += (count - rem); 4185f39a3c06SSuraj Sumangala count = rem; 4186f81c6224SJoe Perches } 4187ef222013SMarcel Holtmann 4188f39a3c06SSuraj Sumangala return rem; 4189ef222013SMarcel Holtmann } 4190ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 4191ef222013SMarcel Holtmann 419299811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 419399811510SSuraj Sumangala 419499811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 419599811510SSuraj Sumangala { 419699811510SSuraj Sumangala int type; 419799811510SSuraj Sumangala int rem = 0; 419899811510SSuraj Sumangala 4199da5f6c37SGustavo F. Padovan while (count) { 420099811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 420199811510SSuraj Sumangala 420299811510SSuraj Sumangala if (!skb) { 420399811510SSuraj Sumangala struct { char type; } *pkt; 420499811510SSuraj Sumangala 420599811510SSuraj Sumangala /* Start of the frame */ 420699811510SSuraj Sumangala pkt = data; 420799811510SSuraj Sumangala type = pkt->type; 420899811510SSuraj Sumangala 420999811510SSuraj Sumangala data++; 421099811510SSuraj Sumangala count--; 421199811510SSuraj Sumangala } else 421299811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 421399811510SSuraj Sumangala 42141e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 42151e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 421699811510SSuraj Sumangala if (rem < 0) 421799811510SSuraj Sumangala return rem; 421899811510SSuraj Sumangala 421999811510SSuraj Sumangala data += (count - rem); 422099811510SSuraj Sumangala count = rem; 4221f81c6224SJoe Perches } 422299811510SSuraj Sumangala 422399811510SSuraj Sumangala return rem; 422499811510SSuraj Sumangala } 422599811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 422699811510SSuraj Sumangala 42271da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 42281da177e4SLinus Torvalds 42291da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 42301da177e4SLinus Torvalds { 42311da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 42321da177e4SLinus Torvalds 4233f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 42341da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 4235f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 42361da177e4SLinus Torvalds 42371da177e4SLinus Torvalds return 0; 42381da177e4SLinus Torvalds } 42391da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 42401da177e4SLinus Torvalds 42411da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 42421da177e4SLinus Torvalds { 42431da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 42441da177e4SLinus Torvalds 4245f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 42461da177e4SLinus Torvalds list_del(&cb->list); 4247f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 42481da177e4SLinus Torvalds 42491da177e4SLinus Torvalds return 0; 42501da177e4SLinus Torvalds } 42511da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 42521da177e4SLinus Torvalds 425351086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 42541da177e4SLinus Torvalds { 42550d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 42561da177e4SLinus Torvalds 42571da177e4SLinus Torvalds /* Time stamp */ 4258a61bbcf2SPatrick McHardy __net_timestamp(skb); 42591da177e4SLinus Torvalds 4260cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4261cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4262cd82e61cSMarcel Holtmann 4263cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 4264cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 4265470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 42661da177e4SLinus Torvalds } 42671da177e4SLinus Torvalds 42681da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 42691da177e4SLinus Torvalds skb_orphan(skb); 42701da177e4SLinus Torvalds 42717bd8f09fSMarcel Holtmann if (hdev->send(hdev, skb) < 0) 427251086991SMarcel Holtmann BT_ERR("%s sending frame failed", hdev->name); 42731da177e4SLinus Torvalds } 42741da177e4SLinus Torvalds 42753119ae95SJohan Hedberg void hci_req_init(struct hci_request *req, struct hci_dev *hdev) 42763119ae95SJohan Hedberg { 42773119ae95SJohan Hedberg skb_queue_head_init(&req->cmd_q); 42783119ae95SJohan Hedberg req->hdev = hdev; 42795d73e034SAndre Guedes req->err = 0; 42803119ae95SJohan Hedberg } 42813119ae95SJohan Hedberg 42823119ae95SJohan Hedberg int hci_req_run(struct hci_request *req, hci_req_complete_t complete) 42833119ae95SJohan Hedberg { 42843119ae95SJohan Hedberg struct hci_dev *hdev = req->hdev; 42853119ae95SJohan Hedberg struct sk_buff *skb; 42863119ae95SJohan Hedberg unsigned long flags; 42873119ae95SJohan Hedberg 42883119ae95SJohan Hedberg BT_DBG("length %u", skb_queue_len(&req->cmd_q)); 42893119ae95SJohan Hedberg 42905d73e034SAndre Guedes /* If an error occured during request building, remove all HCI 42915d73e034SAndre Guedes * commands queued on the HCI request queue. 42925d73e034SAndre Guedes */ 42935d73e034SAndre Guedes if (req->err) { 42945d73e034SAndre Guedes skb_queue_purge(&req->cmd_q); 42955d73e034SAndre Guedes return req->err; 42965d73e034SAndre Guedes } 42975d73e034SAndre Guedes 42983119ae95SJohan Hedberg /* Do not allow empty requests */ 42993119ae95SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 4300382b0c39SAndre Guedes return -ENODATA; 43013119ae95SJohan Hedberg 43023119ae95SJohan Hedberg skb = skb_peek_tail(&req->cmd_q); 43033119ae95SJohan Hedberg bt_cb(skb)->req.complete = complete; 43043119ae95SJohan Hedberg 43053119ae95SJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 43063119ae95SJohan Hedberg skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q); 43073119ae95SJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 43083119ae95SJohan Hedberg 43093119ae95SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 43103119ae95SJohan Hedberg 43113119ae95SJohan Hedberg return 0; 43123119ae95SJohan Hedberg } 43133119ae95SJohan Hedberg 43141ca3a9d0SJohan Hedberg static struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, 431507dc93ddSJohan Hedberg u32 plen, const void *param) 43161da177e4SLinus Torvalds { 43171da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 43181da177e4SLinus Torvalds struct hci_command_hdr *hdr; 43191da177e4SLinus Torvalds struct sk_buff *skb; 43201da177e4SLinus Torvalds 43211da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 43221ca3a9d0SJohan Hedberg if (!skb) 43231ca3a9d0SJohan Hedberg return NULL; 43241da177e4SLinus Torvalds 43251da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 4326a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 43271da177e4SLinus Torvalds hdr->plen = plen; 43281da177e4SLinus Torvalds 43291da177e4SLinus Torvalds if (plen) 43301da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 43311da177e4SLinus Torvalds 43321da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 43331da177e4SLinus Torvalds 43340d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 4335c78ae283SMarcel Holtmann 43361ca3a9d0SJohan Hedberg return skb; 43371ca3a9d0SJohan Hedberg } 43381ca3a9d0SJohan Hedberg 43391ca3a9d0SJohan Hedberg /* Send HCI command */ 434007dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 434107dc93ddSJohan Hedberg const void *param) 43421ca3a9d0SJohan Hedberg { 43431ca3a9d0SJohan Hedberg struct sk_buff *skb; 43441ca3a9d0SJohan Hedberg 43451ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 43461ca3a9d0SJohan Hedberg 43471ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 43481ca3a9d0SJohan Hedberg if (!skb) { 43491ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 43501ca3a9d0SJohan Hedberg return -ENOMEM; 43511ca3a9d0SJohan Hedberg } 43521ca3a9d0SJohan Hedberg 435311714b3dSJohan Hedberg /* Stand-alone HCI commands must be flaged as 435411714b3dSJohan Hedberg * single-command requests. 435511714b3dSJohan Hedberg */ 435611714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 435711714b3dSJohan Hedberg 43581da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 4359c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 43601da177e4SLinus Torvalds 43611da177e4SLinus Torvalds return 0; 43621da177e4SLinus Torvalds } 43631da177e4SLinus Torvalds 436471c76a17SJohan Hedberg /* Queue a command to an asynchronous HCI request */ 436507dc93ddSJohan Hedberg void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen, 436607dc93ddSJohan Hedberg const void *param, u8 event) 436771c76a17SJohan Hedberg { 436871c76a17SJohan Hedberg struct hci_dev *hdev = req->hdev; 436971c76a17SJohan Hedberg struct sk_buff *skb; 437071c76a17SJohan Hedberg 437171c76a17SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 437271c76a17SJohan Hedberg 437334739c1eSAndre Guedes /* If an error occured during request building, there is no point in 437434739c1eSAndre Guedes * queueing the HCI command. We can simply return. 437534739c1eSAndre Guedes */ 437634739c1eSAndre Guedes if (req->err) 437734739c1eSAndre Guedes return; 437834739c1eSAndre Guedes 437971c76a17SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 438071c76a17SJohan Hedberg if (!skb) { 43815d73e034SAndre Guedes BT_ERR("%s no memory for command (opcode 0x%4.4x)", 43825d73e034SAndre Guedes hdev->name, opcode); 43835d73e034SAndre Guedes req->err = -ENOMEM; 4384e348fe6bSAndre Guedes return; 438571c76a17SJohan Hedberg } 438671c76a17SJohan Hedberg 438771c76a17SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 438871c76a17SJohan Hedberg bt_cb(skb)->req.start = true; 438971c76a17SJohan Hedberg 439002350a72SJohan Hedberg bt_cb(skb)->req.event = event; 439102350a72SJohan Hedberg 439271c76a17SJohan Hedberg skb_queue_tail(&req->cmd_q, skb); 439371c76a17SJohan Hedberg } 439471c76a17SJohan Hedberg 439507dc93ddSJohan Hedberg void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, 439607dc93ddSJohan Hedberg const void *param) 439702350a72SJohan Hedberg { 439802350a72SJohan Hedberg hci_req_add_ev(req, opcode, plen, param, 0); 439902350a72SJohan Hedberg } 440002350a72SJohan Hedberg 44011da177e4SLinus Torvalds /* Get data from the previously sent command */ 4402a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 44031da177e4SLinus Torvalds { 44041da177e4SLinus Torvalds struct hci_command_hdr *hdr; 44051da177e4SLinus Torvalds 44061da177e4SLinus Torvalds if (!hdev->sent_cmd) 44071da177e4SLinus Torvalds return NULL; 44081da177e4SLinus Torvalds 44091da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 44101da177e4SLinus Torvalds 4411a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 44121da177e4SLinus Torvalds return NULL; 44131da177e4SLinus Torvalds 4414f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 44151da177e4SLinus Torvalds 44161da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 44171da177e4SLinus Torvalds } 44181da177e4SLinus Torvalds 44191da177e4SLinus Torvalds /* Send ACL data */ 44201da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 44211da177e4SLinus Torvalds { 44221da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 44231da177e4SLinus Torvalds int len = skb->len; 44241da177e4SLinus Torvalds 4425badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 4426badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 44279c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 4428aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 4429aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 44301da177e4SLinus Torvalds } 44311da177e4SLinus Torvalds 4432ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 443373d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 44341da177e4SLinus Torvalds { 4435ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 44361da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 44371da177e4SLinus Torvalds struct sk_buff *list; 44381da177e4SLinus Torvalds 4439087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 4440087bfd99SGustavo Padovan skb->data_len = 0; 4441087bfd99SGustavo Padovan 4442087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4443204a6e54SAndrei Emeltchenko 4444204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 4445204a6e54SAndrei Emeltchenko case HCI_BREDR: 4446087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 4447204a6e54SAndrei Emeltchenko break; 4448204a6e54SAndrei Emeltchenko case HCI_AMP: 4449204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 4450204a6e54SAndrei Emeltchenko break; 4451204a6e54SAndrei Emeltchenko default: 4452204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 4453204a6e54SAndrei Emeltchenko return; 4454204a6e54SAndrei Emeltchenko } 4455087bfd99SGustavo Padovan 445670f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 445770f23020SAndrei Emeltchenko if (!list) { 44581da177e4SLinus Torvalds /* Non fragmented */ 44591da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 44601da177e4SLinus Torvalds 446173d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 44621da177e4SLinus Torvalds } else { 44631da177e4SLinus Torvalds /* Fragmented */ 44641da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 44651da177e4SLinus Torvalds 44661da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 44671da177e4SLinus Torvalds 44681da177e4SLinus Torvalds /* Queue all fragments atomically */ 4469af3e6359SGustavo F. Padovan spin_lock(&queue->lock); 44701da177e4SLinus Torvalds 447173d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 4472e702112fSAndrei Emeltchenko 4473e702112fSAndrei Emeltchenko flags &= ~ACL_START; 4474e702112fSAndrei Emeltchenko flags |= ACL_CONT; 44751da177e4SLinus Torvalds do { 44761da177e4SLinus Torvalds skb = list; list = list->next; 44771da177e4SLinus Torvalds 44780d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4479e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 44801da177e4SLinus Torvalds 44811da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 44821da177e4SLinus Torvalds 448373d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 44841da177e4SLinus Torvalds } while (list); 44851da177e4SLinus Torvalds 4486af3e6359SGustavo F. Padovan spin_unlock(&queue->lock); 44871da177e4SLinus Torvalds } 448873d80debSLuiz Augusto von Dentz } 448973d80debSLuiz Augusto von Dentz 449073d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 449173d80debSLuiz Augusto von Dentz { 4492ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 449373d80debSLuiz Augusto von Dentz 4494f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 449573d80debSLuiz Augusto von Dentz 4496ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 44971da177e4SLinus Torvalds 44983eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 44991da177e4SLinus Torvalds } 45001da177e4SLinus Torvalds 45011da177e4SLinus Torvalds /* Send SCO data */ 45020d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 45031da177e4SLinus Torvalds { 45041da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 45051da177e4SLinus Torvalds struct hci_sco_hdr hdr; 45061da177e4SLinus Torvalds 45071da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 45081da177e4SLinus Torvalds 4509aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 45101da177e4SLinus Torvalds hdr.dlen = skb->len; 45111da177e4SLinus Torvalds 4512badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 4513badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 45149c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 45151da177e4SLinus Torvalds 45160d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 4517c78ae283SMarcel Holtmann 45181da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 45193eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 45201da177e4SLinus Torvalds } 45211da177e4SLinus Torvalds 45221da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 45231da177e4SLinus Torvalds 45241da177e4SLinus Torvalds /* HCI Connection scheduler */ 45256039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 4526a8c5fb1aSGustavo Padovan int *quote) 45271da177e4SLinus Torvalds { 45281da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 45298035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 4530abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 45311da177e4SLinus Torvalds 45321da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 45331da177e4SLinus Torvalds * added and removed with TX task disabled. */ 4534bf4c6325SGustavo F. Padovan 4535bf4c6325SGustavo F. Padovan rcu_read_lock(); 4536bf4c6325SGustavo F. Padovan 4537bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4538769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 45391da177e4SLinus Torvalds continue; 4540769be974SMarcel Holtmann 4541769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 4542769be974SMarcel Holtmann continue; 4543769be974SMarcel Holtmann 45441da177e4SLinus Torvalds num++; 45451da177e4SLinus Torvalds 45461da177e4SLinus Torvalds if (c->sent < min) { 45471da177e4SLinus Torvalds min = c->sent; 45481da177e4SLinus Torvalds conn = c; 45491da177e4SLinus Torvalds } 455052087a79SLuiz Augusto von Dentz 455152087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 455252087a79SLuiz Augusto von Dentz break; 45531da177e4SLinus Torvalds } 45541da177e4SLinus Torvalds 4555bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4556bf4c6325SGustavo F. Padovan 45571da177e4SLinus Torvalds if (conn) { 45586ed58ec5SVille Tervo int cnt, q; 45596ed58ec5SVille Tervo 45606ed58ec5SVille Tervo switch (conn->type) { 45616ed58ec5SVille Tervo case ACL_LINK: 45626ed58ec5SVille Tervo cnt = hdev->acl_cnt; 45636ed58ec5SVille Tervo break; 45646ed58ec5SVille Tervo case SCO_LINK: 45656ed58ec5SVille Tervo case ESCO_LINK: 45666ed58ec5SVille Tervo cnt = hdev->sco_cnt; 45676ed58ec5SVille Tervo break; 45686ed58ec5SVille Tervo case LE_LINK: 45696ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 45706ed58ec5SVille Tervo break; 45716ed58ec5SVille Tervo default: 45726ed58ec5SVille Tervo cnt = 0; 45736ed58ec5SVille Tervo BT_ERR("Unknown link type"); 45746ed58ec5SVille Tervo } 45756ed58ec5SVille Tervo 45766ed58ec5SVille Tervo q = cnt / num; 45771da177e4SLinus Torvalds *quote = q ? q : 1; 45781da177e4SLinus Torvalds } else 45791da177e4SLinus Torvalds *quote = 0; 45801da177e4SLinus Torvalds 45811da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 45821da177e4SLinus Torvalds return conn; 45831da177e4SLinus Torvalds } 45841da177e4SLinus Torvalds 45856039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 45861da177e4SLinus Torvalds { 45871da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 45881da177e4SLinus Torvalds struct hci_conn *c; 45891da177e4SLinus Torvalds 4590bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 45911da177e4SLinus Torvalds 4592bf4c6325SGustavo F. Padovan rcu_read_lock(); 4593bf4c6325SGustavo F. Padovan 45941da177e4SLinus Torvalds /* Kill stalled connections */ 4595bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4596bae1f5d9SVille Tervo if (c->type == type && c->sent) { 45976ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 45986ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 4599bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 46001da177e4SLinus Torvalds } 46011da177e4SLinus Torvalds } 4602bf4c6325SGustavo F. Padovan 4603bf4c6325SGustavo F. Padovan rcu_read_unlock(); 46041da177e4SLinus Torvalds } 46051da177e4SLinus Torvalds 46066039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 460773d80debSLuiz Augusto von Dentz int *quote) 460873d80debSLuiz Augusto von Dentz { 460973d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 461073d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 4611abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 461273d80debSLuiz Augusto von Dentz struct hci_conn *conn; 461373d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 461473d80debSLuiz Augusto von Dentz 461573d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 461673d80debSLuiz Augusto von Dentz 4617bf4c6325SGustavo F. Padovan rcu_read_lock(); 4618bf4c6325SGustavo F. Padovan 4619bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 462073d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 462173d80debSLuiz Augusto von Dentz 462273d80debSLuiz Augusto von Dentz if (conn->type != type) 462373d80debSLuiz Augusto von Dentz continue; 462473d80debSLuiz Augusto von Dentz 462573d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 462673d80debSLuiz Augusto von Dentz continue; 462773d80debSLuiz Augusto von Dentz 462873d80debSLuiz Augusto von Dentz conn_num++; 462973d80debSLuiz Augusto von Dentz 46308192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 463173d80debSLuiz Augusto von Dentz struct sk_buff *skb; 463273d80debSLuiz Augusto von Dentz 463373d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 463473d80debSLuiz Augusto von Dentz continue; 463573d80debSLuiz Augusto von Dentz 463673d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 463773d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 463873d80debSLuiz Augusto von Dentz continue; 463973d80debSLuiz Augusto von Dentz 464073d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 464173d80debSLuiz Augusto von Dentz num = 0; 464273d80debSLuiz Augusto von Dentz min = ~0; 464373d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 464473d80debSLuiz Augusto von Dentz } 464573d80debSLuiz Augusto von Dentz 464673d80debSLuiz Augusto von Dentz num++; 464773d80debSLuiz Augusto von Dentz 464873d80debSLuiz Augusto von Dentz if (conn->sent < min) { 464973d80debSLuiz Augusto von Dentz min = conn->sent; 465073d80debSLuiz Augusto von Dentz chan = tmp; 465173d80debSLuiz Augusto von Dentz } 465273d80debSLuiz Augusto von Dentz } 465373d80debSLuiz Augusto von Dentz 465473d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 465573d80debSLuiz Augusto von Dentz break; 465673d80debSLuiz Augusto von Dentz } 465773d80debSLuiz Augusto von Dentz 4658bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4659bf4c6325SGustavo F. Padovan 466073d80debSLuiz Augusto von Dentz if (!chan) 466173d80debSLuiz Augusto von Dentz return NULL; 466273d80debSLuiz Augusto von Dentz 466373d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 466473d80debSLuiz Augusto von Dentz case ACL_LINK: 466573d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 466673d80debSLuiz Augusto von Dentz break; 4667bd1eb66bSAndrei Emeltchenko case AMP_LINK: 4668bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 4669bd1eb66bSAndrei Emeltchenko break; 467073d80debSLuiz Augusto von Dentz case SCO_LINK: 467173d80debSLuiz Augusto von Dentz case ESCO_LINK: 467273d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 467373d80debSLuiz Augusto von Dentz break; 467473d80debSLuiz Augusto von Dentz case LE_LINK: 467573d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 467673d80debSLuiz Augusto von Dentz break; 467773d80debSLuiz Augusto von Dentz default: 467873d80debSLuiz Augusto von Dentz cnt = 0; 467973d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 468073d80debSLuiz Augusto von Dentz } 468173d80debSLuiz Augusto von Dentz 468273d80debSLuiz Augusto von Dentz q = cnt / num; 468373d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 468473d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 468573d80debSLuiz Augusto von Dentz return chan; 468673d80debSLuiz Augusto von Dentz } 468773d80debSLuiz Augusto von Dentz 468802b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 468902b20f0bSLuiz Augusto von Dentz { 469002b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 469102b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 469202b20f0bSLuiz Augusto von Dentz int num = 0; 469302b20f0bSLuiz Augusto von Dentz 469402b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 469502b20f0bSLuiz Augusto von Dentz 4696bf4c6325SGustavo F. Padovan rcu_read_lock(); 4697bf4c6325SGustavo F. Padovan 4698bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 469902b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 470002b20f0bSLuiz Augusto von Dentz 470102b20f0bSLuiz Augusto von Dentz if (conn->type != type) 470202b20f0bSLuiz Augusto von Dentz continue; 470302b20f0bSLuiz Augusto von Dentz 470402b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 470502b20f0bSLuiz Augusto von Dentz continue; 470602b20f0bSLuiz Augusto von Dentz 470702b20f0bSLuiz Augusto von Dentz num++; 470802b20f0bSLuiz Augusto von Dentz 47098192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 471002b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 471102b20f0bSLuiz Augusto von Dentz 471202b20f0bSLuiz Augusto von Dentz if (chan->sent) { 471302b20f0bSLuiz Augusto von Dentz chan->sent = 0; 471402b20f0bSLuiz Augusto von Dentz continue; 471502b20f0bSLuiz Augusto von Dentz } 471602b20f0bSLuiz Augusto von Dentz 471702b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 471802b20f0bSLuiz Augusto von Dentz continue; 471902b20f0bSLuiz Augusto von Dentz 472002b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 472102b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 472202b20f0bSLuiz Augusto von Dentz continue; 472302b20f0bSLuiz Augusto von Dentz 472402b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 472502b20f0bSLuiz Augusto von Dentz 472602b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 472702b20f0bSLuiz Augusto von Dentz skb->priority); 472802b20f0bSLuiz Augusto von Dentz } 472902b20f0bSLuiz Augusto von Dentz 473002b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 473102b20f0bSLuiz Augusto von Dentz break; 473202b20f0bSLuiz Augusto von Dentz } 4733bf4c6325SGustavo F. Padovan 4734bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4735bf4c6325SGustavo F. Padovan 473602b20f0bSLuiz Augusto von Dentz } 473702b20f0bSLuiz Augusto von Dentz 4738b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 4739b71d385aSAndrei Emeltchenko { 4740b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 4741b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 4742b71d385aSAndrei Emeltchenko } 4743b71d385aSAndrei Emeltchenko 47446039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 47451da177e4SLinus Torvalds { 4746fee746b0SMarcel Holtmann if (!test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) { 47471da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 47481da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 474963d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 47505f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 4751bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 47521da177e4SLinus Torvalds } 475363d2bc1bSAndrei Emeltchenko } 47541da177e4SLinus Torvalds 47556039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 475663d2bc1bSAndrei Emeltchenko { 475763d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 475863d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 475963d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 476063d2bc1bSAndrei Emeltchenko int quote; 476163d2bc1bSAndrei Emeltchenko 476263d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 476304837f64SMarcel Holtmann 476473d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 476573d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 4766ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4767ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 476873d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 476973d80debSLuiz Augusto von Dentz skb->len, skb->priority); 477073d80debSLuiz Augusto von Dentz 4771ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4772ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4773ec1cce24SLuiz Augusto von Dentz break; 4774ec1cce24SLuiz Augusto von Dentz 4775ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4776ec1cce24SLuiz Augusto von Dentz 477773d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 477873d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 477904837f64SMarcel Holtmann 478057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 47811da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 47821da177e4SLinus Torvalds 47831da177e4SLinus Torvalds hdev->acl_cnt--; 478473d80debSLuiz Augusto von Dentz chan->sent++; 478573d80debSLuiz Augusto von Dentz chan->conn->sent++; 47861da177e4SLinus Torvalds } 47871da177e4SLinus Torvalds } 478802b20f0bSLuiz Augusto von Dentz 478902b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 479002b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 47911da177e4SLinus Torvalds } 47921da177e4SLinus Torvalds 47936039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 4794b71d385aSAndrei Emeltchenko { 479563d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 4796b71d385aSAndrei Emeltchenko struct hci_chan *chan; 4797b71d385aSAndrei Emeltchenko struct sk_buff *skb; 4798b71d385aSAndrei Emeltchenko int quote; 4799bd1eb66bSAndrei Emeltchenko u8 type; 4800b71d385aSAndrei Emeltchenko 480163d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 4802b71d385aSAndrei Emeltchenko 4803bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4804bd1eb66bSAndrei Emeltchenko 4805bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 4806bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 4807bd1eb66bSAndrei Emeltchenko else 4808bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 4809bd1eb66bSAndrei Emeltchenko 4810b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 4811bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 4812b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 4813b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 4814b71d385aSAndrei Emeltchenko int blocks; 4815b71d385aSAndrei Emeltchenko 4816b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 4817b71d385aSAndrei Emeltchenko skb->len, skb->priority); 4818b71d385aSAndrei Emeltchenko 4819b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 4820b71d385aSAndrei Emeltchenko if (skb->priority < priority) 4821b71d385aSAndrei Emeltchenko break; 4822b71d385aSAndrei Emeltchenko 4823b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 4824b71d385aSAndrei Emeltchenko 4825b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 4826b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 4827b71d385aSAndrei Emeltchenko return; 4828b71d385aSAndrei Emeltchenko 4829b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 4830b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 4831b71d385aSAndrei Emeltchenko 483257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4833b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 4834b71d385aSAndrei Emeltchenko 4835b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 4836b71d385aSAndrei Emeltchenko quote -= blocks; 4837b71d385aSAndrei Emeltchenko 4838b71d385aSAndrei Emeltchenko chan->sent += blocks; 4839b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 4840b71d385aSAndrei Emeltchenko } 4841b71d385aSAndrei Emeltchenko } 4842b71d385aSAndrei Emeltchenko 4843b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 4844bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 4845b71d385aSAndrei Emeltchenko } 4846b71d385aSAndrei Emeltchenko 48476039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 4848b71d385aSAndrei Emeltchenko { 4849b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4850b71d385aSAndrei Emeltchenko 4851bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 4852bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 4853bd1eb66bSAndrei Emeltchenko return; 4854bd1eb66bSAndrei Emeltchenko 4855bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 4856bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 4857b71d385aSAndrei Emeltchenko return; 4858b71d385aSAndrei Emeltchenko 4859b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 4860b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 4861b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 4862b71d385aSAndrei Emeltchenko break; 4863b71d385aSAndrei Emeltchenko 4864b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 4865b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 4866b71d385aSAndrei Emeltchenko break; 4867b71d385aSAndrei Emeltchenko } 4868b71d385aSAndrei Emeltchenko } 4869b71d385aSAndrei Emeltchenko 48701da177e4SLinus Torvalds /* Schedule SCO */ 48716039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 48721da177e4SLinus Torvalds { 48731da177e4SLinus Torvalds struct hci_conn *conn; 48741da177e4SLinus Torvalds struct sk_buff *skb; 48751da177e4SLinus Torvalds int quote; 48761da177e4SLinus Torvalds 48771da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 48781da177e4SLinus Torvalds 487952087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 488052087a79SLuiz Augusto von Dentz return; 488152087a79SLuiz Augusto von Dentz 48821da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 48831da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 48841da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 488557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 48861da177e4SLinus Torvalds 48871da177e4SLinus Torvalds conn->sent++; 48881da177e4SLinus Torvalds if (conn->sent == ~0) 48891da177e4SLinus Torvalds conn->sent = 0; 48901da177e4SLinus Torvalds } 48911da177e4SLinus Torvalds } 48921da177e4SLinus Torvalds } 48931da177e4SLinus Torvalds 48946039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 4895b6a0dc82SMarcel Holtmann { 4896b6a0dc82SMarcel Holtmann struct hci_conn *conn; 4897b6a0dc82SMarcel Holtmann struct sk_buff *skb; 4898b6a0dc82SMarcel Holtmann int quote; 4899b6a0dc82SMarcel Holtmann 4900b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 4901b6a0dc82SMarcel Holtmann 490252087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 490352087a79SLuiz Augusto von Dentz return; 490452087a79SLuiz Augusto von Dentz 49058fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 49068fc9ced3SGustavo Padovan "e))) { 4907b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 4908b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 490957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4910b6a0dc82SMarcel Holtmann 4911b6a0dc82SMarcel Holtmann conn->sent++; 4912b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 4913b6a0dc82SMarcel Holtmann conn->sent = 0; 4914b6a0dc82SMarcel Holtmann } 4915b6a0dc82SMarcel Holtmann } 4916b6a0dc82SMarcel Holtmann } 4917b6a0dc82SMarcel Holtmann 49186039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 49196ed58ec5SVille Tervo { 492073d80debSLuiz Augusto von Dentz struct hci_chan *chan; 49216ed58ec5SVille Tervo struct sk_buff *skb; 492202b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 49236ed58ec5SVille Tervo 49246ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 49256ed58ec5SVille Tervo 492652087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 492752087a79SLuiz Augusto von Dentz return; 492852087a79SLuiz Augusto von Dentz 4929fee746b0SMarcel Holtmann if (!test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) { 49306ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 49316ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 4932bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 49336ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 4934bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 49356ed58ec5SVille Tervo } 49366ed58ec5SVille Tervo 49376ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 493802b20f0bSLuiz Augusto von Dentz tmp = cnt; 493973d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 4940ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4941ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 494273d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 494373d80debSLuiz Augusto von Dentz skb->len, skb->priority); 49446ed58ec5SVille Tervo 4945ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4946ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4947ec1cce24SLuiz Augusto von Dentz break; 4948ec1cce24SLuiz Augusto von Dentz 4949ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4950ec1cce24SLuiz Augusto von Dentz 495157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 49526ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 49536ed58ec5SVille Tervo 49546ed58ec5SVille Tervo cnt--; 495573d80debSLuiz Augusto von Dentz chan->sent++; 495673d80debSLuiz Augusto von Dentz chan->conn->sent++; 49576ed58ec5SVille Tervo } 49586ed58ec5SVille Tervo } 495973d80debSLuiz Augusto von Dentz 49606ed58ec5SVille Tervo if (hdev->le_pkts) 49616ed58ec5SVille Tervo hdev->le_cnt = cnt; 49626ed58ec5SVille Tervo else 49636ed58ec5SVille Tervo hdev->acl_cnt = cnt; 496402b20f0bSLuiz Augusto von Dentz 496502b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 496602b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 49676ed58ec5SVille Tervo } 49686ed58ec5SVille Tervo 49693eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 49701da177e4SLinus Torvalds { 49713eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 49721da177e4SLinus Torvalds struct sk_buff *skb; 49731da177e4SLinus Torvalds 49746ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 49756ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 49761da177e4SLinus Torvalds 497752de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 49781da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 49791da177e4SLinus Torvalds hci_sched_acl(hdev); 49801da177e4SLinus Torvalds hci_sched_sco(hdev); 4981b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 49826ed58ec5SVille Tervo hci_sched_le(hdev); 498352de599eSMarcel Holtmann } 49846ed58ec5SVille Tervo 49851da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 49861da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 498757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 49881da177e4SLinus Torvalds } 49891da177e4SLinus Torvalds 499025985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 49911da177e4SLinus Torvalds 49921da177e4SLinus Torvalds /* ACL data packet */ 49936039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 49941da177e4SLinus Torvalds { 49951da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 49961da177e4SLinus Torvalds struct hci_conn *conn; 49971da177e4SLinus Torvalds __u16 handle, flags; 49981da177e4SLinus Torvalds 49991da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 50001da177e4SLinus Torvalds 50011da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 50021da177e4SLinus Torvalds flags = hci_flags(handle); 50031da177e4SLinus Torvalds handle = hci_handle(handle); 50041da177e4SLinus Torvalds 5005f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 5006a8c5fb1aSGustavo Padovan handle, flags); 50071da177e4SLinus Torvalds 50081da177e4SLinus Torvalds hdev->stat.acl_rx++; 50091da177e4SLinus Torvalds 50101da177e4SLinus Torvalds hci_dev_lock(hdev); 50111da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 50121da177e4SLinus Torvalds hci_dev_unlock(hdev); 50131da177e4SLinus Torvalds 50141da177e4SLinus Torvalds if (conn) { 501565983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 501604837f64SMarcel Holtmann 50171da177e4SLinus Torvalds /* Send to upper protocol */ 5018686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 50191da177e4SLinus Torvalds return; 50201da177e4SLinus Torvalds } else { 50211da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 50221da177e4SLinus Torvalds hdev->name, handle); 50231da177e4SLinus Torvalds } 50241da177e4SLinus Torvalds 50251da177e4SLinus Torvalds kfree_skb(skb); 50261da177e4SLinus Torvalds } 50271da177e4SLinus Torvalds 50281da177e4SLinus Torvalds /* SCO data packet */ 50296039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 50301da177e4SLinus Torvalds { 50311da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 50321da177e4SLinus Torvalds struct hci_conn *conn; 50331da177e4SLinus Torvalds __u16 handle; 50341da177e4SLinus Torvalds 50351da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 50361da177e4SLinus Torvalds 50371da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 50381da177e4SLinus Torvalds 5039f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 50401da177e4SLinus Torvalds 50411da177e4SLinus Torvalds hdev->stat.sco_rx++; 50421da177e4SLinus Torvalds 50431da177e4SLinus Torvalds hci_dev_lock(hdev); 50441da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 50451da177e4SLinus Torvalds hci_dev_unlock(hdev); 50461da177e4SLinus Torvalds 50471da177e4SLinus Torvalds if (conn) { 50481da177e4SLinus Torvalds /* Send to upper protocol */ 5049686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 50501da177e4SLinus Torvalds return; 50511da177e4SLinus Torvalds } else { 50521da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 50531da177e4SLinus Torvalds hdev->name, handle); 50541da177e4SLinus Torvalds } 50551da177e4SLinus Torvalds 50561da177e4SLinus Torvalds kfree_skb(skb); 50571da177e4SLinus Torvalds } 50581da177e4SLinus Torvalds 50599238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 50609238f36aSJohan Hedberg { 50619238f36aSJohan Hedberg struct sk_buff *skb; 50629238f36aSJohan Hedberg 50639238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 50649238f36aSJohan Hedberg if (!skb) 50659238f36aSJohan Hedberg return true; 50669238f36aSJohan Hedberg 50679238f36aSJohan Hedberg return bt_cb(skb)->req.start; 50689238f36aSJohan Hedberg } 50699238f36aSJohan Hedberg 507042c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 507142c6b129SJohan Hedberg { 507242c6b129SJohan Hedberg struct hci_command_hdr *sent; 507342c6b129SJohan Hedberg struct sk_buff *skb; 507442c6b129SJohan Hedberg u16 opcode; 507542c6b129SJohan Hedberg 507642c6b129SJohan Hedberg if (!hdev->sent_cmd) 507742c6b129SJohan Hedberg return; 507842c6b129SJohan Hedberg 507942c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 508042c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 508142c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 508242c6b129SJohan Hedberg return; 508342c6b129SJohan Hedberg 508442c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 508542c6b129SJohan Hedberg if (!skb) 508642c6b129SJohan Hedberg return; 508742c6b129SJohan Hedberg 508842c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 508942c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 509042c6b129SJohan Hedberg } 509142c6b129SJohan Hedberg 50929238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 50939238f36aSJohan Hedberg { 50949238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 50959238f36aSJohan Hedberg struct sk_buff *skb; 50969238f36aSJohan Hedberg unsigned long flags; 50979238f36aSJohan Hedberg 50989238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 50999238f36aSJohan Hedberg 510042c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 510142c6b129SJohan Hedberg * sent we need to do special handling of it. 51029238f36aSJohan Hedberg */ 510342c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 510442c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 510542c6b129SJohan Hedberg * reset complete event during init and any pending 510642c6b129SJohan Hedberg * command will never be completed. In such a case we 510742c6b129SJohan Hedberg * need to resend whatever was the last sent 510842c6b129SJohan Hedberg * command. 510942c6b129SJohan Hedberg */ 511042c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 511142c6b129SJohan Hedberg hci_resend_last(hdev); 511242c6b129SJohan Hedberg 51139238f36aSJohan Hedberg return; 511442c6b129SJohan Hedberg } 51159238f36aSJohan Hedberg 51169238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 51179238f36aSJohan Hedberg * this request the request is not yet complete. 51189238f36aSJohan Hedberg */ 51199238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 51209238f36aSJohan Hedberg return; 51219238f36aSJohan Hedberg 51229238f36aSJohan Hedberg /* If this was the last command in a request the complete 51239238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 51249238f36aSJohan Hedberg * command queue (hdev->cmd_q). 51259238f36aSJohan Hedberg */ 51269238f36aSJohan Hedberg if (hdev->sent_cmd) { 51279238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 512853e21fbcSJohan Hedberg 512953e21fbcSJohan Hedberg if (req_complete) { 513053e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 513153e21fbcSJohan Hedberg * avoid calling the callback more than once if 513253e21fbcSJohan Hedberg * this function gets called again. 513353e21fbcSJohan Hedberg */ 513453e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 513553e21fbcSJohan Hedberg 51369238f36aSJohan Hedberg goto call_complete; 51379238f36aSJohan Hedberg } 513853e21fbcSJohan Hedberg } 51399238f36aSJohan Hedberg 51409238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 51419238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 51429238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 51439238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 51449238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 51459238f36aSJohan Hedberg break; 51469238f36aSJohan Hedberg } 51479238f36aSJohan Hedberg 51489238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 51499238f36aSJohan Hedberg kfree_skb(skb); 51509238f36aSJohan Hedberg } 51519238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 51529238f36aSJohan Hedberg 51539238f36aSJohan Hedberg call_complete: 51549238f36aSJohan Hedberg if (req_complete) 51559238f36aSJohan Hedberg req_complete(hdev, status); 51569238f36aSJohan Hedberg } 51579238f36aSJohan Hedberg 5158b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 51591da177e4SLinus Torvalds { 5160b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 51611da177e4SLinus Torvalds struct sk_buff *skb; 51621da177e4SLinus Torvalds 51631da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 51641da177e4SLinus Torvalds 51651da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 5166cd82e61cSMarcel Holtmann /* Send copy to monitor */ 5167cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 5168cd82e61cSMarcel Holtmann 51691da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 51701da177e4SLinus Torvalds /* Send copy to the sockets */ 5171470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 51721da177e4SLinus Torvalds } 51731da177e4SLinus Torvalds 5174fee746b0SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 51751da177e4SLinus Torvalds kfree_skb(skb); 51761da177e4SLinus Torvalds continue; 51771da177e4SLinus Torvalds } 51781da177e4SLinus Torvalds 51791da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 51801da177e4SLinus Torvalds /* Don't process data packets in this states. */ 51810d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 51821da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 51831da177e4SLinus Torvalds case HCI_SCODATA_PKT: 51841da177e4SLinus Torvalds kfree_skb(skb); 51851da177e4SLinus Torvalds continue; 51863ff50b79SStephen Hemminger } 51871da177e4SLinus Torvalds } 51881da177e4SLinus Torvalds 51891da177e4SLinus Torvalds /* Process frame */ 51900d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 51911da177e4SLinus Torvalds case HCI_EVENT_PKT: 5192b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 51931da177e4SLinus Torvalds hci_event_packet(hdev, skb); 51941da177e4SLinus Torvalds break; 51951da177e4SLinus Torvalds 51961da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 51971da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 51981da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 51991da177e4SLinus Torvalds break; 52001da177e4SLinus Torvalds 52011da177e4SLinus Torvalds case HCI_SCODATA_PKT: 52021da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 52031da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 52041da177e4SLinus Torvalds break; 52051da177e4SLinus Torvalds 52061da177e4SLinus Torvalds default: 52071da177e4SLinus Torvalds kfree_skb(skb); 52081da177e4SLinus Torvalds break; 52091da177e4SLinus Torvalds } 52101da177e4SLinus Torvalds } 52111da177e4SLinus Torvalds } 52121da177e4SLinus Torvalds 5213c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 52141da177e4SLinus Torvalds { 5215c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 52161da177e4SLinus Torvalds struct sk_buff *skb; 52171da177e4SLinus Torvalds 52182104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 52192104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 52201da177e4SLinus Torvalds 52211da177e4SLinus Torvalds /* Send queued commands */ 52225a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 52235a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 52245a08ecceSAndrei Emeltchenko if (!skb) 52255a08ecceSAndrei Emeltchenko return; 52265a08ecceSAndrei Emeltchenko 52271da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 52281da177e4SLinus Torvalds 5229a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 523070f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 52311da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 523257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 52337bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 523465cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 52357bdb8a5cSSzymon Janc else 523665cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 523765cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 52381da177e4SLinus Torvalds } else { 52391da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 5240c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 52411da177e4SLinus Torvalds } 52421da177e4SLinus Torvalds } 52431da177e4SLinus Torvalds } 5244b1efcc28SAndre Guedes 5245b1efcc28SAndre Guedes void hci_req_add_le_scan_disable(struct hci_request *req) 5246b1efcc28SAndre Guedes { 5247b1efcc28SAndre Guedes struct hci_cp_le_set_scan_enable cp; 5248b1efcc28SAndre Guedes 5249b1efcc28SAndre Guedes memset(&cp, 0, sizeof(cp)); 5250b1efcc28SAndre Guedes cp.enable = LE_SCAN_DISABLE; 5251b1efcc28SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 5252b1efcc28SAndre Guedes } 5253a4790dbdSAndre Guedes 52548ef30fd3SAndre Guedes void hci_req_add_le_passive_scan(struct hci_request *req) 52558ef30fd3SAndre Guedes { 52568ef30fd3SAndre Guedes struct hci_cp_le_set_scan_param param_cp; 52578ef30fd3SAndre Guedes struct hci_cp_le_set_scan_enable enable_cp; 52588ef30fd3SAndre Guedes struct hci_dev *hdev = req->hdev; 52598ef30fd3SAndre Guedes u8 own_addr_type; 52608ef30fd3SAndre Guedes 52616ab535a7SMarcel Holtmann /* Set require_privacy to false since no SCAN_REQ are send 52626ab535a7SMarcel Holtmann * during passive scanning. Not using an unresolvable address 52636ab535a7SMarcel Holtmann * here is important so that peer devices using direct 52646ab535a7SMarcel Holtmann * advertising with our address will be correctly reported 52656ab535a7SMarcel Holtmann * by the controller. 52668ef30fd3SAndre Guedes */ 52676ab535a7SMarcel Holtmann if (hci_update_random_address(req, false, &own_addr_type)) 52688ef30fd3SAndre Guedes return; 52698ef30fd3SAndre Guedes 52708ef30fd3SAndre Guedes memset(¶m_cp, 0, sizeof(param_cp)); 52718ef30fd3SAndre Guedes param_cp.type = LE_SCAN_PASSIVE; 52728ef30fd3SAndre Guedes param_cp.interval = cpu_to_le16(hdev->le_scan_interval); 52738ef30fd3SAndre Guedes param_cp.window = cpu_to_le16(hdev->le_scan_window); 52748ef30fd3SAndre Guedes param_cp.own_address_type = own_addr_type; 52758ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_PARAM, sizeof(param_cp), 52768ef30fd3SAndre Guedes ¶m_cp); 52778ef30fd3SAndre Guedes 52788ef30fd3SAndre Guedes memset(&enable_cp, 0, sizeof(enable_cp)); 52798ef30fd3SAndre Guedes enable_cp.enable = LE_SCAN_ENABLE; 52804340a124SAndre Guedes enable_cp.filter_dup = LE_SCAN_FILTER_DUP_ENABLE; 52818ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(enable_cp), 52828ef30fd3SAndre Guedes &enable_cp); 52838ef30fd3SAndre Guedes } 52848ef30fd3SAndre Guedes 5285a4790dbdSAndre Guedes static void update_background_scan_complete(struct hci_dev *hdev, u8 status) 5286a4790dbdSAndre Guedes { 5287a4790dbdSAndre Guedes if (status) 5288a4790dbdSAndre Guedes BT_DBG("HCI request failed to update background scanning: " 5289a4790dbdSAndre Guedes "status 0x%2.2x", status); 5290a4790dbdSAndre Guedes } 5291a4790dbdSAndre Guedes 5292a4790dbdSAndre Guedes /* This function controls the background scanning based on hdev->pend_le_conns 5293a4790dbdSAndre Guedes * list. If there are pending LE connection we start the background scanning, 5294a4790dbdSAndre Guedes * otherwise we stop it. 5295a4790dbdSAndre Guedes * 5296a4790dbdSAndre Guedes * This function requires the caller holds hdev->lock. 5297a4790dbdSAndre Guedes */ 5298a4790dbdSAndre Guedes void hci_update_background_scan(struct hci_dev *hdev) 5299a4790dbdSAndre Guedes { 5300a4790dbdSAndre Guedes struct hci_request req; 5301a4790dbdSAndre Guedes struct hci_conn *conn; 5302a4790dbdSAndre Guedes int err; 5303a4790dbdSAndre Guedes 5304c20c02d5SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags) || 5305c20c02d5SMarcel Holtmann test_bit(HCI_INIT, &hdev->flags) || 5306c20c02d5SMarcel Holtmann test_bit(HCI_SETUP, &hdev->dev_flags) || 5307c20c02d5SMarcel Holtmann test_bit(HCI_UNREGISTER, &hdev->dev_flags)) 53081c1697c0SMarcel Holtmann return; 53091c1697c0SMarcel Holtmann 5310a4790dbdSAndre Guedes hci_req_init(&req, hdev); 5311a4790dbdSAndre Guedes 5312a4790dbdSAndre Guedes if (list_empty(&hdev->pend_le_conns)) { 5313a4790dbdSAndre Guedes /* If there is no pending LE connections, we should stop 5314a4790dbdSAndre Guedes * the background scanning. 5315a4790dbdSAndre Guedes */ 5316a4790dbdSAndre Guedes 5317a4790dbdSAndre Guedes /* If controller is not scanning we are done. */ 5318a4790dbdSAndre Guedes if (!test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 5319a4790dbdSAndre Guedes return; 5320a4790dbdSAndre Guedes 5321a4790dbdSAndre Guedes hci_req_add_le_scan_disable(&req); 5322a4790dbdSAndre Guedes 5323a4790dbdSAndre Guedes BT_DBG("%s stopping background scanning", hdev->name); 5324a4790dbdSAndre Guedes } else { 5325a4790dbdSAndre Guedes /* If there is at least one pending LE connection, we should 5326a4790dbdSAndre Guedes * keep the background scan running. 5327a4790dbdSAndre Guedes */ 5328a4790dbdSAndre Guedes 5329a4790dbdSAndre Guedes /* If controller is connecting, we should not start scanning 5330a4790dbdSAndre Guedes * since some controllers are not able to scan and connect at 5331a4790dbdSAndre Guedes * the same time. 5332a4790dbdSAndre Guedes */ 5333a4790dbdSAndre Guedes conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT); 5334a4790dbdSAndre Guedes if (conn) 5335a4790dbdSAndre Guedes return; 5336a4790dbdSAndre Guedes 53374340a124SAndre Guedes /* If controller is currently scanning, we stop it to ensure we 53384340a124SAndre Guedes * don't miss any advertising (due to duplicates filter). 53394340a124SAndre Guedes */ 53404340a124SAndre Guedes if (test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 53414340a124SAndre Guedes hci_req_add_le_scan_disable(&req); 53424340a124SAndre Guedes 53438ef30fd3SAndre Guedes hci_req_add_le_passive_scan(&req); 5344a4790dbdSAndre Guedes 5345a4790dbdSAndre Guedes BT_DBG("%s starting background scanning", hdev->name); 5346a4790dbdSAndre Guedes } 5347a4790dbdSAndre Guedes 5348a4790dbdSAndre Guedes err = hci_req_run(&req, update_background_scan_complete); 5349a4790dbdSAndre Guedes if (err) 5350a4790dbdSAndre Guedes BT_ERR("Failed to run HCI request: err %d", err); 5351a4790dbdSAndre Guedes } 5352