11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds BlueZ - Bluetooth protocol stack for Linux 31da177e4SLinus Torvalds Copyright (C) 2000-2001 Qualcomm Incorporated 4590051deSGustavo F. Padovan Copyright (C) 2011 ProFUSION Embedded Systems 51da177e4SLinus Torvalds 61da177e4SLinus Torvalds Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 71da177e4SLinus Torvalds 81da177e4SLinus Torvalds This program is free software; you can redistribute it and/or modify 91da177e4SLinus Torvalds it under the terms of the GNU General Public License version 2 as 101da177e4SLinus Torvalds published by the Free Software Foundation; 111da177e4SLinus Torvalds 121da177e4SLinus Torvalds THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 131da177e4SLinus Torvalds OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 141da177e4SLinus Torvalds FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 151da177e4SLinus Torvalds IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 161da177e4SLinus Torvalds CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 171da177e4SLinus Torvalds WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 181da177e4SLinus Torvalds ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 191da177e4SLinus Torvalds OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 221da177e4SLinus Torvalds COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 231da177e4SLinus Torvalds SOFTWARE IS DISCLAIMED. 241da177e4SLinus Torvalds */ 251da177e4SLinus Torvalds 261da177e4SLinus Torvalds /* Bluetooth HCI core. */ 271da177e4SLinus Torvalds 288c520a59SGustavo Padovan #include <linux/export.h> 293df92b31SSasha Levin #include <linux/idr.h> 30611b30f7SMarcel Holtmann #include <linux/rfkill.h> 31baf27f6eSMarcel Holtmann #include <linux/debugfs.h> 3299780a7bSJohan Hedberg #include <linux/crypto.h> 3347219839SMarcel Holtmann #include <asm/unaligned.h> 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 361da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 374bc58f51SJohan Hedberg #include <net/bluetooth/l2cap.h> 38af58925cSMarcel Holtmann #include <net/bluetooth/mgmt.h> 391da177e4SLinus Torvalds 40970c4e46SJohan Hedberg #include "smp.h" 41970c4e46SJohan Hedberg 42b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work); 43c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work); 443eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work); 451da177e4SLinus Torvalds 461da177e4SLinus Torvalds /* HCI device list */ 471da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 481da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 491da177e4SLinus Torvalds 501da177e4SLinus Torvalds /* HCI callback list */ 511da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 521da177e4SLinus Torvalds DEFINE_RWLOCK(hci_cb_list_lock); 531da177e4SLinus Torvalds 543df92b31SSasha Levin /* HCI ID Numbering */ 553df92b31SSasha Levin static DEFINE_IDA(hci_index_ida); 563df92b31SSasha Levin 57899de765SMarcel Holtmann /* ----- HCI requests ----- */ 58899de765SMarcel Holtmann 59899de765SMarcel Holtmann #define HCI_REQ_DONE 0 60899de765SMarcel Holtmann #define HCI_REQ_PEND 1 61899de765SMarcel Holtmann #define HCI_REQ_CANCELED 2 62899de765SMarcel Holtmann 63899de765SMarcel Holtmann #define hci_req_lock(d) mutex_lock(&d->req_lock) 64899de765SMarcel Holtmann #define hci_req_unlock(d) mutex_unlock(&d->req_lock) 65899de765SMarcel Holtmann 661da177e4SLinus Torvalds /* ---- HCI notifications ---- */ 671da177e4SLinus Torvalds 686516455dSMarcel Holtmann static void hci_notify(struct hci_dev *hdev, int event) 691da177e4SLinus Torvalds { 70040030efSMarcel Holtmann hci_sock_dev_event(hdev, event); 711da177e4SLinus Torvalds } 721da177e4SLinus Torvalds 73baf27f6eSMarcel Holtmann /* ---- HCI debugfs entries ---- */ 74baf27f6eSMarcel Holtmann 754b4148e9SMarcel Holtmann static ssize_t dut_mode_read(struct file *file, char __user *user_buf, 764b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 774b4148e9SMarcel Holtmann { 784b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 794b4148e9SMarcel Holtmann char buf[3]; 804b4148e9SMarcel Holtmann 81111902f7SMarcel Holtmann buf[0] = test_bit(HCI_DUT_MODE, &hdev->dbg_flags) ? 'Y': 'N'; 824b4148e9SMarcel Holtmann buf[1] = '\n'; 834b4148e9SMarcel Holtmann buf[2] = '\0'; 844b4148e9SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 854b4148e9SMarcel Holtmann } 864b4148e9SMarcel Holtmann 874b4148e9SMarcel Holtmann static ssize_t dut_mode_write(struct file *file, const char __user *user_buf, 884b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 894b4148e9SMarcel Holtmann { 904b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 914b4148e9SMarcel Holtmann struct sk_buff *skb; 924b4148e9SMarcel Holtmann char buf[32]; 934b4148e9SMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 944b4148e9SMarcel Holtmann bool enable; 954b4148e9SMarcel Holtmann int err; 964b4148e9SMarcel Holtmann 974b4148e9SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 984b4148e9SMarcel Holtmann return -ENETDOWN; 994b4148e9SMarcel Holtmann 1004b4148e9SMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 1014b4148e9SMarcel Holtmann return -EFAULT; 1024b4148e9SMarcel Holtmann 1034b4148e9SMarcel Holtmann buf[buf_size] = '\0'; 1044b4148e9SMarcel Holtmann if (strtobool(buf, &enable)) 1054b4148e9SMarcel Holtmann return -EINVAL; 1064b4148e9SMarcel Holtmann 107111902f7SMarcel Holtmann if (enable == test_bit(HCI_DUT_MODE, &hdev->dbg_flags)) 1084b4148e9SMarcel Holtmann return -EALREADY; 1094b4148e9SMarcel Holtmann 1104b4148e9SMarcel Holtmann hci_req_lock(hdev); 1114b4148e9SMarcel Holtmann if (enable) 1124b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_ENABLE_DUT_MODE, 0, NULL, 1134b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 1144b4148e9SMarcel Holtmann else 1154b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, 1164b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 1174b4148e9SMarcel Holtmann hci_req_unlock(hdev); 1184b4148e9SMarcel Holtmann 1194b4148e9SMarcel Holtmann if (IS_ERR(skb)) 1204b4148e9SMarcel Holtmann return PTR_ERR(skb); 1214b4148e9SMarcel Holtmann 1224b4148e9SMarcel Holtmann err = -bt_to_errno(skb->data[0]); 1234b4148e9SMarcel Holtmann kfree_skb(skb); 1244b4148e9SMarcel Holtmann 1254b4148e9SMarcel Holtmann if (err < 0) 1264b4148e9SMarcel Holtmann return err; 1274b4148e9SMarcel Holtmann 128111902f7SMarcel Holtmann change_bit(HCI_DUT_MODE, &hdev->dbg_flags); 1294b4148e9SMarcel Holtmann 1304b4148e9SMarcel Holtmann return count; 1314b4148e9SMarcel Holtmann } 1324b4148e9SMarcel Holtmann 1334b4148e9SMarcel Holtmann static const struct file_operations dut_mode_fops = { 1344b4148e9SMarcel Holtmann .open = simple_open, 1354b4148e9SMarcel Holtmann .read = dut_mode_read, 1364b4148e9SMarcel Holtmann .write = dut_mode_write, 1374b4148e9SMarcel Holtmann .llseek = default_llseek, 1384b4148e9SMarcel Holtmann }; 1394b4148e9SMarcel Holtmann 140dfb826a8SMarcel Holtmann static int features_show(struct seq_file *f, void *ptr) 141dfb826a8SMarcel Holtmann { 142dfb826a8SMarcel Holtmann struct hci_dev *hdev = f->private; 143dfb826a8SMarcel Holtmann u8 p; 144dfb826a8SMarcel Holtmann 145dfb826a8SMarcel Holtmann hci_dev_lock(hdev); 146dfb826a8SMarcel Holtmann for (p = 0; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 147cfbb2b5bSMarcel Holtmann seq_printf(f, "%2u: 0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x " 148dfb826a8SMarcel Holtmann "0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x\n", p, 149dfb826a8SMarcel Holtmann hdev->features[p][0], hdev->features[p][1], 150dfb826a8SMarcel Holtmann hdev->features[p][2], hdev->features[p][3], 151dfb826a8SMarcel Holtmann hdev->features[p][4], hdev->features[p][5], 152dfb826a8SMarcel Holtmann hdev->features[p][6], hdev->features[p][7]); 153dfb826a8SMarcel Holtmann } 154cfbb2b5bSMarcel Holtmann if (lmp_le_capable(hdev)) 155cfbb2b5bSMarcel Holtmann seq_printf(f, "LE: 0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x " 156cfbb2b5bSMarcel Holtmann "0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x\n", 157cfbb2b5bSMarcel Holtmann hdev->le_features[0], hdev->le_features[1], 158cfbb2b5bSMarcel Holtmann hdev->le_features[2], hdev->le_features[3], 159cfbb2b5bSMarcel Holtmann hdev->le_features[4], hdev->le_features[5], 160cfbb2b5bSMarcel Holtmann hdev->le_features[6], hdev->le_features[7]); 161dfb826a8SMarcel Holtmann hci_dev_unlock(hdev); 162dfb826a8SMarcel Holtmann 163dfb826a8SMarcel Holtmann return 0; 164dfb826a8SMarcel Holtmann } 165dfb826a8SMarcel Holtmann 166dfb826a8SMarcel Holtmann static int features_open(struct inode *inode, struct file *file) 167dfb826a8SMarcel Holtmann { 168dfb826a8SMarcel Holtmann return single_open(file, features_show, inode->i_private); 169dfb826a8SMarcel Holtmann } 170dfb826a8SMarcel Holtmann 171dfb826a8SMarcel Holtmann static const struct file_operations features_fops = { 172dfb826a8SMarcel Holtmann .open = features_open, 173dfb826a8SMarcel Holtmann .read = seq_read, 174dfb826a8SMarcel Holtmann .llseek = seq_lseek, 175dfb826a8SMarcel Holtmann .release = single_release, 176dfb826a8SMarcel Holtmann }; 177dfb826a8SMarcel Holtmann 17870afe0b8SMarcel Holtmann static int blacklist_show(struct seq_file *f, void *p) 17970afe0b8SMarcel Holtmann { 18070afe0b8SMarcel Holtmann struct hci_dev *hdev = f->private; 18170afe0b8SMarcel Holtmann struct bdaddr_list *b; 18270afe0b8SMarcel Holtmann 18370afe0b8SMarcel Holtmann hci_dev_lock(hdev); 18470afe0b8SMarcel Holtmann list_for_each_entry(b, &hdev->blacklist, list) 185b25f0785SMarcel Holtmann seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 18670afe0b8SMarcel Holtmann hci_dev_unlock(hdev); 18770afe0b8SMarcel Holtmann 18870afe0b8SMarcel Holtmann return 0; 18970afe0b8SMarcel Holtmann } 19070afe0b8SMarcel Holtmann 19170afe0b8SMarcel Holtmann static int blacklist_open(struct inode *inode, struct file *file) 19270afe0b8SMarcel Holtmann { 19370afe0b8SMarcel Holtmann return single_open(file, blacklist_show, inode->i_private); 19470afe0b8SMarcel Holtmann } 19570afe0b8SMarcel Holtmann 19670afe0b8SMarcel Holtmann static const struct file_operations blacklist_fops = { 19770afe0b8SMarcel Holtmann .open = blacklist_open, 19870afe0b8SMarcel Holtmann .read = seq_read, 19970afe0b8SMarcel Holtmann .llseek = seq_lseek, 20070afe0b8SMarcel Holtmann .release = single_release, 20170afe0b8SMarcel Holtmann }; 20270afe0b8SMarcel Holtmann 20347219839SMarcel Holtmann static int uuids_show(struct seq_file *f, void *p) 20447219839SMarcel Holtmann { 20547219839SMarcel Holtmann struct hci_dev *hdev = f->private; 20647219839SMarcel Holtmann struct bt_uuid *uuid; 20747219839SMarcel Holtmann 20847219839SMarcel Holtmann hci_dev_lock(hdev); 20947219839SMarcel Holtmann list_for_each_entry(uuid, &hdev->uuids, list) { 21058f01aa9SMarcel Holtmann u8 i, val[16]; 21147219839SMarcel Holtmann 21258f01aa9SMarcel Holtmann /* The Bluetooth UUID values are stored in big endian, 21358f01aa9SMarcel Holtmann * but with reversed byte order. So convert them into 21458f01aa9SMarcel Holtmann * the right order for the %pUb modifier. 21558f01aa9SMarcel Holtmann */ 21658f01aa9SMarcel Holtmann for (i = 0; i < 16; i++) 21758f01aa9SMarcel Holtmann val[i] = uuid->uuid[15 - i]; 21847219839SMarcel Holtmann 21958f01aa9SMarcel Holtmann seq_printf(f, "%pUb\n", val); 22047219839SMarcel Holtmann } 22147219839SMarcel Holtmann hci_dev_unlock(hdev); 22247219839SMarcel Holtmann 22347219839SMarcel Holtmann return 0; 22447219839SMarcel Holtmann } 22547219839SMarcel Holtmann 22647219839SMarcel Holtmann static int uuids_open(struct inode *inode, struct file *file) 22747219839SMarcel Holtmann { 22847219839SMarcel Holtmann return single_open(file, uuids_show, inode->i_private); 22947219839SMarcel Holtmann } 23047219839SMarcel Holtmann 23147219839SMarcel Holtmann static const struct file_operations uuids_fops = { 23247219839SMarcel Holtmann .open = uuids_open, 23347219839SMarcel Holtmann .read = seq_read, 23447219839SMarcel Holtmann .llseek = seq_lseek, 23547219839SMarcel Holtmann .release = single_release, 23647219839SMarcel Holtmann }; 23747219839SMarcel Holtmann 238baf27f6eSMarcel Holtmann static int inquiry_cache_show(struct seq_file *f, void *p) 239baf27f6eSMarcel Holtmann { 240baf27f6eSMarcel Holtmann struct hci_dev *hdev = f->private; 241baf27f6eSMarcel Holtmann struct discovery_state *cache = &hdev->discovery; 242baf27f6eSMarcel Holtmann struct inquiry_entry *e; 243baf27f6eSMarcel Holtmann 244baf27f6eSMarcel Holtmann hci_dev_lock(hdev); 245baf27f6eSMarcel Holtmann 246baf27f6eSMarcel Holtmann list_for_each_entry(e, &cache->all, all) { 247baf27f6eSMarcel Holtmann struct inquiry_data *data = &e->data; 248baf27f6eSMarcel Holtmann seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n", 249baf27f6eSMarcel Holtmann &data->bdaddr, 250baf27f6eSMarcel Holtmann data->pscan_rep_mode, data->pscan_period_mode, 251baf27f6eSMarcel Holtmann data->pscan_mode, data->dev_class[2], 252baf27f6eSMarcel Holtmann data->dev_class[1], data->dev_class[0], 253baf27f6eSMarcel Holtmann __le16_to_cpu(data->clock_offset), 254baf27f6eSMarcel Holtmann data->rssi, data->ssp_mode, e->timestamp); 255baf27f6eSMarcel Holtmann } 256baf27f6eSMarcel Holtmann 257baf27f6eSMarcel Holtmann hci_dev_unlock(hdev); 258baf27f6eSMarcel Holtmann 259baf27f6eSMarcel Holtmann return 0; 260baf27f6eSMarcel Holtmann } 261baf27f6eSMarcel Holtmann 262baf27f6eSMarcel Holtmann static int inquiry_cache_open(struct inode *inode, struct file *file) 263baf27f6eSMarcel Holtmann { 264baf27f6eSMarcel Holtmann return single_open(file, inquiry_cache_show, inode->i_private); 265baf27f6eSMarcel Holtmann } 266baf27f6eSMarcel Holtmann 267baf27f6eSMarcel Holtmann static const struct file_operations inquiry_cache_fops = { 268baf27f6eSMarcel Holtmann .open = inquiry_cache_open, 269baf27f6eSMarcel Holtmann .read = seq_read, 270baf27f6eSMarcel Holtmann .llseek = seq_lseek, 271baf27f6eSMarcel Holtmann .release = single_release, 272baf27f6eSMarcel Holtmann }; 273baf27f6eSMarcel Holtmann 27402d08d15SMarcel Holtmann static int link_keys_show(struct seq_file *f, void *ptr) 27502d08d15SMarcel Holtmann { 27602d08d15SMarcel Holtmann struct hci_dev *hdev = f->private; 27702d08d15SMarcel Holtmann struct list_head *p, *n; 27802d08d15SMarcel Holtmann 27902d08d15SMarcel Holtmann hci_dev_lock(hdev); 28002d08d15SMarcel Holtmann list_for_each_safe(p, n, &hdev->link_keys) { 28102d08d15SMarcel Holtmann struct link_key *key = list_entry(p, struct link_key, list); 28202d08d15SMarcel Holtmann seq_printf(f, "%pMR %u %*phN %u\n", &key->bdaddr, key->type, 28302d08d15SMarcel Holtmann HCI_LINK_KEY_SIZE, key->val, key->pin_len); 28402d08d15SMarcel Holtmann } 28502d08d15SMarcel Holtmann hci_dev_unlock(hdev); 28602d08d15SMarcel Holtmann 28702d08d15SMarcel Holtmann return 0; 28802d08d15SMarcel Holtmann } 28902d08d15SMarcel Holtmann 29002d08d15SMarcel Holtmann static int link_keys_open(struct inode *inode, struct file *file) 29102d08d15SMarcel Holtmann { 29202d08d15SMarcel Holtmann return single_open(file, link_keys_show, inode->i_private); 29302d08d15SMarcel Holtmann } 29402d08d15SMarcel Holtmann 29502d08d15SMarcel Holtmann static const struct file_operations link_keys_fops = { 29602d08d15SMarcel Holtmann .open = link_keys_open, 29702d08d15SMarcel Holtmann .read = seq_read, 29802d08d15SMarcel Holtmann .llseek = seq_lseek, 29902d08d15SMarcel Holtmann .release = single_release, 30002d08d15SMarcel Holtmann }; 30102d08d15SMarcel Holtmann 302babdbb3cSMarcel Holtmann static int dev_class_show(struct seq_file *f, void *ptr) 303babdbb3cSMarcel Holtmann { 304babdbb3cSMarcel Holtmann struct hci_dev *hdev = f->private; 305babdbb3cSMarcel Holtmann 306babdbb3cSMarcel Holtmann hci_dev_lock(hdev); 307babdbb3cSMarcel Holtmann seq_printf(f, "0x%.2x%.2x%.2x\n", hdev->dev_class[2], 308babdbb3cSMarcel Holtmann hdev->dev_class[1], hdev->dev_class[0]); 309babdbb3cSMarcel Holtmann hci_dev_unlock(hdev); 310babdbb3cSMarcel Holtmann 311babdbb3cSMarcel Holtmann return 0; 312babdbb3cSMarcel Holtmann } 313babdbb3cSMarcel Holtmann 314babdbb3cSMarcel Holtmann static int dev_class_open(struct inode *inode, struct file *file) 315babdbb3cSMarcel Holtmann { 316babdbb3cSMarcel Holtmann return single_open(file, dev_class_show, inode->i_private); 317babdbb3cSMarcel Holtmann } 318babdbb3cSMarcel Holtmann 319babdbb3cSMarcel Holtmann static const struct file_operations dev_class_fops = { 320babdbb3cSMarcel Holtmann .open = dev_class_open, 321babdbb3cSMarcel Holtmann .read = seq_read, 322babdbb3cSMarcel Holtmann .llseek = seq_lseek, 323babdbb3cSMarcel Holtmann .release = single_release, 324babdbb3cSMarcel Holtmann }; 325babdbb3cSMarcel Holtmann 326041000b9SMarcel Holtmann static int voice_setting_get(void *data, u64 *val) 327041000b9SMarcel Holtmann { 328041000b9SMarcel Holtmann struct hci_dev *hdev = data; 329041000b9SMarcel Holtmann 330041000b9SMarcel Holtmann hci_dev_lock(hdev); 331041000b9SMarcel Holtmann *val = hdev->voice_setting; 332041000b9SMarcel Holtmann hci_dev_unlock(hdev); 333041000b9SMarcel Holtmann 334041000b9SMarcel Holtmann return 0; 335041000b9SMarcel Holtmann } 336041000b9SMarcel Holtmann 337041000b9SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get, 338041000b9SMarcel Holtmann NULL, "0x%4.4llx\n"); 339041000b9SMarcel Holtmann 340ebd1e33bSMarcel Holtmann static int auto_accept_delay_set(void *data, u64 val) 341ebd1e33bSMarcel Holtmann { 342ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 343ebd1e33bSMarcel Holtmann 344ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 345ebd1e33bSMarcel Holtmann hdev->auto_accept_delay = val; 346ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 347ebd1e33bSMarcel Holtmann 348ebd1e33bSMarcel Holtmann return 0; 349ebd1e33bSMarcel Holtmann } 350ebd1e33bSMarcel Holtmann 351ebd1e33bSMarcel Holtmann static int auto_accept_delay_get(void *data, u64 *val) 352ebd1e33bSMarcel Holtmann { 353ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 354ebd1e33bSMarcel Holtmann 355ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 356ebd1e33bSMarcel Holtmann *val = hdev->auto_accept_delay; 357ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 358ebd1e33bSMarcel Holtmann 359ebd1e33bSMarcel Holtmann return 0; 360ebd1e33bSMarcel Holtmann } 361ebd1e33bSMarcel Holtmann 362ebd1e33bSMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get, 363ebd1e33bSMarcel Holtmann auto_accept_delay_set, "%llu\n"); 364ebd1e33bSMarcel Holtmann 3655afeac14SMarcel Holtmann static ssize_t force_sc_support_read(struct file *file, char __user *user_buf, 3665afeac14SMarcel Holtmann size_t count, loff_t *ppos) 3675afeac14SMarcel Holtmann { 3685afeac14SMarcel Holtmann struct hci_dev *hdev = file->private_data; 3695afeac14SMarcel Holtmann char buf[3]; 3705afeac14SMarcel Holtmann 371111902f7SMarcel Holtmann buf[0] = test_bit(HCI_FORCE_SC, &hdev->dbg_flags) ? 'Y': 'N'; 3725afeac14SMarcel Holtmann buf[1] = '\n'; 3735afeac14SMarcel Holtmann buf[2] = '\0'; 3745afeac14SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 3755afeac14SMarcel Holtmann } 3765afeac14SMarcel Holtmann 3775afeac14SMarcel Holtmann static ssize_t force_sc_support_write(struct file *file, 3785afeac14SMarcel Holtmann const char __user *user_buf, 3795afeac14SMarcel Holtmann size_t count, loff_t *ppos) 3805afeac14SMarcel Holtmann { 3815afeac14SMarcel Holtmann struct hci_dev *hdev = file->private_data; 3825afeac14SMarcel Holtmann char buf[32]; 3835afeac14SMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 3845afeac14SMarcel Holtmann bool enable; 3855afeac14SMarcel Holtmann 3865afeac14SMarcel Holtmann if (test_bit(HCI_UP, &hdev->flags)) 3875afeac14SMarcel Holtmann return -EBUSY; 3885afeac14SMarcel Holtmann 3895afeac14SMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 3905afeac14SMarcel Holtmann return -EFAULT; 3915afeac14SMarcel Holtmann 3925afeac14SMarcel Holtmann buf[buf_size] = '\0'; 3935afeac14SMarcel Holtmann if (strtobool(buf, &enable)) 3945afeac14SMarcel Holtmann return -EINVAL; 3955afeac14SMarcel Holtmann 396111902f7SMarcel Holtmann if (enable == test_bit(HCI_FORCE_SC, &hdev->dbg_flags)) 3975afeac14SMarcel Holtmann return -EALREADY; 3985afeac14SMarcel Holtmann 399111902f7SMarcel Holtmann change_bit(HCI_FORCE_SC, &hdev->dbg_flags); 4005afeac14SMarcel Holtmann 4015afeac14SMarcel Holtmann return count; 4025afeac14SMarcel Holtmann } 4035afeac14SMarcel Holtmann 4045afeac14SMarcel Holtmann static const struct file_operations force_sc_support_fops = { 4055afeac14SMarcel Holtmann .open = simple_open, 4065afeac14SMarcel Holtmann .read = force_sc_support_read, 4075afeac14SMarcel Holtmann .write = force_sc_support_write, 4085afeac14SMarcel Holtmann .llseek = default_llseek, 4095afeac14SMarcel Holtmann }; 4105afeac14SMarcel Holtmann 411134c2a89SMarcel Holtmann static ssize_t sc_only_mode_read(struct file *file, char __user *user_buf, 412134c2a89SMarcel Holtmann size_t count, loff_t *ppos) 413134c2a89SMarcel Holtmann { 414134c2a89SMarcel Holtmann struct hci_dev *hdev = file->private_data; 415134c2a89SMarcel Holtmann char buf[3]; 416134c2a89SMarcel Holtmann 417134c2a89SMarcel Holtmann buf[0] = test_bit(HCI_SC_ONLY, &hdev->dev_flags) ? 'Y': 'N'; 418134c2a89SMarcel Holtmann buf[1] = '\n'; 419134c2a89SMarcel Holtmann buf[2] = '\0'; 420134c2a89SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 421134c2a89SMarcel Holtmann } 422134c2a89SMarcel Holtmann 423134c2a89SMarcel Holtmann static const struct file_operations sc_only_mode_fops = { 424134c2a89SMarcel Holtmann .open = simple_open, 425134c2a89SMarcel Holtmann .read = sc_only_mode_read, 426134c2a89SMarcel Holtmann .llseek = default_llseek, 427134c2a89SMarcel Holtmann }; 428134c2a89SMarcel Holtmann 4292bfa3531SMarcel Holtmann static int idle_timeout_set(void *data, u64 val) 4302bfa3531SMarcel Holtmann { 4312bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4322bfa3531SMarcel Holtmann 4332bfa3531SMarcel Holtmann if (val != 0 && (val < 500 || val > 3600000)) 4342bfa3531SMarcel Holtmann return -EINVAL; 4352bfa3531SMarcel Holtmann 4362bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4372bfa3531SMarcel Holtmann hdev->idle_timeout = val; 4382bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4392bfa3531SMarcel Holtmann 4402bfa3531SMarcel Holtmann return 0; 4412bfa3531SMarcel Holtmann } 4422bfa3531SMarcel Holtmann 4432bfa3531SMarcel Holtmann static int idle_timeout_get(void *data, u64 *val) 4442bfa3531SMarcel Holtmann { 4452bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4462bfa3531SMarcel Holtmann 4472bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4482bfa3531SMarcel Holtmann *val = hdev->idle_timeout; 4492bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4502bfa3531SMarcel Holtmann 4512bfa3531SMarcel Holtmann return 0; 4522bfa3531SMarcel Holtmann } 4532bfa3531SMarcel Holtmann 4542bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get, 4552bfa3531SMarcel Holtmann idle_timeout_set, "%llu\n"); 4562bfa3531SMarcel Holtmann 457c982b2eaSJohan Hedberg static int rpa_timeout_set(void *data, u64 val) 458c982b2eaSJohan Hedberg { 459c982b2eaSJohan Hedberg struct hci_dev *hdev = data; 460c982b2eaSJohan Hedberg 461c982b2eaSJohan Hedberg /* Require the RPA timeout to be at least 30 seconds and at most 462c982b2eaSJohan Hedberg * 24 hours. 463c982b2eaSJohan Hedberg */ 464c982b2eaSJohan Hedberg if (val < 30 || val > (60 * 60 * 24)) 465c982b2eaSJohan Hedberg return -EINVAL; 466c982b2eaSJohan Hedberg 467c982b2eaSJohan Hedberg hci_dev_lock(hdev); 468c982b2eaSJohan Hedberg hdev->rpa_timeout = val; 469c982b2eaSJohan Hedberg hci_dev_unlock(hdev); 470c982b2eaSJohan Hedberg 471c982b2eaSJohan Hedberg return 0; 472c982b2eaSJohan Hedberg } 473c982b2eaSJohan Hedberg 474c982b2eaSJohan Hedberg static int rpa_timeout_get(void *data, u64 *val) 475c982b2eaSJohan Hedberg { 476c982b2eaSJohan Hedberg struct hci_dev *hdev = data; 477c982b2eaSJohan Hedberg 478c982b2eaSJohan Hedberg hci_dev_lock(hdev); 479c982b2eaSJohan Hedberg *val = hdev->rpa_timeout; 480c982b2eaSJohan Hedberg hci_dev_unlock(hdev); 481c982b2eaSJohan Hedberg 482c982b2eaSJohan Hedberg return 0; 483c982b2eaSJohan Hedberg } 484c982b2eaSJohan Hedberg 485c982b2eaSJohan Hedberg DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get, 486c982b2eaSJohan Hedberg rpa_timeout_set, "%llu\n"); 487c982b2eaSJohan Hedberg 4882bfa3531SMarcel Holtmann static int sniff_min_interval_set(void *data, u64 val) 4892bfa3531SMarcel Holtmann { 4902bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4912bfa3531SMarcel Holtmann 4922bfa3531SMarcel Holtmann if (val == 0 || val % 2 || val > hdev->sniff_max_interval) 4932bfa3531SMarcel Holtmann return -EINVAL; 4942bfa3531SMarcel Holtmann 4952bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4962bfa3531SMarcel Holtmann hdev->sniff_min_interval = val; 4972bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4982bfa3531SMarcel Holtmann 4992bfa3531SMarcel Holtmann return 0; 5002bfa3531SMarcel Holtmann } 5012bfa3531SMarcel Holtmann 5022bfa3531SMarcel Holtmann static int sniff_min_interval_get(void *data, u64 *val) 5032bfa3531SMarcel Holtmann { 5042bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 5052bfa3531SMarcel Holtmann 5062bfa3531SMarcel Holtmann hci_dev_lock(hdev); 5072bfa3531SMarcel Holtmann *val = hdev->sniff_min_interval; 5082bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 5092bfa3531SMarcel Holtmann 5102bfa3531SMarcel Holtmann return 0; 5112bfa3531SMarcel Holtmann } 5122bfa3531SMarcel Holtmann 5132bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get, 5142bfa3531SMarcel Holtmann sniff_min_interval_set, "%llu\n"); 5152bfa3531SMarcel Holtmann 5162bfa3531SMarcel Holtmann static int sniff_max_interval_set(void *data, u64 val) 5172bfa3531SMarcel Holtmann { 5182bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 5192bfa3531SMarcel Holtmann 5202bfa3531SMarcel Holtmann if (val == 0 || val % 2 || val < hdev->sniff_min_interval) 5212bfa3531SMarcel Holtmann return -EINVAL; 5222bfa3531SMarcel Holtmann 5232bfa3531SMarcel Holtmann hci_dev_lock(hdev); 5242bfa3531SMarcel Holtmann hdev->sniff_max_interval = val; 5252bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 5262bfa3531SMarcel Holtmann 5272bfa3531SMarcel Holtmann return 0; 5282bfa3531SMarcel Holtmann } 5292bfa3531SMarcel Holtmann 5302bfa3531SMarcel Holtmann static int sniff_max_interval_get(void *data, u64 *val) 5312bfa3531SMarcel Holtmann { 5322bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 5332bfa3531SMarcel Holtmann 5342bfa3531SMarcel Holtmann hci_dev_lock(hdev); 5352bfa3531SMarcel Holtmann *val = hdev->sniff_max_interval; 5362bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 5372bfa3531SMarcel Holtmann 5382bfa3531SMarcel Holtmann return 0; 5392bfa3531SMarcel Holtmann } 5402bfa3531SMarcel Holtmann 5412bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get, 5422bfa3531SMarcel Holtmann sniff_max_interval_set, "%llu\n"); 5432bfa3531SMarcel Holtmann 54431ad1691SAndrzej Kaczmarek static int conn_info_min_age_set(void *data, u64 val) 54531ad1691SAndrzej Kaczmarek { 54631ad1691SAndrzej Kaczmarek struct hci_dev *hdev = data; 54731ad1691SAndrzej Kaczmarek 54831ad1691SAndrzej Kaczmarek if (val == 0 || val > hdev->conn_info_max_age) 54931ad1691SAndrzej Kaczmarek return -EINVAL; 55031ad1691SAndrzej Kaczmarek 55131ad1691SAndrzej Kaczmarek hci_dev_lock(hdev); 55231ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = val; 55331ad1691SAndrzej Kaczmarek hci_dev_unlock(hdev); 55431ad1691SAndrzej Kaczmarek 55531ad1691SAndrzej Kaczmarek return 0; 55631ad1691SAndrzej Kaczmarek } 55731ad1691SAndrzej Kaczmarek 55831ad1691SAndrzej Kaczmarek static int conn_info_min_age_get(void *data, u64 *val) 55931ad1691SAndrzej Kaczmarek { 56031ad1691SAndrzej Kaczmarek struct hci_dev *hdev = data; 56131ad1691SAndrzej Kaczmarek 56231ad1691SAndrzej Kaczmarek hci_dev_lock(hdev); 56331ad1691SAndrzej Kaczmarek *val = hdev->conn_info_min_age; 56431ad1691SAndrzej Kaczmarek hci_dev_unlock(hdev); 56531ad1691SAndrzej Kaczmarek 56631ad1691SAndrzej Kaczmarek return 0; 56731ad1691SAndrzej Kaczmarek } 56831ad1691SAndrzej Kaczmarek 56931ad1691SAndrzej Kaczmarek DEFINE_SIMPLE_ATTRIBUTE(conn_info_min_age_fops, conn_info_min_age_get, 57031ad1691SAndrzej Kaczmarek conn_info_min_age_set, "%llu\n"); 57131ad1691SAndrzej Kaczmarek 57231ad1691SAndrzej Kaczmarek static int conn_info_max_age_set(void *data, u64 val) 57331ad1691SAndrzej Kaczmarek { 57431ad1691SAndrzej Kaczmarek struct hci_dev *hdev = data; 57531ad1691SAndrzej Kaczmarek 57631ad1691SAndrzej Kaczmarek if (val == 0 || val < hdev->conn_info_min_age) 57731ad1691SAndrzej Kaczmarek return -EINVAL; 57831ad1691SAndrzej Kaczmarek 57931ad1691SAndrzej Kaczmarek hci_dev_lock(hdev); 58031ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = val; 58131ad1691SAndrzej Kaczmarek hci_dev_unlock(hdev); 58231ad1691SAndrzej Kaczmarek 58331ad1691SAndrzej Kaczmarek return 0; 58431ad1691SAndrzej Kaczmarek } 58531ad1691SAndrzej Kaczmarek 58631ad1691SAndrzej Kaczmarek static int conn_info_max_age_get(void *data, u64 *val) 58731ad1691SAndrzej Kaczmarek { 58831ad1691SAndrzej Kaczmarek struct hci_dev *hdev = data; 58931ad1691SAndrzej Kaczmarek 59031ad1691SAndrzej Kaczmarek hci_dev_lock(hdev); 59131ad1691SAndrzej Kaczmarek *val = hdev->conn_info_max_age; 59231ad1691SAndrzej Kaczmarek hci_dev_unlock(hdev); 59331ad1691SAndrzej Kaczmarek 59431ad1691SAndrzej Kaczmarek return 0; 59531ad1691SAndrzej Kaczmarek } 59631ad1691SAndrzej Kaczmarek 59731ad1691SAndrzej Kaczmarek DEFINE_SIMPLE_ATTRIBUTE(conn_info_max_age_fops, conn_info_max_age_get, 59831ad1691SAndrzej Kaczmarek conn_info_max_age_set, "%llu\n"); 59931ad1691SAndrzej Kaczmarek 600ac345813SMarcel Holtmann static int identity_show(struct seq_file *f, void *p) 601ac345813SMarcel Holtmann { 602ac345813SMarcel Holtmann struct hci_dev *hdev = f->private; 603a1f4c318SJohan Hedberg bdaddr_t addr; 604ac345813SMarcel Holtmann u8 addr_type; 605ac345813SMarcel Holtmann 606ac345813SMarcel Holtmann hci_dev_lock(hdev); 607ac345813SMarcel Holtmann 608a1f4c318SJohan Hedberg hci_copy_identity_address(hdev, &addr, &addr_type); 609ac345813SMarcel Holtmann 610a1f4c318SJohan Hedberg seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type, 611473deef2SMarcel Holtmann 16, hdev->irk, &hdev->rpa); 612ac345813SMarcel Holtmann 613ac345813SMarcel Holtmann hci_dev_unlock(hdev); 614ac345813SMarcel Holtmann 615ac345813SMarcel Holtmann return 0; 616ac345813SMarcel Holtmann } 617ac345813SMarcel Holtmann 618ac345813SMarcel Holtmann static int identity_open(struct inode *inode, struct file *file) 619ac345813SMarcel Holtmann { 620ac345813SMarcel Holtmann return single_open(file, identity_show, inode->i_private); 621ac345813SMarcel Holtmann } 622ac345813SMarcel Holtmann 623ac345813SMarcel Holtmann static const struct file_operations identity_fops = { 624ac345813SMarcel Holtmann .open = identity_open, 625ac345813SMarcel Holtmann .read = seq_read, 626ac345813SMarcel Holtmann .llseek = seq_lseek, 627ac345813SMarcel Holtmann .release = single_release, 628ac345813SMarcel Holtmann }; 629ac345813SMarcel Holtmann 6307a4cd51dSMarcel Holtmann static int random_address_show(struct seq_file *f, void *p) 6317a4cd51dSMarcel Holtmann { 6327a4cd51dSMarcel Holtmann struct hci_dev *hdev = f->private; 6337a4cd51dSMarcel Holtmann 6347a4cd51dSMarcel Holtmann hci_dev_lock(hdev); 6357a4cd51dSMarcel Holtmann seq_printf(f, "%pMR\n", &hdev->random_addr); 6367a4cd51dSMarcel Holtmann hci_dev_unlock(hdev); 6377a4cd51dSMarcel Holtmann 6387a4cd51dSMarcel Holtmann return 0; 6397a4cd51dSMarcel Holtmann } 6407a4cd51dSMarcel Holtmann 6417a4cd51dSMarcel Holtmann static int random_address_open(struct inode *inode, struct file *file) 6427a4cd51dSMarcel Holtmann { 6437a4cd51dSMarcel Holtmann return single_open(file, random_address_show, inode->i_private); 6447a4cd51dSMarcel Holtmann } 6457a4cd51dSMarcel Holtmann 6467a4cd51dSMarcel Holtmann static const struct file_operations random_address_fops = { 6477a4cd51dSMarcel Holtmann .open = random_address_open, 6487a4cd51dSMarcel Holtmann .read = seq_read, 6497a4cd51dSMarcel Holtmann .llseek = seq_lseek, 6507a4cd51dSMarcel Holtmann .release = single_release, 6517a4cd51dSMarcel Holtmann }; 6527a4cd51dSMarcel Holtmann 653e7b8fc92SMarcel Holtmann static int static_address_show(struct seq_file *f, void *p) 654e7b8fc92SMarcel Holtmann { 655e7b8fc92SMarcel Holtmann struct hci_dev *hdev = f->private; 656e7b8fc92SMarcel Holtmann 657e7b8fc92SMarcel Holtmann hci_dev_lock(hdev); 658e7b8fc92SMarcel Holtmann seq_printf(f, "%pMR\n", &hdev->static_addr); 659e7b8fc92SMarcel Holtmann hci_dev_unlock(hdev); 660e7b8fc92SMarcel Holtmann 661e7b8fc92SMarcel Holtmann return 0; 662e7b8fc92SMarcel Holtmann } 663e7b8fc92SMarcel Holtmann 664e7b8fc92SMarcel Holtmann static int static_address_open(struct inode *inode, struct file *file) 665e7b8fc92SMarcel Holtmann { 666e7b8fc92SMarcel Holtmann return single_open(file, static_address_show, inode->i_private); 667e7b8fc92SMarcel Holtmann } 668e7b8fc92SMarcel Holtmann 669e7b8fc92SMarcel Holtmann static const struct file_operations static_address_fops = { 670e7b8fc92SMarcel Holtmann .open = static_address_open, 671e7b8fc92SMarcel Holtmann .read = seq_read, 672e7b8fc92SMarcel Holtmann .llseek = seq_lseek, 673e7b8fc92SMarcel Holtmann .release = single_release, 674e7b8fc92SMarcel Holtmann }; 675e7b8fc92SMarcel Holtmann 676b32bba6cSMarcel Holtmann static ssize_t force_static_address_read(struct file *file, 677b32bba6cSMarcel Holtmann char __user *user_buf, 678b32bba6cSMarcel Holtmann size_t count, loff_t *ppos) 67992202185SMarcel Holtmann { 680b32bba6cSMarcel Holtmann struct hci_dev *hdev = file->private_data; 681b32bba6cSMarcel Holtmann char buf[3]; 68292202185SMarcel Holtmann 683111902f7SMarcel Holtmann buf[0] = test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) ? 'Y': 'N'; 684b32bba6cSMarcel Holtmann buf[1] = '\n'; 685b32bba6cSMarcel Holtmann buf[2] = '\0'; 686b32bba6cSMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 687b32bba6cSMarcel Holtmann } 688b32bba6cSMarcel Holtmann 689b32bba6cSMarcel Holtmann static ssize_t force_static_address_write(struct file *file, 690b32bba6cSMarcel Holtmann const char __user *user_buf, 691b32bba6cSMarcel Holtmann size_t count, loff_t *ppos) 692b32bba6cSMarcel Holtmann { 693b32bba6cSMarcel Holtmann struct hci_dev *hdev = file->private_data; 694b32bba6cSMarcel Holtmann char buf[32]; 695b32bba6cSMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 696b32bba6cSMarcel Holtmann bool enable; 697b32bba6cSMarcel Holtmann 698b32bba6cSMarcel Holtmann if (test_bit(HCI_UP, &hdev->flags)) 699b32bba6cSMarcel Holtmann return -EBUSY; 700b32bba6cSMarcel Holtmann 701b32bba6cSMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 702b32bba6cSMarcel Holtmann return -EFAULT; 703b32bba6cSMarcel Holtmann 704b32bba6cSMarcel Holtmann buf[buf_size] = '\0'; 705b32bba6cSMarcel Holtmann if (strtobool(buf, &enable)) 70692202185SMarcel Holtmann return -EINVAL; 70792202185SMarcel Holtmann 708111902f7SMarcel Holtmann if (enable == test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags)) 709b32bba6cSMarcel Holtmann return -EALREADY; 71092202185SMarcel Holtmann 711111902f7SMarcel Holtmann change_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags); 712b32bba6cSMarcel Holtmann 713b32bba6cSMarcel Holtmann return count; 71492202185SMarcel Holtmann } 71592202185SMarcel Holtmann 716b32bba6cSMarcel Holtmann static const struct file_operations force_static_address_fops = { 717b32bba6cSMarcel Holtmann .open = simple_open, 718b32bba6cSMarcel Holtmann .read = force_static_address_read, 719b32bba6cSMarcel Holtmann .write = force_static_address_write, 720b32bba6cSMarcel Holtmann .llseek = default_llseek, 721b32bba6cSMarcel Holtmann }; 72292202185SMarcel Holtmann 723d2ab0ac1SMarcel Holtmann static int white_list_show(struct seq_file *f, void *ptr) 724d2ab0ac1SMarcel Holtmann { 725d2ab0ac1SMarcel Holtmann struct hci_dev *hdev = f->private; 726d2ab0ac1SMarcel Holtmann struct bdaddr_list *b; 727d2ab0ac1SMarcel Holtmann 728d2ab0ac1SMarcel Holtmann hci_dev_lock(hdev); 729d2ab0ac1SMarcel Holtmann list_for_each_entry(b, &hdev->le_white_list, list) 730d2ab0ac1SMarcel Holtmann seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 731d2ab0ac1SMarcel Holtmann hci_dev_unlock(hdev); 732d2ab0ac1SMarcel Holtmann 733d2ab0ac1SMarcel Holtmann return 0; 734d2ab0ac1SMarcel Holtmann } 735d2ab0ac1SMarcel Holtmann 736d2ab0ac1SMarcel Holtmann static int white_list_open(struct inode *inode, struct file *file) 737d2ab0ac1SMarcel Holtmann { 738d2ab0ac1SMarcel Holtmann return single_open(file, white_list_show, inode->i_private); 739d2ab0ac1SMarcel Holtmann } 740d2ab0ac1SMarcel Holtmann 741d2ab0ac1SMarcel Holtmann static const struct file_operations white_list_fops = { 742d2ab0ac1SMarcel Holtmann .open = white_list_open, 743d2ab0ac1SMarcel Holtmann .read = seq_read, 744d2ab0ac1SMarcel Holtmann .llseek = seq_lseek, 745d2ab0ac1SMarcel Holtmann .release = single_release, 746d2ab0ac1SMarcel Holtmann }; 747d2ab0ac1SMarcel Holtmann 7483698d704SMarcel Holtmann static int identity_resolving_keys_show(struct seq_file *f, void *ptr) 7493698d704SMarcel Holtmann { 7503698d704SMarcel Holtmann struct hci_dev *hdev = f->private; 751adae20cbSJohan Hedberg struct smp_irk *irk; 7523698d704SMarcel Holtmann 753adae20cbSJohan Hedberg rcu_read_lock(); 754adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 7553698d704SMarcel Holtmann seq_printf(f, "%pMR (type %u) %*phN %pMR\n", 7563698d704SMarcel Holtmann &irk->bdaddr, irk->addr_type, 7573698d704SMarcel Holtmann 16, irk->val, &irk->rpa); 7583698d704SMarcel Holtmann } 759adae20cbSJohan Hedberg rcu_read_unlock(); 7603698d704SMarcel Holtmann 7613698d704SMarcel Holtmann return 0; 7623698d704SMarcel Holtmann } 7633698d704SMarcel Holtmann 7643698d704SMarcel Holtmann static int identity_resolving_keys_open(struct inode *inode, struct file *file) 7653698d704SMarcel Holtmann { 7663698d704SMarcel Holtmann return single_open(file, identity_resolving_keys_show, 7673698d704SMarcel Holtmann inode->i_private); 7683698d704SMarcel Holtmann } 7693698d704SMarcel Holtmann 7703698d704SMarcel Holtmann static const struct file_operations identity_resolving_keys_fops = { 7713698d704SMarcel Holtmann .open = identity_resolving_keys_open, 7723698d704SMarcel Holtmann .read = seq_read, 7733698d704SMarcel Holtmann .llseek = seq_lseek, 7743698d704SMarcel Holtmann .release = single_release, 7753698d704SMarcel Holtmann }; 7763698d704SMarcel Holtmann 7778f8625cdSMarcel Holtmann static int long_term_keys_show(struct seq_file *f, void *ptr) 7788f8625cdSMarcel Holtmann { 7798f8625cdSMarcel Holtmann struct hci_dev *hdev = f->private; 780970d0f1bSJohan Hedberg struct smp_ltk *ltk; 7818f8625cdSMarcel Holtmann 782970d0f1bSJohan Hedberg rcu_read_lock(); 783970d0f1bSJohan Hedberg list_for_each_entry_rcu(ltk, &hdev->long_term_keys, list) 784fe39c7b2SMarcel Holtmann seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n", 7858f8625cdSMarcel Holtmann <k->bdaddr, ltk->bdaddr_type, ltk->authenticated, 7868f8625cdSMarcel Holtmann ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv), 787fe39c7b2SMarcel Holtmann __le64_to_cpu(ltk->rand), 16, ltk->val); 788970d0f1bSJohan Hedberg rcu_read_unlock(); 7898f8625cdSMarcel Holtmann 7908f8625cdSMarcel Holtmann return 0; 7918f8625cdSMarcel Holtmann } 7928f8625cdSMarcel Holtmann 7938f8625cdSMarcel Holtmann static int long_term_keys_open(struct inode *inode, struct file *file) 7948f8625cdSMarcel Holtmann { 7958f8625cdSMarcel Holtmann return single_open(file, long_term_keys_show, inode->i_private); 7968f8625cdSMarcel Holtmann } 7978f8625cdSMarcel Holtmann 7988f8625cdSMarcel Holtmann static const struct file_operations long_term_keys_fops = { 7998f8625cdSMarcel Holtmann .open = long_term_keys_open, 8008f8625cdSMarcel Holtmann .read = seq_read, 8018f8625cdSMarcel Holtmann .llseek = seq_lseek, 8028f8625cdSMarcel Holtmann .release = single_release, 8038f8625cdSMarcel Holtmann }; 8048f8625cdSMarcel Holtmann 8054e70c7e7SMarcel Holtmann static int conn_min_interval_set(void *data, u64 val) 8064e70c7e7SMarcel Holtmann { 8074e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 8084e70c7e7SMarcel Holtmann 8094e70c7e7SMarcel Holtmann if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval) 8104e70c7e7SMarcel Holtmann return -EINVAL; 8114e70c7e7SMarcel Holtmann 8124e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 8134e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = val; 8144e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 8154e70c7e7SMarcel Holtmann 8164e70c7e7SMarcel Holtmann return 0; 8174e70c7e7SMarcel Holtmann } 8184e70c7e7SMarcel Holtmann 8194e70c7e7SMarcel Holtmann static int conn_min_interval_get(void *data, u64 *val) 8204e70c7e7SMarcel Holtmann { 8214e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 8224e70c7e7SMarcel Holtmann 8234e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 8244e70c7e7SMarcel Holtmann *val = hdev->le_conn_min_interval; 8254e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 8264e70c7e7SMarcel Holtmann 8274e70c7e7SMarcel Holtmann return 0; 8284e70c7e7SMarcel Holtmann } 8294e70c7e7SMarcel Holtmann 8304e70c7e7SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get, 8314e70c7e7SMarcel Holtmann conn_min_interval_set, "%llu\n"); 8324e70c7e7SMarcel Holtmann 8334e70c7e7SMarcel Holtmann static int conn_max_interval_set(void *data, u64 val) 8344e70c7e7SMarcel Holtmann { 8354e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 8364e70c7e7SMarcel Holtmann 8374e70c7e7SMarcel Holtmann if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval) 8384e70c7e7SMarcel Holtmann return -EINVAL; 8394e70c7e7SMarcel Holtmann 8404e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 8414e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = val; 8424e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 8434e70c7e7SMarcel Holtmann 8444e70c7e7SMarcel Holtmann return 0; 8454e70c7e7SMarcel Holtmann } 8464e70c7e7SMarcel Holtmann 8474e70c7e7SMarcel Holtmann static int conn_max_interval_get(void *data, u64 *val) 8484e70c7e7SMarcel Holtmann { 8494e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 8504e70c7e7SMarcel Holtmann 8514e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 8524e70c7e7SMarcel Holtmann *val = hdev->le_conn_max_interval; 8534e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 8544e70c7e7SMarcel Holtmann 8554e70c7e7SMarcel Holtmann return 0; 8564e70c7e7SMarcel Holtmann } 8574e70c7e7SMarcel Holtmann 8584e70c7e7SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get, 8594e70c7e7SMarcel Holtmann conn_max_interval_set, "%llu\n"); 8604e70c7e7SMarcel Holtmann 861816a93d1SMarcel Holtmann static int conn_latency_set(void *data, u64 val) 862816a93d1SMarcel Holtmann { 863816a93d1SMarcel Holtmann struct hci_dev *hdev = data; 864816a93d1SMarcel Holtmann 865816a93d1SMarcel Holtmann if (val > 0x01f3) 866816a93d1SMarcel Holtmann return -EINVAL; 867816a93d1SMarcel Holtmann 868816a93d1SMarcel Holtmann hci_dev_lock(hdev); 869816a93d1SMarcel Holtmann hdev->le_conn_latency = val; 870816a93d1SMarcel Holtmann hci_dev_unlock(hdev); 871816a93d1SMarcel Holtmann 872816a93d1SMarcel Holtmann return 0; 873816a93d1SMarcel Holtmann } 874816a93d1SMarcel Holtmann 875816a93d1SMarcel Holtmann static int conn_latency_get(void *data, u64 *val) 876816a93d1SMarcel Holtmann { 877816a93d1SMarcel Holtmann struct hci_dev *hdev = data; 878816a93d1SMarcel Holtmann 879816a93d1SMarcel Holtmann hci_dev_lock(hdev); 880816a93d1SMarcel Holtmann *val = hdev->le_conn_latency; 881816a93d1SMarcel Holtmann hci_dev_unlock(hdev); 882816a93d1SMarcel Holtmann 883816a93d1SMarcel Holtmann return 0; 884816a93d1SMarcel Holtmann } 885816a93d1SMarcel Holtmann 886816a93d1SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get, 887816a93d1SMarcel Holtmann conn_latency_set, "%llu\n"); 888816a93d1SMarcel Holtmann 889f1649577SMarcel Holtmann static int supervision_timeout_set(void *data, u64 val) 890f1649577SMarcel Holtmann { 891f1649577SMarcel Holtmann struct hci_dev *hdev = data; 892f1649577SMarcel Holtmann 893f1649577SMarcel Holtmann if (val < 0x000a || val > 0x0c80) 894f1649577SMarcel Holtmann return -EINVAL; 895f1649577SMarcel Holtmann 896f1649577SMarcel Holtmann hci_dev_lock(hdev); 897f1649577SMarcel Holtmann hdev->le_supv_timeout = val; 898f1649577SMarcel Holtmann hci_dev_unlock(hdev); 899f1649577SMarcel Holtmann 900f1649577SMarcel Holtmann return 0; 901f1649577SMarcel Holtmann } 902f1649577SMarcel Holtmann 903f1649577SMarcel Holtmann static int supervision_timeout_get(void *data, u64 *val) 904f1649577SMarcel Holtmann { 905f1649577SMarcel Holtmann struct hci_dev *hdev = data; 906f1649577SMarcel Holtmann 907f1649577SMarcel Holtmann hci_dev_lock(hdev); 908f1649577SMarcel Holtmann *val = hdev->le_supv_timeout; 909f1649577SMarcel Holtmann hci_dev_unlock(hdev); 910f1649577SMarcel Holtmann 911f1649577SMarcel Holtmann return 0; 912f1649577SMarcel Holtmann } 913f1649577SMarcel Holtmann 914f1649577SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get, 915f1649577SMarcel Holtmann supervision_timeout_set, "%llu\n"); 916f1649577SMarcel Holtmann 9173f959d46SMarcel Holtmann static int adv_channel_map_set(void *data, u64 val) 9183f959d46SMarcel Holtmann { 9193f959d46SMarcel Holtmann struct hci_dev *hdev = data; 9203f959d46SMarcel Holtmann 9213f959d46SMarcel Holtmann if (val < 0x01 || val > 0x07) 9223f959d46SMarcel Holtmann return -EINVAL; 9233f959d46SMarcel Holtmann 9243f959d46SMarcel Holtmann hci_dev_lock(hdev); 9253f959d46SMarcel Holtmann hdev->le_adv_channel_map = val; 9263f959d46SMarcel Holtmann hci_dev_unlock(hdev); 9273f959d46SMarcel Holtmann 9283f959d46SMarcel Holtmann return 0; 9293f959d46SMarcel Holtmann } 9303f959d46SMarcel Holtmann 9313f959d46SMarcel Holtmann static int adv_channel_map_get(void *data, u64 *val) 9323f959d46SMarcel Holtmann { 9333f959d46SMarcel Holtmann struct hci_dev *hdev = data; 9343f959d46SMarcel Holtmann 9353f959d46SMarcel Holtmann hci_dev_lock(hdev); 9363f959d46SMarcel Holtmann *val = hdev->le_adv_channel_map; 9373f959d46SMarcel Holtmann hci_dev_unlock(hdev); 9383f959d46SMarcel Holtmann 9393f959d46SMarcel Holtmann return 0; 9403f959d46SMarcel Holtmann } 9413f959d46SMarcel Holtmann 9423f959d46SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get, 9433f959d46SMarcel Holtmann adv_channel_map_set, "%llu\n"); 9443f959d46SMarcel Holtmann 945729a1051SGeorg Lukas static int adv_min_interval_set(void *data, u64 val) 94689863109SJukka Rissanen { 947729a1051SGeorg Lukas struct hci_dev *hdev = data; 94889863109SJukka Rissanen 949729a1051SGeorg Lukas if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval) 95089863109SJukka Rissanen return -EINVAL; 95189863109SJukka Rissanen 9527d474e06SAndre Guedes hci_dev_lock(hdev); 953729a1051SGeorg Lukas hdev->le_adv_min_interval = val; 9547d474e06SAndre Guedes hci_dev_unlock(hdev); 9557d474e06SAndre Guedes 9567d474e06SAndre Guedes return 0; 9577d474e06SAndre Guedes } 9587d474e06SAndre Guedes 959729a1051SGeorg Lukas static int adv_min_interval_get(void *data, u64 *val) 9607d474e06SAndre Guedes { 961729a1051SGeorg Lukas struct hci_dev *hdev = data; 962729a1051SGeorg Lukas 963729a1051SGeorg Lukas hci_dev_lock(hdev); 964729a1051SGeorg Lukas *val = hdev->le_adv_min_interval; 965729a1051SGeorg Lukas hci_dev_unlock(hdev); 966729a1051SGeorg Lukas 967729a1051SGeorg Lukas return 0; 9687d474e06SAndre Guedes } 9697d474e06SAndre Guedes 970729a1051SGeorg Lukas DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get, 971729a1051SGeorg Lukas adv_min_interval_set, "%llu\n"); 9727d474e06SAndre Guedes 973729a1051SGeorg Lukas static int adv_max_interval_set(void *data, u64 val) 974729a1051SGeorg Lukas { 975729a1051SGeorg Lukas struct hci_dev *hdev = data; 976729a1051SGeorg Lukas 977729a1051SGeorg Lukas if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval) 9787d474e06SAndre Guedes return -EINVAL; 9797d474e06SAndre Guedes 9807d474e06SAndre Guedes hci_dev_lock(hdev); 981729a1051SGeorg Lukas hdev->le_adv_max_interval = val; 9827d474e06SAndre Guedes hci_dev_unlock(hdev); 9837d474e06SAndre Guedes 984729a1051SGeorg Lukas return 0; 9857d474e06SAndre Guedes } 9867d474e06SAndre Guedes 987729a1051SGeorg Lukas static int adv_max_interval_get(void *data, u64 *val) 988729a1051SGeorg Lukas { 989729a1051SGeorg Lukas struct hci_dev *hdev = data; 990729a1051SGeorg Lukas 9917d474e06SAndre Guedes hci_dev_lock(hdev); 992729a1051SGeorg Lukas *val = hdev->le_adv_max_interval; 9937d474e06SAndre Guedes hci_dev_unlock(hdev); 994729a1051SGeorg Lukas 995729a1051SGeorg Lukas return 0; 996729a1051SGeorg Lukas } 997729a1051SGeorg Lukas 998729a1051SGeorg Lukas DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get, 999729a1051SGeorg Lukas adv_max_interval_set, "%llu\n"); 1000729a1051SGeorg Lukas 10010b3c7d37SMarcel Holtmann static int device_list_show(struct seq_file *f, void *ptr) 10027d474e06SAndre Guedes { 10030b3c7d37SMarcel Holtmann struct hci_dev *hdev = f->private; 10047d474e06SAndre Guedes struct hci_conn_params *p; 100540f4938aSMarcel Holtmann struct bdaddr_list *b; 10067d474e06SAndre Guedes 10077d474e06SAndre Guedes hci_dev_lock(hdev); 100840f4938aSMarcel Holtmann list_for_each_entry(b, &hdev->whitelist, list) 100940f4938aSMarcel Holtmann seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 10107d474e06SAndre Guedes list_for_each_entry(p, &hdev->le_conn_params, list) { 101140f4938aSMarcel Holtmann seq_printf(f, "%pMR (type %u) %u\n", &p->addr, p->addr_type, 10127d474e06SAndre Guedes p->auto_connect); 10137d474e06SAndre Guedes } 10147d474e06SAndre Guedes hci_dev_unlock(hdev); 10157d474e06SAndre Guedes 10167d474e06SAndre Guedes return 0; 10177d474e06SAndre Guedes } 10187d474e06SAndre Guedes 10190b3c7d37SMarcel Holtmann static int device_list_open(struct inode *inode, struct file *file) 10207d474e06SAndre Guedes { 10210b3c7d37SMarcel Holtmann return single_open(file, device_list_show, inode->i_private); 10227d474e06SAndre Guedes } 10237d474e06SAndre Guedes 10240b3c7d37SMarcel Holtmann static const struct file_operations device_list_fops = { 10250b3c7d37SMarcel Holtmann .open = device_list_open, 10267d474e06SAndre Guedes .read = seq_read, 10277d474e06SAndre Guedes .llseek = seq_lseek, 10287d474e06SAndre Guedes .release = single_release, 10297d474e06SAndre Guedes }; 10307d474e06SAndre Guedes 10311da177e4SLinus Torvalds /* ---- HCI requests ---- */ 10321da177e4SLinus Torvalds 103342c6b129SJohan Hedberg static void hci_req_sync_complete(struct hci_dev *hdev, u8 result) 10341da177e4SLinus Torvalds { 103542c6b129SJohan Hedberg BT_DBG("%s result 0x%2.2x", hdev->name, result); 103675fb0e32SJohan Hedberg 10371da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 10381da177e4SLinus Torvalds hdev->req_result = result; 10391da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 10401da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 10411da177e4SLinus Torvalds } 10421da177e4SLinus Torvalds } 10431da177e4SLinus Torvalds 10441da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 10451da177e4SLinus Torvalds { 10461da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 10471da177e4SLinus Torvalds 10481da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 10491da177e4SLinus Torvalds hdev->req_result = err; 10501da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 10511da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 10521da177e4SLinus Torvalds } 10531da177e4SLinus Torvalds } 10541da177e4SLinus Torvalds 105577a63e0aSFengguang Wu static struct sk_buff *hci_get_cmd_complete(struct hci_dev *hdev, u16 opcode, 105677a63e0aSFengguang Wu u8 event) 105775e84b7cSJohan Hedberg { 105875e84b7cSJohan Hedberg struct hci_ev_cmd_complete *ev; 105975e84b7cSJohan Hedberg struct hci_event_hdr *hdr; 106075e84b7cSJohan Hedberg struct sk_buff *skb; 106175e84b7cSJohan Hedberg 106275e84b7cSJohan Hedberg hci_dev_lock(hdev); 106375e84b7cSJohan Hedberg 106475e84b7cSJohan Hedberg skb = hdev->recv_evt; 106575e84b7cSJohan Hedberg hdev->recv_evt = NULL; 106675e84b7cSJohan Hedberg 106775e84b7cSJohan Hedberg hci_dev_unlock(hdev); 106875e84b7cSJohan Hedberg 106975e84b7cSJohan Hedberg if (!skb) 107075e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 107175e84b7cSJohan Hedberg 107275e84b7cSJohan Hedberg if (skb->len < sizeof(*hdr)) { 107375e84b7cSJohan Hedberg BT_ERR("Too short HCI event"); 107475e84b7cSJohan Hedberg goto failed; 107575e84b7cSJohan Hedberg } 107675e84b7cSJohan Hedberg 107775e84b7cSJohan Hedberg hdr = (void *) skb->data; 107875e84b7cSJohan Hedberg skb_pull(skb, HCI_EVENT_HDR_SIZE); 107975e84b7cSJohan Hedberg 10807b1abbbeSJohan Hedberg if (event) { 10817b1abbbeSJohan Hedberg if (hdr->evt != event) 10827b1abbbeSJohan Hedberg goto failed; 10837b1abbbeSJohan Hedberg return skb; 10847b1abbbeSJohan Hedberg } 10857b1abbbeSJohan Hedberg 108675e84b7cSJohan Hedberg if (hdr->evt != HCI_EV_CMD_COMPLETE) { 108775e84b7cSJohan Hedberg BT_DBG("Last event is not cmd complete (0x%2.2x)", hdr->evt); 108875e84b7cSJohan Hedberg goto failed; 108975e84b7cSJohan Hedberg } 109075e84b7cSJohan Hedberg 109175e84b7cSJohan Hedberg if (skb->len < sizeof(*ev)) { 109275e84b7cSJohan Hedberg BT_ERR("Too short cmd_complete event"); 109375e84b7cSJohan Hedberg goto failed; 109475e84b7cSJohan Hedberg } 109575e84b7cSJohan Hedberg 109675e84b7cSJohan Hedberg ev = (void *) skb->data; 109775e84b7cSJohan Hedberg skb_pull(skb, sizeof(*ev)); 109875e84b7cSJohan Hedberg 109975e84b7cSJohan Hedberg if (opcode == __le16_to_cpu(ev->opcode)) 110075e84b7cSJohan Hedberg return skb; 110175e84b7cSJohan Hedberg 110275e84b7cSJohan Hedberg BT_DBG("opcode doesn't match (0x%2.2x != 0x%2.2x)", opcode, 110375e84b7cSJohan Hedberg __le16_to_cpu(ev->opcode)); 110475e84b7cSJohan Hedberg 110575e84b7cSJohan Hedberg failed: 110675e84b7cSJohan Hedberg kfree_skb(skb); 110775e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 110875e84b7cSJohan Hedberg } 110975e84b7cSJohan Hedberg 11107b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, 111107dc93ddSJohan Hedberg const void *param, u8 event, u32 timeout) 111275e84b7cSJohan Hedberg { 111375e84b7cSJohan Hedberg DECLARE_WAITQUEUE(wait, current); 111475e84b7cSJohan Hedberg struct hci_request req; 111575e84b7cSJohan Hedberg int err = 0; 111675e84b7cSJohan Hedberg 111775e84b7cSJohan Hedberg BT_DBG("%s", hdev->name); 111875e84b7cSJohan Hedberg 111975e84b7cSJohan Hedberg hci_req_init(&req, hdev); 112075e84b7cSJohan Hedberg 11217b1abbbeSJohan Hedberg hci_req_add_ev(&req, opcode, plen, param, event); 112275e84b7cSJohan Hedberg 112375e84b7cSJohan Hedberg hdev->req_status = HCI_REQ_PEND; 112475e84b7cSJohan Hedberg 112575e84b7cSJohan Hedberg add_wait_queue(&hdev->req_wait_q, &wait); 112675e84b7cSJohan Hedberg set_current_state(TASK_INTERRUPTIBLE); 112775e84b7cSJohan Hedberg 1128039fada5SChan-yeol Park err = hci_req_run(&req, hci_req_sync_complete); 1129039fada5SChan-yeol Park if (err < 0) { 1130039fada5SChan-yeol Park remove_wait_queue(&hdev->req_wait_q, &wait); 113122a3ceabSJohan Hedberg set_current_state(TASK_RUNNING); 1132039fada5SChan-yeol Park return ERR_PTR(err); 1133039fada5SChan-yeol Park } 1134039fada5SChan-yeol Park 113575e84b7cSJohan Hedberg schedule_timeout(timeout); 113675e84b7cSJohan Hedberg 113775e84b7cSJohan Hedberg remove_wait_queue(&hdev->req_wait_q, &wait); 113875e84b7cSJohan Hedberg 113975e84b7cSJohan Hedberg if (signal_pending(current)) 114075e84b7cSJohan Hedberg return ERR_PTR(-EINTR); 114175e84b7cSJohan Hedberg 114275e84b7cSJohan Hedberg switch (hdev->req_status) { 114375e84b7cSJohan Hedberg case HCI_REQ_DONE: 114475e84b7cSJohan Hedberg err = -bt_to_errno(hdev->req_result); 114575e84b7cSJohan Hedberg break; 114675e84b7cSJohan Hedberg 114775e84b7cSJohan Hedberg case HCI_REQ_CANCELED: 114875e84b7cSJohan Hedberg err = -hdev->req_result; 114975e84b7cSJohan Hedberg break; 115075e84b7cSJohan Hedberg 115175e84b7cSJohan Hedberg default: 115275e84b7cSJohan Hedberg err = -ETIMEDOUT; 115375e84b7cSJohan Hedberg break; 115475e84b7cSJohan Hedberg } 115575e84b7cSJohan Hedberg 115675e84b7cSJohan Hedberg hdev->req_status = hdev->req_result = 0; 115775e84b7cSJohan Hedberg 115875e84b7cSJohan Hedberg BT_DBG("%s end: err %d", hdev->name, err); 115975e84b7cSJohan Hedberg 116075e84b7cSJohan Hedberg if (err < 0) 116175e84b7cSJohan Hedberg return ERR_PTR(err); 116275e84b7cSJohan Hedberg 11637b1abbbeSJohan Hedberg return hci_get_cmd_complete(hdev, opcode, event); 11647b1abbbeSJohan Hedberg } 11657b1abbbeSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync_ev); 11667b1abbbeSJohan Hedberg 11677b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 116807dc93ddSJohan Hedberg const void *param, u32 timeout) 11697b1abbbeSJohan Hedberg { 11707b1abbbeSJohan Hedberg return __hci_cmd_sync_ev(hdev, opcode, plen, param, 0, timeout); 117175e84b7cSJohan Hedberg } 117275e84b7cSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync); 117375e84b7cSJohan Hedberg 11741da177e4SLinus Torvalds /* Execute request and wait for completion. */ 117501178cd4SJohan Hedberg static int __hci_req_sync(struct hci_dev *hdev, 117642c6b129SJohan Hedberg void (*func)(struct hci_request *req, 117742c6b129SJohan Hedberg unsigned long opt), 11781da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 11791da177e4SLinus Torvalds { 118042c6b129SJohan Hedberg struct hci_request req; 11811da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 11821da177e4SLinus Torvalds int err = 0; 11831da177e4SLinus Torvalds 11841da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 11851da177e4SLinus Torvalds 118642c6b129SJohan Hedberg hci_req_init(&req, hdev); 118742c6b129SJohan Hedberg 11881da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 11891da177e4SLinus Torvalds 119042c6b129SJohan Hedberg func(&req, opt); 119153cce22dSJohan Hedberg 1192039fada5SChan-yeol Park add_wait_queue(&hdev->req_wait_q, &wait); 1193039fada5SChan-yeol Park set_current_state(TASK_INTERRUPTIBLE); 1194039fada5SChan-yeol Park 119542c6b129SJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 119642c6b129SJohan Hedberg if (err < 0) { 119753cce22dSJohan Hedberg hdev->req_status = 0; 1198920c8300SAndre Guedes 1199039fada5SChan-yeol Park remove_wait_queue(&hdev->req_wait_q, &wait); 120022a3ceabSJohan Hedberg set_current_state(TASK_RUNNING); 1201039fada5SChan-yeol Park 1202920c8300SAndre Guedes /* ENODATA means the HCI request command queue is empty. 1203920c8300SAndre Guedes * This can happen when a request with conditionals doesn't 1204920c8300SAndre Guedes * trigger any commands to be sent. This is normal behavior 1205920c8300SAndre Guedes * and should not trigger an error return. 120642c6b129SJohan Hedberg */ 1207920c8300SAndre Guedes if (err == -ENODATA) 120842c6b129SJohan Hedberg return 0; 1209920c8300SAndre Guedes 1210920c8300SAndre Guedes return err; 121153cce22dSJohan Hedberg } 121253cce22dSJohan Hedberg 12131da177e4SLinus Torvalds schedule_timeout(timeout); 12141da177e4SLinus Torvalds 12151da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 12161da177e4SLinus Torvalds 12171da177e4SLinus Torvalds if (signal_pending(current)) 12181da177e4SLinus Torvalds return -EINTR; 12191da177e4SLinus Torvalds 12201da177e4SLinus Torvalds switch (hdev->req_status) { 12211da177e4SLinus Torvalds case HCI_REQ_DONE: 1222e175072fSJoe Perches err = -bt_to_errno(hdev->req_result); 12231da177e4SLinus Torvalds break; 12241da177e4SLinus Torvalds 12251da177e4SLinus Torvalds case HCI_REQ_CANCELED: 12261da177e4SLinus Torvalds err = -hdev->req_result; 12271da177e4SLinus Torvalds break; 12281da177e4SLinus Torvalds 12291da177e4SLinus Torvalds default: 12301da177e4SLinus Torvalds err = -ETIMEDOUT; 12311da177e4SLinus Torvalds break; 12323ff50b79SStephen Hemminger } 12331da177e4SLinus Torvalds 1234a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 12351da177e4SLinus Torvalds 12361da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds return err; 12391da177e4SLinus Torvalds } 12401da177e4SLinus Torvalds 124101178cd4SJohan Hedberg static int hci_req_sync(struct hci_dev *hdev, 124242c6b129SJohan Hedberg void (*req)(struct hci_request *req, 124342c6b129SJohan Hedberg unsigned long opt), 12441da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 12451da177e4SLinus Torvalds { 12461da177e4SLinus Torvalds int ret; 12471da177e4SLinus Torvalds 12487c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 12497c6a329eSMarcel Holtmann return -ENETDOWN; 12507c6a329eSMarcel Holtmann 12511da177e4SLinus Torvalds /* Serialize all requests */ 12521da177e4SLinus Torvalds hci_req_lock(hdev); 125301178cd4SJohan Hedberg ret = __hci_req_sync(hdev, req, opt, timeout); 12541da177e4SLinus Torvalds hci_req_unlock(hdev); 12551da177e4SLinus Torvalds 12561da177e4SLinus Torvalds return ret; 12571da177e4SLinus Torvalds } 12581da177e4SLinus Torvalds 125942c6b129SJohan Hedberg static void hci_reset_req(struct hci_request *req, unsigned long opt) 12601da177e4SLinus Torvalds { 126142c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 12621da177e4SLinus Torvalds 12631da177e4SLinus Torvalds /* Reset device */ 126442c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 126542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 12661da177e4SLinus Torvalds } 12671da177e4SLinus Torvalds 126842c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 12691da177e4SLinus Torvalds { 127042c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 12712455a3eaSAndrei Emeltchenko 12721da177e4SLinus Torvalds /* Read Local Supported Features */ 127342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 12741da177e4SLinus Torvalds 12751143e5a6SMarcel Holtmann /* Read Local Version */ 127642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 12772177bab5SJohan Hedberg 12782177bab5SJohan Hedberg /* Read BD Address */ 127942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 12801da177e4SLinus Torvalds } 12811da177e4SLinus Torvalds 128242c6b129SJohan Hedberg static void amp_init(struct hci_request *req) 1283e61ef499SAndrei Emeltchenko { 128442c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 12852455a3eaSAndrei Emeltchenko 1286e61ef499SAndrei Emeltchenko /* Read Local Version */ 128742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 12886bcbc489SAndrei Emeltchenko 1289f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 1290f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 1291f6996cfeSMarcel Holtmann 1292f6996cfeSMarcel Holtmann /* Read Local Supported Features */ 1293f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 1294f6996cfeSMarcel Holtmann 12956bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 129642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 1297e71dfabaSAndrei Emeltchenko 1298e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 129942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 13007528ca1cSMarcel Holtmann 1301f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 1302f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 1303f38ba941SMarcel Holtmann 13047528ca1cSMarcel Holtmann /* Read Location Data */ 13057528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 1306e61ef499SAndrei Emeltchenko } 1307e61ef499SAndrei Emeltchenko 130842c6b129SJohan Hedberg static void hci_init1_req(struct hci_request *req, unsigned long opt) 1309e61ef499SAndrei Emeltchenko { 131042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 1311e61ef499SAndrei Emeltchenko 1312e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 1313e61ef499SAndrei Emeltchenko 131411778716SAndrei Emeltchenko /* Reset */ 131511778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 131642c6b129SJohan Hedberg hci_reset_req(req, 0); 131711778716SAndrei Emeltchenko 1318e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 1319e61ef499SAndrei Emeltchenko case HCI_BREDR: 132042c6b129SJohan Hedberg bredr_init(req); 1321e61ef499SAndrei Emeltchenko break; 1322e61ef499SAndrei Emeltchenko 1323e61ef499SAndrei Emeltchenko case HCI_AMP: 132442c6b129SJohan Hedberg amp_init(req); 1325e61ef499SAndrei Emeltchenko break; 1326e61ef499SAndrei Emeltchenko 1327e61ef499SAndrei Emeltchenko default: 1328e61ef499SAndrei Emeltchenko BT_ERR("Unknown device type %d", hdev->dev_type); 1329e61ef499SAndrei Emeltchenko break; 1330e61ef499SAndrei Emeltchenko } 1331e61ef499SAndrei Emeltchenko } 1332e61ef499SAndrei Emeltchenko 133342c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 13342177bab5SJohan Hedberg { 13354ca048e3SMarcel Holtmann struct hci_dev *hdev = req->hdev; 13364ca048e3SMarcel Holtmann 13372177bab5SJohan Hedberg __le16 param; 13382177bab5SJohan Hedberg __u8 flt_type; 13392177bab5SJohan Hedberg 13402177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 134142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 13422177bab5SJohan Hedberg 13432177bab5SJohan Hedberg /* Read Class of Device */ 134442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 13452177bab5SJohan Hedberg 13462177bab5SJohan Hedberg /* Read Local Name */ 134742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 13482177bab5SJohan Hedberg 13492177bab5SJohan Hedberg /* Read Voice Setting */ 135042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 13512177bab5SJohan Hedberg 1352b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 1353b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 1354b4cb9fb2SMarcel Holtmann 13554b836f39SMarcel Holtmann /* Read Current IAC LAP */ 13564b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 13574b836f39SMarcel Holtmann 13582177bab5SJohan Hedberg /* Clear Event Filters */ 13592177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 136042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 13612177bab5SJohan Hedberg 13622177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 1363dcf4adbfSJoe Perches param = cpu_to_le16(0x7d00); 136442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 13652177bab5SJohan Hedberg 13664ca048e3SMarcel Holtmann /* AVM Berlin (31), aka "BlueFRITZ!", reports version 1.2, 13674ca048e3SMarcel Holtmann * but it does not support page scan related HCI commands. 13684ca048e3SMarcel Holtmann */ 13694ca048e3SMarcel Holtmann if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) { 1370f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 1371f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 1372f332ec66SJohan Hedberg } 13732177bab5SJohan Hedberg } 13742177bab5SJohan Hedberg 137542c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 13762177bab5SJohan Hedberg { 1377c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 1378c73eee91SJohan Hedberg 13792177bab5SJohan Hedberg /* Read LE Buffer Size */ 138042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 13812177bab5SJohan Hedberg 13822177bab5SJohan Hedberg /* Read LE Local Supported Features */ 138342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 13842177bab5SJohan Hedberg 1385747d3f03SMarcel Holtmann /* Read LE Supported States */ 1386747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 1387747d3f03SMarcel Holtmann 13882177bab5SJohan Hedberg /* Read LE White List Size */ 138942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 0, NULL); 13902177bab5SJohan Hedberg 1391747d3f03SMarcel Holtmann /* Clear LE White List */ 1392747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 1393c73eee91SJohan Hedberg 1394c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 1395c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1396c73eee91SJohan Hedberg set_bit(HCI_LE_ENABLED, &hdev->dev_flags); 13972177bab5SJohan Hedberg } 13982177bab5SJohan Hedberg 13992177bab5SJohan Hedberg static u8 hci_get_inquiry_mode(struct hci_dev *hdev) 14002177bab5SJohan Hedberg { 14012177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 14022177bab5SJohan Hedberg return 0x02; 14032177bab5SJohan Hedberg 14042177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 14052177bab5SJohan Hedberg return 0x01; 14062177bab5SJohan Hedberg 14072177bab5SJohan Hedberg if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 && 14082177bab5SJohan Hedberg hdev->lmp_subver == 0x0757) 14092177bab5SJohan Hedberg return 0x01; 14102177bab5SJohan Hedberg 14112177bab5SJohan Hedberg if (hdev->manufacturer == 15) { 14122177bab5SJohan Hedberg if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963) 14132177bab5SJohan Hedberg return 0x01; 14142177bab5SJohan Hedberg if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963) 14152177bab5SJohan Hedberg return 0x01; 14162177bab5SJohan Hedberg if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965) 14172177bab5SJohan Hedberg return 0x01; 14182177bab5SJohan Hedberg } 14192177bab5SJohan Hedberg 14202177bab5SJohan Hedberg if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 && 14212177bab5SJohan Hedberg hdev->lmp_subver == 0x1805) 14222177bab5SJohan Hedberg return 0x01; 14232177bab5SJohan Hedberg 14242177bab5SJohan Hedberg return 0x00; 14252177bab5SJohan Hedberg } 14262177bab5SJohan Hedberg 142742c6b129SJohan Hedberg static void hci_setup_inquiry_mode(struct hci_request *req) 14282177bab5SJohan Hedberg { 14292177bab5SJohan Hedberg u8 mode; 14302177bab5SJohan Hedberg 143142c6b129SJohan Hedberg mode = hci_get_inquiry_mode(req->hdev); 14322177bab5SJohan Hedberg 143342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 14342177bab5SJohan Hedberg } 14352177bab5SJohan Hedberg 143642c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 14372177bab5SJohan Hedberg { 143842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 143942c6b129SJohan Hedberg 14402177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 14412177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 14422177bab5SJohan Hedberg * command otherwise. 14432177bab5SJohan Hedberg */ 14442177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 14452177bab5SJohan Hedberg 14462177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 14472177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 14482177bab5SJohan Hedberg */ 14492177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 14502177bab5SJohan Hedberg return; 14512177bab5SJohan Hedberg 14522177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 14532177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 14542177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 14552177bab5SJohan Hedberg events[4] |= 0x04; /* Read Remote Extended Features Complete */ 14562177bab5SJohan Hedberg events[5] |= 0x08; /* Synchronous Connection Complete */ 14572177bab5SJohan Hedberg events[5] |= 0x10; /* Synchronous Connection Changed */ 1458c7882cbdSMarcel Holtmann } else { 1459c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 1460c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 1461c7882cbdSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 1462c7882cbdSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information Complete */ 1463c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 1464c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 1465c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 1466c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 1467c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 14680da71f1bSMarcel Holtmann 14690da71f1bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) { 14700da71f1bSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 1471c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 14722177bab5SJohan Hedberg } 14730da71f1bSMarcel Holtmann } 14742177bab5SJohan Hedberg 14752177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 14762177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 14772177bab5SJohan Hedberg 14782177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 14792177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 14802177bab5SJohan Hedberg 14812177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 14822177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 14832177bab5SJohan Hedberg 14842177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 14852177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 14862177bab5SJohan Hedberg 14872177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 14882177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 14892177bab5SJohan Hedberg 14902177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 14912177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 14922177bab5SJohan Hedberg 14932177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 14942177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 14952177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 14962177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 14972177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 14982177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 14992177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 15002177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 15012177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 15022177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 15032177bab5SJohan Hedberg * Features Notification 15042177bab5SJohan Hedberg */ 15052177bab5SJohan Hedberg } 15062177bab5SJohan Hedberg 15072177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 15082177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 15092177bab5SJohan Hedberg 151042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 15112177bab5SJohan Hedberg } 15122177bab5SJohan Hedberg 151342c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 15142177bab5SJohan Hedberg { 151542c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 151642c6b129SJohan Hedberg 15172177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 151842c6b129SJohan Hedberg bredr_setup(req); 151956f87901SJohan Hedberg else 152056f87901SJohan Hedberg clear_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 15212177bab5SJohan Hedberg 15222177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 152342c6b129SJohan Hedberg le_setup(req); 15242177bab5SJohan Hedberg 15253f8e2d75SJohan Hedberg /* AVM Berlin (31), aka "BlueFRITZ!", doesn't support the read 15263f8e2d75SJohan Hedberg * local supported commands HCI command. 15273f8e2d75SJohan Hedberg */ 15283f8e2d75SJohan Hedberg if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) 152942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 15302177bab5SJohan Hedberg 15312177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 153257af75a8SMarcel Holtmann /* When SSP is available, then the host features page 153357af75a8SMarcel Holtmann * should also be available as well. However some 153457af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 153557af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 153657af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 153757af75a8SMarcel Holtmann */ 153857af75a8SMarcel Holtmann hdev->max_page = 0x01; 153957af75a8SMarcel Holtmann 15402177bab5SJohan Hedberg if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) { 15412177bab5SJohan Hedberg u8 mode = 0x01; 154242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 15432177bab5SJohan Hedberg sizeof(mode), &mode); 15442177bab5SJohan Hedberg } else { 15452177bab5SJohan Hedberg struct hci_cp_write_eir cp; 15462177bab5SJohan Hedberg 15472177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 15482177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 15492177bab5SJohan Hedberg 155042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 15512177bab5SJohan Hedberg } 15522177bab5SJohan Hedberg } 15532177bab5SJohan Hedberg 15542177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 155542c6b129SJohan Hedberg hci_setup_inquiry_mode(req); 15562177bab5SJohan Hedberg 15572177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 155842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 15592177bab5SJohan Hedberg 15602177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 15612177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 15622177bab5SJohan Hedberg 15632177bab5SJohan Hedberg cp.page = 0x01; 156442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 156542c6b129SJohan Hedberg sizeof(cp), &cp); 15662177bab5SJohan Hedberg } 15672177bab5SJohan Hedberg 15682177bab5SJohan Hedberg if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) { 15692177bab5SJohan Hedberg u8 enable = 1; 157042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 15712177bab5SJohan Hedberg &enable); 15722177bab5SJohan Hedberg } 15732177bab5SJohan Hedberg } 15742177bab5SJohan Hedberg 157542c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 15762177bab5SJohan Hedberg { 157742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 15782177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 15792177bab5SJohan Hedberg u16 link_policy = 0; 15802177bab5SJohan Hedberg 15812177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 15822177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 15832177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 15842177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 15852177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 15862177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 15872177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 15882177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 15892177bab5SJohan Hedberg 15902177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 159142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 15922177bab5SJohan Hedberg } 15932177bab5SJohan Hedberg 159442c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 15952177bab5SJohan Hedberg { 159642c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 15972177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 15982177bab5SJohan Hedberg 1599c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 1600c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1601c73eee91SJohan Hedberg return; 1602c73eee91SJohan Hedberg 16032177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 16042177bab5SJohan Hedberg 16052177bab5SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) { 16062177bab5SJohan Hedberg cp.le = 0x01; 160732226e4fSMarcel Holtmann cp.simul = 0x00; 16082177bab5SJohan Hedberg } 16092177bab5SJohan Hedberg 16102177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 161142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 16122177bab5SJohan Hedberg &cp); 16132177bab5SJohan Hedberg } 16142177bab5SJohan Hedberg 1615d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 1616d62e6d67SJohan Hedberg { 1617d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 1618d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 1619d62e6d67SJohan Hedberg 1620d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 1621d62e6d67SJohan Hedberg * enable all necessary events for it. 1622d62e6d67SJohan Hedberg */ 162353b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 1624d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 1625d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 1626d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 1627d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 1628d62e6d67SJohan Hedberg } 1629d62e6d67SJohan Hedberg 1630d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 1631d62e6d67SJohan Hedberg * enable all necessary events for it. 1632d62e6d67SJohan Hedberg */ 163353b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 1634d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 1635d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 1636d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 1637d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 1638d62e6d67SJohan Hedberg } 1639d62e6d67SJohan Hedberg 164040c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 1641cd7ca0ecSMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) 164240c59fcbSMarcel Holtmann events[2] |= 0x80; 164340c59fcbSMarcel Holtmann 1644d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 1645d62e6d67SJohan Hedberg } 1646d62e6d67SJohan Hedberg 164742c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 16482177bab5SJohan Hedberg { 164942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 1650d2c5d77fSJohan Hedberg u8 p; 165142c6b129SJohan Hedberg 16520da71f1bSMarcel Holtmann hci_setup_event_mask(req); 16530da71f1bSMarcel Holtmann 1654b8f4e068SGustavo Padovan /* Some Broadcom based Bluetooth controllers do not support the 1655b8f4e068SGustavo Padovan * Delete Stored Link Key command. They are clearly indicating its 1656b8f4e068SGustavo Padovan * absence in the bit mask of supported commands. 1657b8f4e068SGustavo Padovan * 1658b8f4e068SGustavo Padovan * Check the supported commands and only if the the command is marked 1659b8f4e068SGustavo Padovan * as supported send it. If not supported assume that the controller 1660b8f4e068SGustavo Padovan * does not have actual support for stored link keys which makes this 1661b8f4e068SGustavo Padovan * command redundant anyway. 1662f9f462faSMarcel Holtmann * 1663f9f462faSMarcel Holtmann * Some controllers indicate that they support handling deleting 1664f9f462faSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 1665f9f462faSMarcel Holtmann * just disable this command. 1666b8f4e068SGustavo Padovan */ 1667f9f462faSMarcel Holtmann if (hdev->commands[6] & 0x80 && 1668f9f462faSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 166959f45d57SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 167059f45d57SJohan Hedberg 167159f45d57SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 167259f45d57SJohan Hedberg cp.delete_all = 0x01; 167359f45d57SJohan Hedberg hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 167459f45d57SJohan Hedberg sizeof(cp), &cp); 167559f45d57SJohan Hedberg } 167659f45d57SJohan Hedberg 16772177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 167842c6b129SJohan Hedberg hci_setup_link_policy(req); 16792177bab5SJohan Hedberg 16809193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 16819193c6e8SAndre Guedes u8 events[8]; 16829193c6e8SAndre Guedes 16839193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 16844d6c705bSMarcel Holtmann events[0] = 0x0f; 16854d6c705bSMarcel Holtmann 16864d6c705bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) 16874d6c705bSMarcel Holtmann events[0] |= 0x10; /* LE Long Term Key Request */ 1688662bc2e6SAndre Guedes 1689662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 1690662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 1691662bc2e6SAndre Guedes */ 1692662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 1693662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 1694662bc2e6SAndre Guedes * Parameter Request 1695662bc2e6SAndre Guedes */ 1696662bc2e6SAndre Guedes 16979193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 16989193c6e8SAndre Guedes events); 16999193c6e8SAndre Guedes 170015a49ccaSMarcel Holtmann if (hdev->commands[25] & 0x40) { 170115a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 170215a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 170315a49ccaSMarcel Holtmann } 170415a49ccaSMarcel Holtmann 170542c6b129SJohan Hedberg hci_set_le_support(req); 17069193c6e8SAndre Guedes } 1707d2c5d77fSJohan Hedberg 1708d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 1709d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 1710d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 1711d2c5d77fSJohan Hedberg 1712d2c5d77fSJohan Hedberg cp.page = p; 1713d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 1714d2c5d77fSJohan Hedberg sizeof(cp), &cp); 1715d2c5d77fSJohan Hedberg } 17162177bab5SJohan Hedberg } 17172177bab5SJohan Hedberg 17185d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 17195d4e7e8dSJohan Hedberg { 17205d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 17215d4e7e8dSJohan Hedberg 1722d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 1723d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 1724d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 1725d62e6d67SJohan Hedberg 1726109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 1727109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 1728109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 1729109e3191SMarcel Holtmann 1730f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 1731f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 1732f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 1733f4fe73edSMarcel Holtmann 17345d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 173553b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 17365d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 1737a6d0d690SMarcel Holtmann 1738a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 17395afeac14SMarcel Holtmann if ((lmp_sc_capable(hdev) || 1740111902f7SMarcel Holtmann test_bit(HCI_FORCE_SC, &hdev->dbg_flags)) && 1741a6d0d690SMarcel Holtmann test_bit(HCI_SC_ENABLED, &hdev->dev_flags)) { 1742a6d0d690SMarcel Holtmann u8 support = 0x01; 1743a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 1744a6d0d690SMarcel Holtmann sizeof(support), &support); 1745a6d0d690SMarcel Holtmann } 17465d4e7e8dSJohan Hedberg } 17475d4e7e8dSJohan Hedberg 17482177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 17492177bab5SJohan Hedberg { 17502177bab5SJohan Hedberg int err; 17512177bab5SJohan Hedberg 17522177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 17532177bab5SJohan Hedberg if (err < 0) 17542177bab5SJohan Hedberg return err; 17552177bab5SJohan Hedberg 17564b4148e9SMarcel Holtmann /* The Device Under Test (DUT) mode is special and available for 17574b4148e9SMarcel Holtmann * all controller types. So just create it early on. 17584b4148e9SMarcel Holtmann */ 17594b4148e9SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 17604b4148e9SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 17614b4148e9SMarcel Holtmann &dut_mode_fops); 17624b4148e9SMarcel Holtmann } 17634b4148e9SMarcel Holtmann 17642177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 17652177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 17662177bab5SJohan Hedberg * first stage init. 17672177bab5SJohan Hedberg */ 17682177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 17692177bab5SJohan Hedberg return 0; 17702177bab5SJohan Hedberg 17712177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 17722177bab5SJohan Hedberg if (err < 0) 17732177bab5SJohan Hedberg return err; 17742177bab5SJohan Hedberg 17755d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 17765d4e7e8dSJohan Hedberg if (err < 0) 17775d4e7e8dSJohan Hedberg return err; 17785d4e7e8dSJohan Hedberg 1779baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 1780baf27f6eSMarcel Holtmann if (err < 0) 1781baf27f6eSMarcel Holtmann return err; 1782baf27f6eSMarcel Holtmann 1783baf27f6eSMarcel Holtmann /* Only create debugfs entries during the initial setup 1784baf27f6eSMarcel Holtmann * phase and not every time the controller gets powered on. 1785baf27f6eSMarcel Holtmann */ 1786baf27f6eSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 1787baf27f6eSMarcel Holtmann return 0; 1788baf27f6eSMarcel Holtmann 1789dfb826a8SMarcel Holtmann debugfs_create_file("features", 0444, hdev->debugfs, hdev, 1790dfb826a8SMarcel Holtmann &features_fops); 1791ceeb3bc0SMarcel Holtmann debugfs_create_u16("manufacturer", 0444, hdev->debugfs, 1792ceeb3bc0SMarcel Holtmann &hdev->manufacturer); 1793ceeb3bc0SMarcel Holtmann debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver); 1794ceeb3bc0SMarcel Holtmann debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev); 179540f4938aSMarcel Holtmann debugfs_create_file("device_list", 0444, hdev->debugfs, hdev, 179640f4938aSMarcel Holtmann &device_list_fops); 179770afe0b8SMarcel Holtmann debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev, 179870afe0b8SMarcel Holtmann &blacklist_fops); 179947219839SMarcel Holtmann debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 180047219839SMarcel Holtmann 180131ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev, 180231ad1691SAndrzej Kaczmarek &conn_info_min_age_fops); 180331ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev, 180431ad1691SAndrzej Kaczmarek &conn_info_max_age_fops); 180531ad1691SAndrzej Kaczmarek 1806baf27f6eSMarcel Holtmann if (lmp_bredr_capable(hdev)) { 1807baf27f6eSMarcel Holtmann debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, 1808baf27f6eSMarcel Holtmann hdev, &inquiry_cache_fops); 180902d08d15SMarcel Holtmann debugfs_create_file("link_keys", 0400, hdev->debugfs, 181002d08d15SMarcel Holtmann hdev, &link_keys_fops); 1811babdbb3cSMarcel Holtmann debugfs_create_file("dev_class", 0444, hdev->debugfs, 1812babdbb3cSMarcel Holtmann hdev, &dev_class_fops); 1813041000b9SMarcel Holtmann debugfs_create_file("voice_setting", 0444, hdev->debugfs, 1814041000b9SMarcel Holtmann hdev, &voice_setting_fops); 1815baf27f6eSMarcel Holtmann } 1816baf27f6eSMarcel Holtmann 181706f5b778SMarcel Holtmann if (lmp_ssp_capable(hdev)) { 1818ebd1e33bSMarcel Holtmann debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 1819ebd1e33bSMarcel Holtmann hdev, &auto_accept_delay_fops); 18205afeac14SMarcel Holtmann debugfs_create_file("force_sc_support", 0644, hdev->debugfs, 18215afeac14SMarcel Holtmann hdev, &force_sc_support_fops); 1822134c2a89SMarcel Holtmann debugfs_create_file("sc_only_mode", 0444, hdev->debugfs, 1823134c2a89SMarcel Holtmann hdev, &sc_only_mode_fops); 182406f5b778SMarcel Holtmann } 1825ebd1e33bSMarcel Holtmann 18262bfa3531SMarcel Holtmann if (lmp_sniff_capable(hdev)) { 18272bfa3531SMarcel Holtmann debugfs_create_file("idle_timeout", 0644, hdev->debugfs, 18282bfa3531SMarcel Holtmann hdev, &idle_timeout_fops); 18292bfa3531SMarcel Holtmann debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs, 18302bfa3531SMarcel Holtmann hdev, &sniff_min_interval_fops); 18312bfa3531SMarcel Holtmann debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs, 18322bfa3531SMarcel Holtmann hdev, &sniff_max_interval_fops); 18332bfa3531SMarcel Holtmann } 18342bfa3531SMarcel Holtmann 1835d0f729b8SMarcel Holtmann if (lmp_le_capable(hdev)) { 1836ac345813SMarcel Holtmann debugfs_create_file("identity", 0400, hdev->debugfs, 1837ac345813SMarcel Holtmann hdev, &identity_fops); 1838ac345813SMarcel Holtmann debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, 1839ac345813SMarcel Holtmann hdev, &rpa_timeout_fops); 18407a4cd51dSMarcel Holtmann debugfs_create_file("random_address", 0444, hdev->debugfs, 18417a4cd51dSMarcel Holtmann hdev, &random_address_fops); 1842e7b8fc92SMarcel Holtmann debugfs_create_file("static_address", 0444, hdev->debugfs, 1843e7b8fc92SMarcel Holtmann hdev, &static_address_fops); 1844b32bba6cSMarcel Holtmann 1845b32bba6cSMarcel Holtmann /* For controllers with a public address, provide a debug 1846b32bba6cSMarcel Holtmann * option to force the usage of the configured static 1847b32bba6cSMarcel Holtmann * address. By default the public address is used. 1848b32bba6cSMarcel Holtmann */ 1849b32bba6cSMarcel Holtmann if (bacmp(&hdev->bdaddr, BDADDR_ANY)) 1850b32bba6cSMarcel Holtmann debugfs_create_file("force_static_address", 0644, 1851b32bba6cSMarcel Holtmann hdev->debugfs, hdev, 1852b32bba6cSMarcel Holtmann &force_static_address_fops); 1853b32bba6cSMarcel Holtmann 1854b32bba6cSMarcel Holtmann debugfs_create_u8("white_list_size", 0444, hdev->debugfs, 1855b32bba6cSMarcel Holtmann &hdev->le_white_list_size); 1856d2ab0ac1SMarcel Holtmann debugfs_create_file("white_list", 0444, hdev->debugfs, hdev, 1857d2ab0ac1SMarcel Holtmann &white_list_fops); 18583698d704SMarcel Holtmann debugfs_create_file("identity_resolving_keys", 0400, 18593698d704SMarcel Holtmann hdev->debugfs, hdev, 18603698d704SMarcel Holtmann &identity_resolving_keys_fops); 18618f8625cdSMarcel Holtmann debugfs_create_file("long_term_keys", 0400, hdev->debugfs, 18628f8625cdSMarcel Holtmann hdev, &long_term_keys_fops); 18634e70c7e7SMarcel Holtmann debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, 18644e70c7e7SMarcel Holtmann hdev, &conn_min_interval_fops); 18654e70c7e7SMarcel Holtmann debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, 18664e70c7e7SMarcel Holtmann hdev, &conn_max_interval_fops); 1867816a93d1SMarcel Holtmann debugfs_create_file("conn_latency", 0644, hdev->debugfs, 1868816a93d1SMarcel Holtmann hdev, &conn_latency_fops); 1869f1649577SMarcel Holtmann debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, 1870f1649577SMarcel Holtmann hdev, &supervision_timeout_fops); 18713f959d46SMarcel Holtmann debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, 18723f959d46SMarcel Holtmann hdev, &adv_channel_map_fops); 1873729a1051SGeorg Lukas debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, 1874729a1051SGeorg Lukas hdev, &adv_min_interval_fops); 1875729a1051SGeorg Lukas debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, 1876729a1051SGeorg Lukas hdev, &adv_max_interval_fops); 1877b9a7a61eSLukasz Rymanowski debugfs_create_u16("discov_interleaved_timeout", 0644, 1878b9a7a61eSLukasz Rymanowski hdev->debugfs, 1879b9a7a61eSLukasz Rymanowski &hdev->discov_interleaved_timeout); 188054506918SJohan Hedberg 1881711eafe3SJohan Hedberg smp_register(hdev); 1882d0f729b8SMarcel Holtmann } 1883e7b8fc92SMarcel Holtmann 1884baf27f6eSMarcel Holtmann return 0; 18852177bab5SJohan Hedberg } 18862177bab5SJohan Hedberg 18870ebca7d6SMarcel Holtmann static void hci_init0_req(struct hci_request *req, unsigned long opt) 18880ebca7d6SMarcel Holtmann { 18890ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 18900ebca7d6SMarcel Holtmann 18910ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 18920ebca7d6SMarcel Holtmann 18930ebca7d6SMarcel Holtmann /* Reset */ 18940ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 18950ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 18960ebca7d6SMarcel Holtmann 18970ebca7d6SMarcel Holtmann /* Read Local Version */ 18980ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 18990ebca7d6SMarcel Holtmann 19000ebca7d6SMarcel Holtmann /* Read BD Address */ 19010ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 19020ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 19030ebca7d6SMarcel Holtmann } 19040ebca7d6SMarcel Holtmann 19050ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 19060ebca7d6SMarcel Holtmann { 19070ebca7d6SMarcel Holtmann int err; 19080ebca7d6SMarcel Holtmann 1909cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 1910cc78b44bSMarcel Holtmann return 0; 1911cc78b44bSMarcel Holtmann 19120ebca7d6SMarcel Holtmann err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT); 19130ebca7d6SMarcel Holtmann if (err < 0) 19140ebca7d6SMarcel Holtmann return err; 19150ebca7d6SMarcel Holtmann 19160ebca7d6SMarcel Holtmann return 0; 19170ebca7d6SMarcel Holtmann } 19180ebca7d6SMarcel Holtmann 191942c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 19201da177e4SLinus Torvalds { 19211da177e4SLinus Torvalds __u8 scan = opt; 19221da177e4SLinus Torvalds 192342c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 19241da177e4SLinus Torvalds 19251da177e4SLinus Torvalds /* Inquiry and Page scans */ 192642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 19271da177e4SLinus Torvalds } 19281da177e4SLinus Torvalds 192942c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 19301da177e4SLinus Torvalds { 19311da177e4SLinus Torvalds __u8 auth = opt; 19321da177e4SLinus Torvalds 193342c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 19341da177e4SLinus Torvalds 19351da177e4SLinus Torvalds /* Authentication */ 193642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 19371da177e4SLinus Torvalds } 19381da177e4SLinus Torvalds 193942c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 19401da177e4SLinus Torvalds { 19411da177e4SLinus Torvalds __u8 encrypt = opt; 19421da177e4SLinus Torvalds 194342c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 19441da177e4SLinus Torvalds 1945e4e8e37cSMarcel Holtmann /* Encryption */ 194642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 19471da177e4SLinus Torvalds } 19481da177e4SLinus Torvalds 194942c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1950e4e8e37cSMarcel Holtmann { 1951e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1952e4e8e37cSMarcel Holtmann 195342c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1954e4e8e37cSMarcel Holtmann 1955e4e8e37cSMarcel Holtmann /* Default link policy */ 195642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1957e4e8e37cSMarcel Holtmann } 1958e4e8e37cSMarcel Holtmann 19591da177e4SLinus Torvalds /* Get HCI device by index. 19601da177e4SLinus Torvalds * Device is held on return. */ 19611da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 19621da177e4SLinus Torvalds { 19638035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 19641da177e4SLinus Torvalds 19651da177e4SLinus Torvalds BT_DBG("%d", index); 19661da177e4SLinus Torvalds 19671da177e4SLinus Torvalds if (index < 0) 19681da177e4SLinus Torvalds return NULL; 19691da177e4SLinus Torvalds 19701da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 19718035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 19721da177e4SLinus Torvalds if (d->id == index) { 19731da177e4SLinus Torvalds hdev = hci_dev_hold(d); 19741da177e4SLinus Torvalds break; 19751da177e4SLinus Torvalds } 19761da177e4SLinus Torvalds } 19771da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 19781da177e4SLinus Torvalds return hdev; 19791da177e4SLinus Torvalds } 19801da177e4SLinus Torvalds 19811da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1982ff9ef578SJohan Hedberg 198330dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 198430dc78e1SJohan Hedberg { 198530dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 198630dc78e1SJohan Hedberg 19876fbe195dSAndre Guedes switch (discov->state) { 1988343f935bSAndre Guedes case DISCOVERY_FINDING: 19896fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 199030dc78e1SJohan Hedberg return true; 199130dc78e1SJohan Hedberg 19926fbe195dSAndre Guedes default: 199330dc78e1SJohan Hedberg return false; 199430dc78e1SJohan Hedberg } 19956fbe195dSAndre Guedes } 199630dc78e1SJohan Hedberg 1997ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1998ff9ef578SJohan Hedberg { 1999bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 2000bb3e0a33SJohan Hedberg 2001ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 2002ff9ef578SJohan Hedberg 2003bb3e0a33SJohan Hedberg if (old_state == state) 2004ff9ef578SJohan Hedberg return; 2005ff9ef578SJohan Hedberg 2006bb3e0a33SJohan Hedberg hdev->discovery.state = state; 2007bb3e0a33SJohan Hedberg 2008ff9ef578SJohan Hedberg switch (state) { 2009ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 2010c54c3860SAndre Guedes hci_update_background_scan(hdev); 2011c54c3860SAndre Guedes 2012bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 2013ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 2014ff9ef578SJohan Hedberg break; 2015ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 2016ff9ef578SJohan Hedberg break; 2017343f935bSAndre Guedes case DISCOVERY_FINDING: 2018ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 2019ff9ef578SJohan Hedberg break; 202030dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 202130dc78e1SJohan Hedberg break; 2022ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 2023ff9ef578SJohan Hedberg break; 2024ff9ef578SJohan Hedberg } 2025ff9ef578SJohan Hedberg } 2026ff9ef578SJohan Hedberg 20271f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 20281da177e4SLinus Torvalds { 202930883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2030b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 20311da177e4SLinus Torvalds 2032561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 2033561aafbcSJohan Hedberg list_del(&p->all); 2034b57c1a56SJohan Hedberg kfree(p); 20351da177e4SLinus Torvalds } 2036561aafbcSJohan Hedberg 2037561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 2038561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 20391da177e4SLinus Torvalds } 20401da177e4SLinus Torvalds 2041a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 2042a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 20431da177e4SLinus Torvalds { 204430883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 20451da177e4SLinus Torvalds struct inquiry_entry *e; 20461da177e4SLinus Torvalds 20476ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 20481da177e4SLinus Torvalds 2049561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 20501da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 20511da177e4SLinus Torvalds return e; 20521da177e4SLinus Torvalds } 20531da177e4SLinus Torvalds 2054b57c1a56SJohan Hedberg return NULL; 2055b57c1a56SJohan Hedberg } 2056b57c1a56SJohan Hedberg 2057561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 2058561aafbcSJohan Hedberg bdaddr_t *bdaddr) 2059561aafbcSJohan Hedberg { 206030883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2061561aafbcSJohan Hedberg struct inquiry_entry *e; 2062561aafbcSJohan Hedberg 20636ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 2064561aafbcSJohan Hedberg 2065561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 2066561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 2067561aafbcSJohan Hedberg return e; 2068561aafbcSJohan Hedberg } 2069561aafbcSJohan Hedberg 2070561aafbcSJohan Hedberg return NULL; 2071561aafbcSJohan Hedberg } 2072561aafbcSJohan Hedberg 207330dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 207430dc78e1SJohan Hedberg bdaddr_t *bdaddr, 207530dc78e1SJohan Hedberg int state) 207630dc78e1SJohan Hedberg { 207730dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 207830dc78e1SJohan Hedberg struct inquiry_entry *e; 207930dc78e1SJohan Hedberg 20806ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 208130dc78e1SJohan Hedberg 208230dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 208330dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 208430dc78e1SJohan Hedberg return e; 208530dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 208630dc78e1SJohan Hedberg return e; 208730dc78e1SJohan Hedberg } 208830dc78e1SJohan Hedberg 208930dc78e1SJohan Hedberg return NULL; 209030dc78e1SJohan Hedberg } 209130dc78e1SJohan Hedberg 2092a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 2093a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 2094a3d4e20aSJohan Hedberg { 2095a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2096a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 2097a3d4e20aSJohan Hedberg struct inquiry_entry *p; 2098a3d4e20aSJohan Hedberg 2099a3d4e20aSJohan Hedberg list_del(&ie->list); 2100a3d4e20aSJohan Hedberg 2101a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 2102a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 2103a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 2104a3d4e20aSJohan Hedberg break; 2105a3d4e20aSJohan Hedberg pos = &p->list; 2106a3d4e20aSJohan Hedberg } 2107a3d4e20aSJohan Hedberg 2108a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 2109a3d4e20aSJohan Hedberg } 2110a3d4e20aSJohan Hedberg 2111af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 2112af58925cSMarcel Holtmann bool name_known) 21131da177e4SLinus Torvalds { 211430883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 211570f23020SAndrei Emeltchenko struct inquiry_entry *ie; 2116af58925cSMarcel Holtmann u32 flags = 0; 21171da177e4SLinus Torvalds 21186ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 21191da177e4SLinus Torvalds 21202b2fec4dSSzymon Janc hci_remove_remote_oob_data(hdev, &data->bdaddr); 21212b2fec4dSSzymon Janc 2122af58925cSMarcel Holtmann if (!data->ssp_mode) 2123af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 2124388fc8faSJohan Hedberg 212570f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 2126a3d4e20aSJohan Hedberg if (ie) { 2127af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 2128af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 2129388fc8faSJohan Hedberg 2130a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 2131a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 2132a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 2133a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 2134a3d4e20aSJohan Hedberg } 2135a3d4e20aSJohan Hedberg 2136561aafbcSJohan Hedberg goto update; 2137a3d4e20aSJohan Hedberg } 2138561aafbcSJohan Hedberg 21391da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 214027f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 2141af58925cSMarcel Holtmann if (!ie) { 2142af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 2143af58925cSMarcel Holtmann goto done; 2144af58925cSMarcel Holtmann } 214570f23020SAndrei Emeltchenko 2146561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 2147561aafbcSJohan Hedberg 2148561aafbcSJohan Hedberg if (name_known) { 2149561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2150561aafbcSJohan Hedberg } else { 2151561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 2152561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 2153561aafbcSJohan Hedberg } 2154561aafbcSJohan Hedberg 2155561aafbcSJohan Hedberg update: 2156561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 2157561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 2158561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2159561aafbcSJohan Hedberg list_del(&ie->list); 21601da177e4SLinus Torvalds } 21611da177e4SLinus Torvalds 216270f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 216370f23020SAndrei Emeltchenko ie->timestamp = jiffies; 21641da177e4SLinus Torvalds cache->timestamp = jiffies; 21653175405bSJohan Hedberg 21663175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 2167af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 21683175405bSJohan Hedberg 2169af58925cSMarcel Holtmann done: 2170af58925cSMarcel Holtmann return flags; 21711da177e4SLinus Torvalds } 21721da177e4SLinus Torvalds 21731da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 21741da177e4SLinus Torvalds { 217530883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 21761da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 21771da177e4SLinus Torvalds struct inquiry_entry *e; 21781da177e4SLinus Torvalds int copied = 0; 21791da177e4SLinus Torvalds 2180561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 21811da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 2182b57c1a56SJohan Hedberg 2183b57c1a56SJohan Hedberg if (copied >= num) 2184b57c1a56SJohan Hedberg break; 2185b57c1a56SJohan Hedberg 21861da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 21871da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 21881da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 21891da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 21901da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 21911da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 2192b57c1a56SJohan Hedberg 21931da177e4SLinus Torvalds info++; 2194b57c1a56SJohan Hedberg copied++; 21951da177e4SLinus Torvalds } 21961da177e4SLinus Torvalds 21971da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 21981da177e4SLinus Torvalds return copied; 21991da177e4SLinus Torvalds } 22001da177e4SLinus Torvalds 220142c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 22021da177e4SLinus Torvalds { 22031da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 220442c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 22051da177e4SLinus Torvalds struct hci_cp_inquiry cp; 22061da177e4SLinus Torvalds 22071da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 22081da177e4SLinus Torvalds 22091da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 22101da177e4SLinus Torvalds return; 22111da177e4SLinus Torvalds 22121da177e4SLinus Torvalds /* Start Inquiry */ 22131da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 22141da177e4SLinus Torvalds cp.length = ir->length; 22151da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 221642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 22171da177e4SLinus Torvalds } 22181da177e4SLinus Torvalds 22191da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 22201da177e4SLinus Torvalds { 22211da177e4SLinus Torvalds __u8 __user *ptr = arg; 22221da177e4SLinus Torvalds struct hci_inquiry_req ir; 22231da177e4SLinus Torvalds struct hci_dev *hdev; 22241da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 22251da177e4SLinus Torvalds long timeo; 22261da177e4SLinus Torvalds __u8 *buf; 22271da177e4SLinus Torvalds 22281da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 22291da177e4SLinus Torvalds return -EFAULT; 22301da177e4SLinus Torvalds 22315a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 22325a08ecceSAndrei Emeltchenko if (!hdev) 22331da177e4SLinus Torvalds return -ENODEV; 22341da177e4SLinus Torvalds 22350736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 22360736cfa8SMarcel Holtmann err = -EBUSY; 22370736cfa8SMarcel Holtmann goto done; 22380736cfa8SMarcel Holtmann } 22390736cfa8SMarcel Holtmann 22404a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2241fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2242fee746b0SMarcel Holtmann goto done; 2243fee746b0SMarcel Holtmann } 2244fee746b0SMarcel Holtmann 22455b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 22465b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 22475b69bef5SMarcel Holtmann goto done; 22485b69bef5SMarcel Holtmann } 22495b69bef5SMarcel Holtmann 225056f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 225156f87901SJohan Hedberg err = -EOPNOTSUPP; 225256f87901SJohan Hedberg goto done; 225356f87901SJohan Hedberg } 225456f87901SJohan Hedberg 225509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 22561da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 2257a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 22581f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 22591da177e4SLinus Torvalds do_inquiry = 1; 22601da177e4SLinus Torvalds } 226109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 22621da177e4SLinus Torvalds 226304837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 226470f23020SAndrei Emeltchenko 226570f23020SAndrei Emeltchenko if (do_inquiry) { 226601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 226701178cd4SJohan Hedberg timeo); 226870f23020SAndrei Emeltchenko if (err < 0) 22691da177e4SLinus Torvalds goto done; 22703e13fa1eSAndre Guedes 22713e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 22723e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 22733e13fa1eSAndre Guedes */ 227474316201SNeilBrown if (wait_on_bit(&hdev->flags, HCI_INQUIRY, 22753e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 22763e13fa1eSAndre Guedes return -EINTR; 227770f23020SAndrei Emeltchenko } 22781da177e4SLinus Torvalds 22798fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 22808fc9ced3SGustavo Padovan * 255 entries 22818fc9ced3SGustavo Padovan */ 22821da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 22831da177e4SLinus Torvalds 22841da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 22851da177e4SLinus Torvalds * copy it to the user space. 22861da177e4SLinus Torvalds */ 228770f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 228870f23020SAndrei Emeltchenko if (!buf) { 22891da177e4SLinus Torvalds err = -ENOMEM; 22901da177e4SLinus Torvalds goto done; 22911da177e4SLinus Torvalds } 22921da177e4SLinus Torvalds 229309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 22941da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 229509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 22961da177e4SLinus Torvalds 22971da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 22981da177e4SLinus Torvalds 22991da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 23001da177e4SLinus Torvalds ptr += sizeof(ir); 23011da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 23021da177e4SLinus Torvalds ir.num_rsp)) 23031da177e4SLinus Torvalds err = -EFAULT; 23041da177e4SLinus Torvalds } else 23051da177e4SLinus Torvalds err = -EFAULT; 23061da177e4SLinus Torvalds 23071da177e4SLinus Torvalds kfree(buf); 23081da177e4SLinus Torvalds 23091da177e4SLinus Torvalds done: 23101da177e4SLinus Torvalds hci_dev_put(hdev); 23111da177e4SLinus Torvalds return err; 23121da177e4SLinus Torvalds } 23131da177e4SLinus Torvalds 2314cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 23151da177e4SLinus Torvalds { 23161da177e4SLinus Torvalds int ret = 0; 23171da177e4SLinus Torvalds 23181da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 23191da177e4SLinus Torvalds 23201da177e4SLinus Torvalds hci_req_lock(hdev); 23211da177e4SLinus Torvalds 232294324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 232394324962SJohan Hovold ret = -ENODEV; 232494324962SJohan Hovold goto done; 232594324962SJohan Hovold } 232694324962SJohan Hovold 2327d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2328d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 2329a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 2330a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 2331bf543036SJohan Hedberg */ 2332a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 2333611b30f7SMarcel Holtmann ret = -ERFKILL; 2334611b30f7SMarcel Holtmann goto done; 2335611b30f7SMarcel Holtmann } 2336611b30f7SMarcel Holtmann 2337a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 2338a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 2339a5c8f270SMarcel Holtmann * be able to determine if there is a public address 2340a5c8f270SMarcel Holtmann * or not. 2341a5c8f270SMarcel Holtmann * 2342c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 2343c6beca0eSMarcel Holtmann * if a public address or static random address is 2344c6beca0eSMarcel Holtmann * available. 2345c6beca0eSMarcel Holtmann * 2346a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 2347a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 2348a5c8f270SMarcel Holtmann */ 2349c6beca0eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 2350c6beca0eSMarcel Holtmann hdev->dev_type == HCI_BREDR && 2351a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2352a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 2353a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 2354a5c8f270SMarcel Holtmann goto done; 2355a5c8f270SMarcel Holtmann } 2356a5c8f270SMarcel Holtmann } 2357a5c8f270SMarcel Holtmann 23581da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 23591da177e4SLinus Torvalds ret = -EALREADY; 23601da177e4SLinus Torvalds goto done; 23611da177e4SLinus Torvalds } 23621da177e4SLinus Torvalds 23631da177e4SLinus Torvalds if (hdev->open(hdev)) { 23641da177e4SLinus Torvalds ret = -EIO; 23651da177e4SLinus Torvalds goto done; 23661da177e4SLinus Torvalds } 23671da177e4SLinus Torvalds 23681da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 23691da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 2370f41c70c4SMarcel Holtmann 2371af202f84SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 2372af202f84SMarcel Holtmann if (hdev->setup) 2373f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 2374f41c70c4SMarcel Holtmann 2375af202f84SMarcel Holtmann /* The transport driver can set these quirks before 2376af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 2377af202f84SMarcel Holtmann * 2378af202f84SMarcel Holtmann * In case any of them is set, the controller has to 2379af202f84SMarcel Holtmann * start up as unconfigured. 2380af202f84SMarcel Holtmann */ 2381eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 2382eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 238389bc22d2SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 2384f41c70c4SMarcel Holtmann 23850ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 23860ebca7d6SMarcel Holtmann * read at least the version information provided by 23870ebca7d6SMarcel Holtmann * the Read Local Version Information command. 23880ebca7d6SMarcel Holtmann * 23890ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 23900ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 23910ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 23920ebca7d6SMarcel Holtmann */ 23930ebca7d6SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 23940ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 239589bc22d2SMarcel Holtmann } 239689bc22d2SMarcel Holtmann 23979713c17bSMarcel Holtmann if (test_bit(HCI_CONFIG, &hdev->dev_flags)) { 23989713c17bSMarcel Holtmann /* If public address change is configured, ensure that 23999713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 24009713c17bSMarcel Holtmann * support changing the public address, fail the power 24019713c17bSMarcel Holtmann * on procedure. 240224c457e2SMarcel Holtmann */ 24039713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 24049713c17bSMarcel Holtmann hdev->set_bdaddr) 240524c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 240624c457e2SMarcel Holtmann else 240724c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 240824c457e2SMarcel Holtmann } 240924c457e2SMarcel Holtmann 2410f41c70c4SMarcel Holtmann if (!ret) { 24114a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 24120736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 24132177bab5SJohan Hedberg ret = __hci_init(hdev); 24141da177e4SLinus Torvalds } 24151da177e4SLinus Torvalds 2416f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 2417f41c70c4SMarcel Holtmann 24181da177e4SLinus Torvalds if (!ret) { 24191da177e4SLinus Torvalds hci_dev_hold(hdev); 2420d6bfd59cSJohan Hedberg set_bit(HCI_RPA_EXPIRED, &hdev->dev_flags); 24211da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 24221da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 2423bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2424d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags) && 24254a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 24260736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 24271514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 242809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2429744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 243009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 243156e5cb86SJohan Hedberg } 24321da177e4SLinus Torvalds } else { 24331da177e4SLinus Torvalds /* Init failed, cleanup */ 24343eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2435c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 2436b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 24371da177e4SLinus Torvalds 24381da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 24391da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 24401da177e4SLinus Torvalds 24411da177e4SLinus Torvalds if (hdev->flush) 24421da177e4SLinus Torvalds hdev->flush(hdev); 24431da177e4SLinus Torvalds 24441da177e4SLinus Torvalds if (hdev->sent_cmd) { 24451da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 24461da177e4SLinus Torvalds hdev->sent_cmd = NULL; 24471da177e4SLinus Torvalds } 24481da177e4SLinus Torvalds 24491da177e4SLinus Torvalds hdev->close(hdev); 2450fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 24511da177e4SLinus Torvalds } 24521da177e4SLinus Torvalds 24531da177e4SLinus Torvalds done: 24541da177e4SLinus Torvalds hci_req_unlock(hdev); 24551da177e4SLinus Torvalds return ret; 24561da177e4SLinus Torvalds } 24571da177e4SLinus Torvalds 2458cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 2459cbed0ca1SJohan Hedberg 2460cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 2461cbed0ca1SJohan Hedberg { 2462cbed0ca1SJohan Hedberg struct hci_dev *hdev; 2463cbed0ca1SJohan Hedberg int err; 2464cbed0ca1SJohan Hedberg 2465cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 2466cbed0ca1SJohan Hedberg if (!hdev) 2467cbed0ca1SJohan Hedberg return -ENODEV; 2468cbed0ca1SJohan Hedberg 24694a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 2470fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 2471fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 2472fee746b0SMarcel Holtmann * possible. 2473fee746b0SMarcel Holtmann * 2474fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 2475fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 2476fee746b0SMarcel Holtmann * open the device. 2477fee746b0SMarcel Holtmann */ 24784a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 2479fee746b0SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 2480fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2481fee746b0SMarcel Holtmann goto done; 2482fee746b0SMarcel Holtmann } 2483fee746b0SMarcel Holtmann 2484e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 2485e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 2486e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 2487e1d08f40SJohan Hedberg * completed. 2488e1d08f40SJohan Hedberg */ 2489e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 2490e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 2491e1d08f40SJohan Hedberg 2492a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 2493a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 2494a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 2495a5c8f270SMarcel Holtmann */ 2496e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 2497e1d08f40SJohan Hedberg 249812aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 2499b6ae8457SJohan Hedberg * are brought up using legacy ioctl, set the HCI_BONDABLE bit 250012aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 250112aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 250212aa4f0aSMarcel Holtmann * to explicitly enable it. 250312aa4f0aSMarcel Holtmann */ 250412aa4f0aSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 250512aa4f0aSMarcel Holtmann !test_bit(HCI_MGMT, &hdev->dev_flags)) 2506b6ae8457SJohan Hedberg set_bit(HCI_BONDABLE, &hdev->dev_flags); 250712aa4f0aSMarcel Holtmann 2508cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 2509cbed0ca1SJohan Hedberg 2510fee746b0SMarcel Holtmann done: 2511cbed0ca1SJohan Hedberg hci_dev_put(hdev); 2512cbed0ca1SJohan Hedberg return err; 2513cbed0ca1SJohan Hedberg } 2514cbed0ca1SJohan Hedberg 2515d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 2516d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 2517d7347f3cSJohan Hedberg { 2518d7347f3cSJohan Hedberg struct hci_conn_params *p; 2519d7347f3cSJohan Hedberg 2520f161dd41SJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) { 2521f161dd41SJohan Hedberg if (p->conn) { 2522f161dd41SJohan Hedberg hci_conn_drop(p->conn); 2523f8aaf9b6SJohan Hedberg hci_conn_put(p->conn); 2524f161dd41SJohan Hedberg p->conn = NULL; 2525f161dd41SJohan Hedberg } 2526d7347f3cSJohan Hedberg list_del_init(&p->action); 2527f161dd41SJohan Hedberg } 2528d7347f3cSJohan Hedberg 2529d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 2530d7347f3cSJohan Hedberg } 2531d7347f3cSJohan Hedberg 25321da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 25331da177e4SLinus Torvalds { 25341da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 25351da177e4SLinus Torvalds 253678c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 253778c04c0bSVinicius Costa Gomes 25381da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 25391da177e4SLinus Torvalds hci_req_lock(hdev); 25401da177e4SLinus Torvalds 25411da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 254265cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 25431da177e4SLinus Torvalds hci_req_unlock(hdev); 25441da177e4SLinus Torvalds return 0; 25451da177e4SLinus Torvalds } 25461da177e4SLinus Torvalds 25473eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 25483eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2549b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 25501da177e4SLinus Torvalds 255116ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 2552e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 255316ab91abSJohan Hedberg hdev->discov_timeout = 0; 25545e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 2555310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 255616ab91abSJohan Hedberg } 255716ab91abSJohan Hedberg 2558a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 25597d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 25607d78525dSJohan Hedberg 25617ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 25624518bb0fSJohan Hedberg 25634518bb0fSJohan Hedberg if (test_bit(HCI_MGMT, &hdev->dev_flags)) 2564d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 25657ba8b4beSAndre Guedes 256676727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 256776727c02SJohan Hedberg * ensuring the workqueue is empty up front. 256876727c02SJohan Hedberg */ 256976727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 257076727c02SJohan Hedberg 257109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 25721f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 2573d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 2574f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 257509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 25761da177e4SLinus Torvalds 25771da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 25781da177e4SLinus Torvalds 25791da177e4SLinus Torvalds if (hdev->flush) 25801da177e4SLinus Torvalds hdev->flush(hdev); 25811da177e4SLinus Torvalds 25821da177e4SLinus Torvalds /* Reset device */ 25831da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 25841da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 25854a964404SMarcel Holtmann if (!test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 25864a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 2587a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 25881da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 258901178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 25901da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 25911da177e4SLinus Torvalds } 25921da177e4SLinus Torvalds 2593c347b765SGustavo F. Padovan /* flush cmd work */ 2594c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 25951da177e4SLinus Torvalds 25961da177e4SLinus Torvalds /* Drop queues */ 25971da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 25981da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 25991da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 26001da177e4SLinus Torvalds 26011da177e4SLinus Torvalds /* Drop last sent command */ 26021da177e4SLinus Torvalds if (hdev->sent_cmd) { 260365cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 26041da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 26051da177e4SLinus Torvalds hdev->sent_cmd = NULL; 26061da177e4SLinus Torvalds } 26071da177e4SLinus Torvalds 2608b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 2609b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 2610b6ddb638SJohan Hedberg 26111da177e4SLinus Torvalds /* After this point our queues are empty 26121da177e4SLinus Torvalds * and no tasks are scheduled. */ 26131da177e4SLinus Torvalds hdev->close(hdev); 26141da177e4SLinus Torvalds 261535b973c9SJohan Hedberg /* Clear flags */ 2616fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 261735b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 261835b973c9SJohan Hedberg 261993c311a0SMarcel Holtmann if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 262093c311a0SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 262109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2622744cf19eSJohan Hedberg mgmt_powered(hdev, 0); 262309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 26248ee56540SMarcel Holtmann } 262593c311a0SMarcel Holtmann } 26265add6af8SJohan Hedberg 2627ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 2628536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 2629ced5c338SAndrei Emeltchenko 2630e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 263109b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 26327a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 2633e59fda8dSJohan Hedberg 26341da177e4SLinus Torvalds hci_req_unlock(hdev); 26351da177e4SLinus Torvalds 26361da177e4SLinus Torvalds hci_dev_put(hdev); 26371da177e4SLinus Torvalds return 0; 26381da177e4SLinus Torvalds } 26391da177e4SLinus Torvalds 26401da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 26411da177e4SLinus Torvalds { 26421da177e4SLinus Torvalds struct hci_dev *hdev; 26431da177e4SLinus Torvalds int err; 26441da177e4SLinus Torvalds 264570f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 264670f23020SAndrei Emeltchenko if (!hdev) 26471da177e4SLinus Torvalds return -ENODEV; 26488ee56540SMarcel Holtmann 26490736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 26500736cfa8SMarcel Holtmann err = -EBUSY; 26510736cfa8SMarcel Holtmann goto done; 26520736cfa8SMarcel Holtmann } 26530736cfa8SMarcel Holtmann 26548ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 26558ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 26568ee56540SMarcel Holtmann 26571da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 26588ee56540SMarcel Holtmann 26590736cfa8SMarcel Holtmann done: 26601da177e4SLinus Torvalds hci_dev_put(hdev); 26611da177e4SLinus Torvalds return err; 26621da177e4SLinus Torvalds } 26631da177e4SLinus Torvalds 26641da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 26651da177e4SLinus Torvalds { 26661da177e4SLinus Torvalds struct hci_dev *hdev; 26671da177e4SLinus Torvalds int ret = 0; 26681da177e4SLinus Torvalds 266970f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 267070f23020SAndrei Emeltchenko if (!hdev) 26711da177e4SLinus Torvalds return -ENODEV; 26721da177e4SLinus Torvalds 26731da177e4SLinus Torvalds hci_req_lock(hdev); 26741da177e4SLinus Torvalds 2675808a049eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 2676808a049eSMarcel Holtmann ret = -ENETDOWN; 26771da177e4SLinus Torvalds goto done; 2678808a049eSMarcel Holtmann } 26791da177e4SLinus Torvalds 26800736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 26810736cfa8SMarcel Holtmann ret = -EBUSY; 26820736cfa8SMarcel Holtmann goto done; 26830736cfa8SMarcel Holtmann } 26840736cfa8SMarcel Holtmann 26854a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2686fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2687fee746b0SMarcel Holtmann goto done; 2688fee746b0SMarcel Holtmann } 2689fee746b0SMarcel Holtmann 26901da177e4SLinus Torvalds /* Drop queues */ 26911da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 26921da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 26931da177e4SLinus Torvalds 269476727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 269576727c02SJohan Hedberg * ensuring the workqueue is empty up front. 269676727c02SJohan Hedberg */ 269776727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 269876727c02SJohan Hedberg 269909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 27001f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 27011da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 270209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 27031da177e4SLinus Torvalds 27041da177e4SLinus Torvalds if (hdev->flush) 27051da177e4SLinus Torvalds hdev->flush(hdev); 27061da177e4SLinus Torvalds 27071da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 27086ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 27091da177e4SLinus Torvalds 271001178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 27111da177e4SLinus Torvalds 27121da177e4SLinus Torvalds done: 27131da177e4SLinus Torvalds hci_req_unlock(hdev); 27141da177e4SLinus Torvalds hci_dev_put(hdev); 27151da177e4SLinus Torvalds return ret; 27161da177e4SLinus Torvalds } 27171da177e4SLinus Torvalds 27181da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 27191da177e4SLinus Torvalds { 27201da177e4SLinus Torvalds struct hci_dev *hdev; 27211da177e4SLinus Torvalds int ret = 0; 27221da177e4SLinus Torvalds 272370f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 272470f23020SAndrei Emeltchenko if (!hdev) 27251da177e4SLinus Torvalds return -ENODEV; 27261da177e4SLinus Torvalds 27270736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 27280736cfa8SMarcel Holtmann ret = -EBUSY; 27290736cfa8SMarcel Holtmann goto done; 27300736cfa8SMarcel Holtmann } 27310736cfa8SMarcel Holtmann 27324a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2733fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2734fee746b0SMarcel Holtmann goto done; 2735fee746b0SMarcel Holtmann } 2736fee746b0SMarcel Holtmann 27371da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 27381da177e4SLinus Torvalds 27390736cfa8SMarcel Holtmann done: 27401da177e4SLinus Torvalds hci_dev_put(hdev); 27411da177e4SLinus Torvalds return ret; 27421da177e4SLinus Torvalds } 27431da177e4SLinus Torvalds 2744123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 2745123abc08SJohan Hedberg { 2746bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 2747123abc08SJohan Hedberg 2748123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 2749123abc08SJohan Hedberg 2750123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 2751123abc08SJohan Hedberg conn_changed = !test_and_set_bit(HCI_CONNECTABLE, 2752123abc08SJohan Hedberg &hdev->dev_flags); 2753123abc08SJohan Hedberg else 2754123abc08SJohan Hedberg conn_changed = test_and_clear_bit(HCI_CONNECTABLE, 2755123abc08SJohan Hedberg &hdev->dev_flags); 2756123abc08SJohan Hedberg 2757bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 2758bc6d2d04SJohan Hedberg discov_changed = !test_and_set_bit(HCI_DISCOVERABLE, 2759bc6d2d04SJohan Hedberg &hdev->dev_flags); 2760bc6d2d04SJohan Hedberg } else { 2761bc6d2d04SJohan Hedberg clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 2762bc6d2d04SJohan Hedberg discov_changed = test_and_clear_bit(HCI_DISCOVERABLE, 2763bc6d2d04SJohan Hedberg &hdev->dev_flags); 2764bc6d2d04SJohan Hedberg } 2765bc6d2d04SJohan Hedberg 2766123abc08SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 2767123abc08SJohan Hedberg return; 2768123abc08SJohan Hedberg 2769bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 2770bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 2771bc6d2d04SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 2772bc6d2d04SJohan Hedberg 2773bc6d2d04SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 2774bc6d2d04SJohan Hedberg mgmt_update_adv_data(hdev); 2775bc6d2d04SJohan Hedberg 2776123abc08SJohan Hedberg mgmt_new_settings(hdev); 2777123abc08SJohan Hedberg } 2778bc6d2d04SJohan Hedberg } 2779123abc08SJohan Hedberg 27801da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 27811da177e4SLinus Torvalds { 27821da177e4SLinus Torvalds struct hci_dev *hdev; 27831da177e4SLinus Torvalds struct hci_dev_req dr; 27841da177e4SLinus Torvalds int err = 0; 27851da177e4SLinus Torvalds 27861da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 27871da177e4SLinus Torvalds return -EFAULT; 27881da177e4SLinus Torvalds 278970f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 279070f23020SAndrei Emeltchenko if (!hdev) 27911da177e4SLinus Torvalds return -ENODEV; 27921da177e4SLinus Torvalds 27930736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 27940736cfa8SMarcel Holtmann err = -EBUSY; 27950736cfa8SMarcel Holtmann goto done; 27960736cfa8SMarcel Holtmann } 27970736cfa8SMarcel Holtmann 27984a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2799fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2800fee746b0SMarcel Holtmann goto done; 2801fee746b0SMarcel Holtmann } 2802fee746b0SMarcel Holtmann 28035b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 28045b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 28055b69bef5SMarcel Holtmann goto done; 28065b69bef5SMarcel Holtmann } 28075b69bef5SMarcel Holtmann 280856f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 280956f87901SJohan Hedberg err = -EOPNOTSUPP; 281056f87901SJohan Hedberg goto done; 281156f87901SJohan Hedberg } 281256f87901SJohan Hedberg 28131da177e4SLinus Torvalds switch (cmd) { 28141da177e4SLinus Torvalds case HCISETAUTH: 281501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 28165f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 28171da177e4SLinus Torvalds break; 28181da177e4SLinus Torvalds 28191da177e4SLinus Torvalds case HCISETENCRYPT: 28201da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 28211da177e4SLinus Torvalds err = -EOPNOTSUPP; 28221da177e4SLinus Torvalds break; 28231da177e4SLinus Torvalds } 28241da177e4SLinus Torvalds 28251da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 28261da177e4SLinus Torvalds /* Auth must be enabled first */ 282701178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 28285f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 28291da177e4SLinus Torvalds if (err) 28301da177e4SLinus Torvalds break; 28311da177e4SLinus Torvalds } 28321da177e4SLinus Torvalds 283301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 28345f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 28351da177e4SLinus Torvalds break; 28361da177e4SLinus Torvalds 28371da177e4SLinus Torvalds case HCISETSCAN: 283801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 28395f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 284091a668b0SJohan Hedberg 2841bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 2842bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 284391a668b0SJohan Hedberg */ 2844123abc08SJohan Hedberg if (!err) 2845123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 28461da177e4SLinus Torvalds break; 28471da177e4SLinus Torvalds 28481da177e4SLinus Torvalds case HCISETLINKPOL: 284901178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 28505f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 28511da177e4SLinus Torvalds break; 28521da177e4SLinus Torvalds 28531da177e4SLinus Torvalds case HCISETLINKMODE: 2854e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 2855e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 2856e4e8e37cSMarcel Holtmann break; 2857e4e8e37cSMarcel Holtmann 2858e4e8e37cSMarcel Holtmann case HCISETPTYPE: 2859e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 28601da177e4SLinus Torvalds break; 28611da177e4SLinus Torvalds 28621da177e4SLinus Torvalds case HCISETACLMTU: 28631da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 28641da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 28651da177e4SLinus Torvalds break; 28661da177e4SLinus Torvalds 28671da177e4SLinus Torvalds case HCISETSCOMTU: 28681da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 28691da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 28701da177e4SLinus Torvalds break; 28711da177e4SLinus Torvalds 28721da177e4SLinus Torvalds default: 28731da177e4SLinus Torvalds err = -EINVAL; 28741da177e4SLinus Torvalds break; 28751da177e4SLinus Torvalds } 2876e4e8e37cSMarcel Holtmann 28770736cfa8SMarcel Holtmann done: 28781da177e4SLinus Torvalds hci_dev_put(hdev); 28791da177e4SLinus Torvalds return err; 28801da177e4SLinus Torvalds } 28811da177e4SLinus Torvalds 28821da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 28831da177e4SLinus Torvalds { 28848035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 28851da177e4SLinus Torvalds struct hci_dev_list_req *dl; 28861da177e4SLinus Torvalds struct hci_dev_req *dr; 28871da177e4SLinus Torvalds int n = 0, size, err; 28881da177e4SLinus Torvalds __u16 dev_num; 28891da177e4SLinus Torvalds 28901da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 28911da177e4SLinus Torvalds return -EFAULT; 28921da177e4SLinus Torvalds 28931da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 28941da177e4SLinus Torvalds return -EINVAL; 28951da177e4SLinus Torvalds 28961da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 28971da177e4SLinus Torvalds 289870f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 289970f23020SAndrei Emeltchenko if (!dl) 29001da177e4SLinus Torvalds return -ENOMEM; 29011da177e4SLinus Torvalds 29021da177e4SLinus Torvalds dr = dl->dev_req; 29031da177e4SLinus Torvalds 2904f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 29058035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 29062e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 2907c542a06cSJohan Hedberg 29082e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 29092e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 29102e84d8dbSMarcel Holtmann * device is actually down. 29112e84d8dbSMarcel Holtmann */ 29122e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 29132e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 2914c542a06cSJohan Hedberg 29151da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 29162e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 2917c542a06cSJohan Hedberg 29181da177e4SLinus Torvalds if (++n >= dev_num) 29191da177e4SLinus Torvalds break; 29201da177e4SLinus Torvalds } 2921f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 29221da177e4SLinus Torvalds 29231da177e4SLinus Torvalds dl->dev_num = n; 29241da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 29251da177e4SLinus Torvalds 29261da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 29271da177e4SLinus Torvalds kfree(dl); 29281da177e4SLinus Torvalds 29291da177e4SLinus Torvalds return err ? -EFAULT : 0; 29301da177e4SLinus Torvalds } 29311da177e4SLinus Torvalds 29321da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 29331da177e4SLinus Torvalds { 29341da177e4SLinus Torvalds struct hci_dev *hdev; 29351da177e4SLinus Torvalds struct hci_dev_info di; 29362e84d8dbSMarcel Holtmann unsigned long flags; 29371da177e4SLinus Torvalds int err = 0; 29381da177e4SLinus Torvalds 29391da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 29401da177e4SLinus Torvalds return -EFAULT; 29411da177e4SLinus Torvalds 294270f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 294370f23020SAndrei Emeltchenko if (!hdev) 29441da177e4SLinus Torvalds return -ENODEV; 29451da177e4SLinus Torvalds 29462e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 29472e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 29482e84d8dbSMarcel Holtmann * device is actually down. 29492e84d8dbSMarcel Holtmann */ 29502e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 29512e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 29522e84d8dbSMarcel Holtmann else 29532e84d8dbSMarcel Holtmann flags = hdev->flags; 2954c542a06cSJohan Hedberg 29551da177e4SLinus Torvalds strcpy(di.name, hdev->name); 29561da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 295760f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 29582e84d8dbSMarcel Holtmann di.flags = flags; 29591da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2960572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 29611da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 29621da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 29631da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 29641da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2965572c7f84SJohan Hedberg } else { 2966572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2967572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2968572c7f84SJohan Hedberg di.sco_mtu = 0; 2969572c7f84SJohan Hedberg di.sco_pkts = 0; 2970572c7f84SJohan Hedberg } 29711da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 29721da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 29731da177e4SLinus Torvalds 29741da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 29751da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 29761da177e4SLinus Torvalds 29771da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 29781da177e4SLinus Torvalds err = -EFAULT; 29791da177e4SLinus Torvalds 29801da177e4SLinus Torvalds hci_dev_put(hdev); 29811da177e4SLinus Torvalds 29821da177e4SLinus Torvalds return err; 29831da177e4SLinus Torvalds } 29841da177e4SLinus Torvalds 29851da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 29861da177e4SLinus Torvalds 2987611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2988611b30f7SMarcel Holtmann { 2989611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2990611b30f7SMarcel Holtmann 2991611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2992611b30f7SMarcel Holtmann 29930736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 29940736cfa8SMarcel Holtmann return -EBUSY; 29950736cfa8SMarcel Holtmann 29965e130367SJohan Hedberg if (blocked) { 29975e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 2998d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2999d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) 3000611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 30015e130367SJohan Hedberg } else { 30025e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 30035e130367SJohan Hedberg } 3004611b30f7SMarcel Holtmann 3005611b30f7SMarcel Holtmann return 0; 3006611b30f7SMarcel Holtmann } 3007611b30f7SMarcel Holtmann 3008611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 3009611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 3010611b30f7SMarcel Holtmann }; 3011611b30f7SMarcel Holtmann 3012ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 3013ab81cbf9SJohan Hedberg { 3014ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 301596570ffcSJohan Hedberg int err; 3016ab81cbf9SJohan Hedberg 3017ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 3018ab81cbf9SJohan Hedberg 3019cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 302096570ffcSJohan Hedberg if (err < 0) { 302196570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 3022ab81cbf9SJohan Hedberg return; 302396570ffcSJohan Hedberg } 3024ab81cbf9SJohan Hedberg 3025a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 3026a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 3027a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 3028a5c8f270SMarcel Holtmann */ 3029a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 30304a964404SMarcel Holtmann test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) || 3031a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 3032a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 3033a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 3034bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 3035bf543036SJohan Hedberg hci_dev_do_close(hdev); 3036bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 303719202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 303819202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 3039bf543036SJohan Hedberg } 3040ab81cbf9SJohan Hedberg 3041fee746b0SMarcel Holtmann if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) { 30424a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 30434a964404SMarcel Holtmann * so that userspace can easily identify them. 30444a964404SMarcel Holtmann */ 30454a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 30464a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 30470602a8adSMarcel Holtmann 30480602a8adSMarcel Holtmann /* For fully configured devices, this will send 30490602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 30500602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 30510602a8adSMarcel Holtmann * 30520602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 30530602a8adSMarcel Holtmann * and no event will be send. 30540602a8adSMarcel Holtmann */ 3055744cf19eSJohan Hedberg mgmt_index_added(hdev); 3056d603b76bSMarcel Holtmann } else if (test_and_clear_bit(HCI_CONFIG, &hdev->dev_flags)) { 30575ea234d3SMarcel Holtmann /* When the controller is now configured, then it 30585ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 30595ea234d3SMarcel Holtmann */ 30605ea234d3SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 30615ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 30625ea234d3SMarcel Holtmann 3063d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 3064d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 3065d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 3066d603b76bSMarcel Holtmann */ 3067d603b76bSMarcel Holtmann mgmt_index_added(hdev); 3068ab81cbf9SJohan Hedberg } 3069ab81cbf9SJohan Hedberg } 3070ab81cbf9SJohan Hedberg 3071ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 3072ab81cbf9SJohan Hedberg { 30733243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 30743243553fSJohan Hedberg power_off.work); 3075ab81cbf9SJohan Hedberg 3076ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 3077ab81cbf9SJohan Hedberg 30788ee56540SMarcel Holtmann hci_dev_do_close(hdev); 3079ab81cbf9SJohan Hedberg } 3080ab81cbf9SJohan Hedberg 308116ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 308216ab91abSJohan Hedberg { 308316ab91abSJohan Hedberg struct hci_dev *hdev; 308416ab91abSJohan Hedberg 308516ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 308616ab91abSJohan Hedberg 308716ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 308816ab91abSJohan Hedberg 3089d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 309016ab91abSJohan Hedberg } 309116ab91abSJohan Hedberg 309235f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 30932aeb9a1aSJohan Hedberg { 30944821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 30952aeb9a1aSJohan Hedberg 30964821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 30974821002cSJohan Hedberg list_del(&uuid->list); 30982aeb9a1aSJohan Hedberg kfree(uuid); 30992aeb9a1aSJohan Hedberg } 31002aeb9a1aSJohan Hedberg } 31012aeb9a1aSJohan Hedberg 310235f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 310355ed8ca1SJohan Hedberg { 310455ed8ca1SJohan Hedberg struct list_head *p, *n; 310555ed8ca1SJohan Hedberg 310655ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 310755ed8ca1SJohan Hedberg struct link_key *key; 310855ed8ca1SJohan Hedberg 310955ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 311055ed8ca1SJohan Hedberg 311155ed8ca1SJohan Hedberg list_del(p); 311255ed8ca1SJohan Hedberg kfree(key); 311355ed8ca1SJohan Hedberg } 311455ed8ca1SJohan Hedberg } 311555ed8ca1SJohan Hedberg 311635f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 3117b899efafSVinicius Costa Gomes { 3118970d0f1bSJohan Hedberg struct smp_ltk *k; 3119b899efafSVinicius Costa Gomes 3120970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 3121970d0f1bSJohan Hedberg list_del_rcu(&k->list); 3122970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 3123b899efafSVinicius Costa Gomes } 3124b899efafSVinicius Costa Gomes } 3125b899efafSVinicius Costa Gomes 3126970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 3127970c4e46SJohan Hedberg { 3128adae20cbSJohan Hedberg struct smp_irk *k; 3129970c4e46SJohan Hedberg 3130adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 3131adae20cbSJohan Hedberg list_del_rcu(&k->list); 3132adae20cbSJohan Hedberg kfree_rcu(k, rcu); 3133970c4e46SJohan Hedberg } 3134970c4e46SJohan Hedberg } 3135970c4e46SJohan Hedberg 313655ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 313755ed8ca1SJohan Hedberg { 313855ed8ca1SJohan Hedberg struct link_key *k; 313955ed8ca1SJohan Hedberg 31408035ded4SLuiz Augusto von Dentz list_for_each_entry(k, &hdev->link_keys, list) 314155ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 314255ed8ca1SJohan Hedberg return k; 314355ed8ca1SJohan Hedberg 314455ed8ca1SJohan Hedberg return NULL; 314555ed8ca1SJohan Hedberg } 314655ed8ca1SJohan Hedberg 3147745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 3148d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 3149d25e28abSJohan Hedberg { 3150d25e28abSJohan Hedberg /* Legacy key */ 3151d25e28abSJohan Hedberg if (key_type < 0x03) 3152745c0ce3SVishal Agarwal return true; 3153d25e28abSJohan Hedberg 3154d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 3155d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 3156745c0ce3SVishal Agarwal return false; 3157d25e28abSJohan Hedberg 3158d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 3159d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 3160745c0ce3SVishal Agarwal return false; 3161d25e28abSJohan Hedberg 3162d25e28abSJohan Hedberg /* Security mode 3 case */ 3163d25e28abSJohan Hedberg if (!conn) 3164745c0ce3SVishal Agarwal return true; 3165d25e28abSJohan Hedberg 3166d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 3167d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 3168745c0ce3SVishal Agarwal return true; 3169d25e28abSJohan Hedberg 3170d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 3171d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 3172745c0ce3SVishal Agarwal return true; 3173d25e28abSJohan Hedberg 3174d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 3175d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 3176745c0ce3SVishal Agarwal return true; 3177d25e28abSJohan Hedberg 3178d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 3179d25e28abSJohan Hedberg * persistently */ 3180745c0ce3SVishal Agarwal return false; 3181d25e28abSJohan Hedberg } 3182d25e28abSJohan Hedberg 3183e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 318498a0b845SJohan Hedberg { 3185e804d25dSJohan Hedberg if (type == SMP_LTK) 3186e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 318798a0b845SJohan Hedberg 3188e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 318998a0b845SJohan Hedberg } 319098a0b845SJohan Hedberg 3191fe39c7b2SMarcel Holtmann struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, __le64 rand, 3192e804d25dSJohan Hedberg u8 role) 319375d262c2SVinicius Costa Gomes { 3194c9839a11SVinicius Costa Gomes struct smp_ltk *k; 319575d262c2SVinicius Costa Gomes 3196970d0f1bSJohan Hedberg rcu_read_lock(); 3197970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 3198fe39c7b2SMarcel Holtmann if (k->ediv != ediv || k->rand != rand) 319975d262c2SVinicius Costa Gomes continue; 320075d262c2SVinicius Costa Gomes 3201e804d25dSJohan Hedberg if (ltk_role(k->type) != role) 320298a0b845SJohan Hedberg continue; 320398a0b845SJohan Hedberg 3204970d0f1bSJohan Hedberg rcu_read_unlock(); 320575d262c2SVinicius Costa Gomes return k; 320675d262c2SVinicius Costa Gomes } 3207970d0f1bSJohan Hedberg rcu_read_unlock(); 320875d262c2SVinicius Costa Gomes 320975d262c2SVinicius Costa Gomes return NULL; 321075d262c2SVinicius Costa Gomes } 321175d262c2SVinicius Costa Gomes 3212c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 3213e804d25dSJohan Hedberg u8 addr_type, u8 role) 321475d262c2SVinicius Costa Gomes { 3215c9839a11SVinicius Costa Gomes struct smp_ltk *k; 321675d262c2SVinicius Costa Gomes 3217970d0f1bSJohan Hedberg rcu_read_lock(); 3218970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 3219c9839a11SVinicius Costa Gomes if (addr_type == k->bdaddr_type && 322098a0b845SJohan Hedberg bacmp(bdaddr, &k->bdaddr) == 0 && 3221970d0f1bSJohan Hedberg ltk_role(k->type) == role) { 3222970d0f1bSJohan Hedberg rcu_read_unlock(); 322375d262c2SVinicius Costa Gomes return k; 3224970d0f1bSJohan Hedberg } 3225970d0f1bSJohan Hedberg } 3226970d0f1bSJohan Hedberg rcu_read_unlock(); 322775d262c2SVinicius Costa Gomes 322875d262c2SVinicius Costa Gomes return NULL; 322975d262c2SVinicius Costa Gomes } 323075d262c2SVinicius Costa Gomes 3231970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 3232970c4e46SJohan Hedberg { 3233970c4e46SJohan Hedberg struct smp_irk *irk; 3234970c4e46SJohan Hedberg 3235adae20cbSJohan Hedberg rcu_read_lock(); 3236adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 3237adae20cbSJohan Hedberg if (!bacmp(&irk->rpa, rpa)) { 3238adae20cbSJohan Hedberg rcu_read_unlock(); 3239970c4e46SJohan Hedberg return irk; 3240970c4e46SJohan Hedberg } 3241adae20cbSJohan Hedberg } 3242970c4e46SJohan Hedberg 3243adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 3244defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 3245970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 3246adae20cbSJohan Hedberg rcu_read_unlock(); 3247970c4e46SJohan Hedberg return irk; 3248970c4e46SJohan Hedberg } 3249970c4e46SJohan Hedberg } 3250adae20cbSJohan Hedberg rcu_read_unlock(); 3251970c4e46SJohan Hedberg 3252970c4e46SJohan Hedberg return NULL; 3253970c4e46SJohan Hedberg } 3254970c4e46SJohan Hedberg 3255970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 3256970c4e46SJohan Hedberg u8 addr_type) 3257970c4e46SJohan Hedberg { 3258970c4e46SJohan Hedberg struct smp_irk *irk; 3259970c4e46SJohan Hedberg 32606cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 32616cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 32626cfc9988SJohan Hedberg return NULL; 32636cfc9988SJohan Hedberg 3264adae20cbSJohan Hedberg rcu_read_lock(); 3265adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 3266970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 3267adae20cbSJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) { 3268adae20cbSJohan Hedberg rcu_read_unlock(); 3269970c4e46SJohan Hedberg return irk; 3270970c4e46SJohan Hedberg } 3271adae20cbSJohan Hedberg } 3272adae20cbSJohan Hedberg rcu_read_unlock(); 3273970c4e46SJohan Hedberg 3274970c4e46SJohan Hedberg return NULL; 3275970c4e46SJohan Hedberg } 3276970c4e46SJohan Hedberg 3277567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 32787652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 32797652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 328055ed8ca1SJohan Hedberg { 328155ed8ca1SJohan Hedberg struct link_key *key, *old_key; 3282745c0ce3SVishal Agarwal u8 old_key_type; 328355ed8ca1SJohan Hedberg 328455ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 328555ed8ca1SJohan Hedberg if (old_key) { 328655ed8ca1SJohan Hedberg old_key_type = old_key->type; 328755ed8ca1SJohan Hedberg key = old_key; 328855ed8ca1SJohan Hedberg } else { 328912adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 32900a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 329155ed8ca1SJohan Hedberg if (!key) 3292567fa2aaSJohan Hedberg return NULL; 329355ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 329455ed8ca1SJohan Hedberg } 329555ed8ca1SJohan Hedberg 32966ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 329755ed8ca1SJohan Hedberg 3298d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 3299d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 3300d25e28abSJohan Hedberg * previous key */ 3301d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 3302a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 3303d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 3304655fe6ecSJohan Hedberg if (conn) 3305655fe6ecSJohan Hedberg conn->key_type = type; 3306655fe6ecSJohan Hedberg } 3307d25e28abSJohan Hedberg 330855ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 33099b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 331055ed8ca1SJohan Hedberg key->pin_len = pin_len; 331155ed8ca1SJohan Hedberg 3312b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 331355ed8ca1SJohan Hedberg key->type = old_key_type; 33144748fed2SJohan Hedberg else 33154748fed2SJohan Hedberg key->type = type; 33164748fed2SJohan Hedberg 33177652ff6aSJohan Hedberg if (persistent) 33187652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 33197652ff6aSJohan Hedberg old_key_type); 33204df378a1SJohan Hedberg 3321567fa2aaSJohan Hedberg return key; 332255ed8ca1SJohan Hedberg } 332355ed8ca1SJohan Hedberg 3324ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 332535d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 3326fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 332775d262c2SVinicius Costa Gomes { 3328c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 3329e804d25dSJohan Hedberg u8 role = ltk_role(type); 333075d262c2SVinicius Costa Gomes 3331e804d25dSJohan Hedberg old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type, role); 3332c9839a11SVinicius Costa Gomes if (old_key) 333375d262c2SVinicius Costa Gomes key = old_key; 3334c9839a11SVinicius Costa Gomes else { 33350a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 333675d262c2SVinicius Costa Gomes if (!key) 3337ca9142b8SJohan Hedberg return NULL; 3338970d0f1bSJohan Hedberg list_add_rcu(&key->list, &hdev->long_term_keys); 333975d262c2SVinicius Costa Gomes } 334075d262c2SVinicius Costa Gomes 334175d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 3342c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 3343c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 3344c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 3345c9839a11SVinicius Costa Gomes key->ediv = ediv; 3346fe39c7b2SMarcel Holtmann key->rand = rand; 3347c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 3348c9839a11SVinicius Costa Gomes key->type = type; 334975d262c2SVinicius Costa Gomes 3350ca9142b8SJohan Hedberg return key; 335175d262c2SVinicius Costa Gomes } 335275d262c2SVinicius Costa Gomes 3353ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 3354ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 3355970c4e46SJohan Hedberg { 3356970c4e46SJohan Hedberg struct smp_irk *irk; 3357970c4e46SJohan Hedberg 3358970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 3359970c4e46SJohan Hedberg if (!irk) { 3360970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 3361970c4e46SJohan Hedberg if (!irk) 3362ca9142b8SJohan Hedberg return NULL; 3363970c4e46SJohan Hedberg 3364970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 3365970c4e46SJohan Hedberg irk->addr_type = addr_type; 3366970c4e46SJohan Hedberg 3367adae20cbSJohan Hedberg list_add_rcu(&irk->list, &hdev->identity_resolving_keys); 3368970c4e46SJohan Hedberg } 3369970c4e46SJohan Hedberg 3370970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 3371970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 3372970c4e46SJohan Hedberg 3373ca9142b8SJohan Hedberg return irk; 3374970c4e46SJohan Hedberg } 3375970c4e46SJohan Hedberg 337655ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 337755ed8ca1SJohan Hedberg { 337855ed8ca1SJohan Hedberg struct link_key *key; 337955ed8ca1SJohan Hedberg 338055ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 338155ed8ca1SJohan Hedberg if (!key) 338255ed8ca1SJohan Hedberg return -ENOENT; 338355ed8ca1SJohan Hedberg 33846ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 338555ed8ca1SJohan Hedberg 338655ed8ca1SJohan Hedberg list_del(&key->list); 338755ed8ca1SJohan Hedberg kfree(key); 338855ed8ca1SJohan Hedberg 338955ed8ca1SJohan Hedberg return 0; 339055ed8ca1SJohan Hedberg } 339155ed8ca1SJohan Hedberg 3392e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 3393b899efafSVinicius Costa Gomes { 3394970d0f1bSJohan Hedberg struct smp_ltk *k; 3395c51ffa0bSJohan Hedberg int removed = 0; 3396b899efafSVinicius Costa Gomes 3397970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 3398e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 3399b899efafSVinicius Costa Gomes continue; 3400b899efafSVinicius Costa Gomes 34016ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3402b899efafSVinicius Costa Gomes 3403970d0f1bSJohan Hedberg list_del_rcu(&k->list); 3404970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 3405c51ffa0bSJohan Hedberg removed++; 3406b899efafSVinicius Costa Gomes } 3407b899efafSVinicius Costa Gomes 3408c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 3409b899efafSVinicius Costa Gomes } 3410b899efafSVinicius Costa Gomes 3411a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 3412a7ec7338SJohan Hedberg { 3413adae20cbSJohan Hedberg struct smp_irk *k; 3414a7ec7338SJohan Hedberg 3415adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 3416a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 3417a7ec7338SJohan Hedberg continue; 3418a7ec7338SJohan Hedberg 3419a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3420a7ec7338SJohan Hedberg 3421adae20cbSJohan Hedberg list_del_rcu(&k->list); 3422adae20cbSJohan Hedberg kfree_rcu(k, rcu); 3423a7ec7338SJohan Hedberg } 3424a7ec7338SJohan Hedberg } 3425a7ec7338SJohan Hedberg 34266bd32326SVille Tervo /* HCI command timer function */ 342765cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 34286bd32326SVille Tervo { 342965cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 343065cc2b49SMarcel Holtmann cmd_timer.work); 34316bd32326SVille Tervo 3432bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 3433bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 3434bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 3435bda4f23aSAndrei Emeltchenko 3436bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 3437bda4f23aSAndrei Emeltchenko } else { 34386bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 3439bda4f23aSAndrei Emeltchenko } 3440bda4f23aSAndrei Emeltchenko 34416bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 3442c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 34436bd32326SVille Tervo } 34446bd32326SVille Tervo 34452763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 34462763eda6SSzymon Janc bdaddr_t *bdaddr) 34472763eda6SSzymon Janc { 34482763eda6SSzymon Janc struct oob_data *data; 34492763eda6SSzymon Janc 34502763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 34512763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 34522763eda6SSzymon Janc return data; 34532763eda6SSzymon Janc 34542763eda6SSzymon Janc return NULL; 34552763eda6SSzymon Janc } 34562763eda6SSzymon Janc 34572763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 34582763eda6SSzymon Janc { 34592763eda6SSzymon Janc struct oob_data *data; 34602763eda6SSzymon Janc 34612763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 34622763eda6SSzymon Janc if (!data) 34632763eda6SSzymon Janc return -ENOENT; 34642763eda6SSzymon Janc 34656ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 34662763eda6SSzymon Janc 34672763eda6SSzymon Janc list_del(&data->list); 34682763eda6SSzymon Janc kfree(data); 34692763eda6SSzymon Janc 34702763eda6SSzymon Janc return 0; 34712763eda6SSzymon Janc } 34722763eda6SSzymon Janc 347335f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 34742763eda6SSzymon Janc { 34752763eda6SSzymon Janc struct oob_data *data, *n; 34762763eda6SSzymon Janc 34772763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 34782763eda6SSzymon Janc list_del(&data->list); 34792763eda6SSzymon Janc kfree(data); 34802763eda6SSzymon Janc } 34812763eda6SSzymon Janc } 34822763eda6SSzymon Janc 34830798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 348438da1703SJohan Hedberg u8 *hash, u8 *rand) 34852763eda6SSzymon Janc { 34862763eda6SSzymon Janc struct oob_data *data; 34872763eda6SSzymon Janc 34882763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 34892763eda6SSzymon Janc if (!data) { 34900a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 34912763eda6SSzymon Janc if (!data) 34922763eda6SSzymon Janc return -ENOMEM; 34932763eda6SSzymon Janc 34942763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 34952763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 34962763eda6SSzymon Janc } 34972763eda6SSzymon Janc 3498519ca9d0SMarcel Holtmann memcpy(data->hash192, hash, sizeof(data->hash192)); 349938da1703SJohan Hedberg memcpy(data->rand192, rand, sizeof(data->rand192)); 35002763eda6SSzymon Janc 35010798872eSMarcel Holtmann memset(data->hash256, 0, sizeof(data->hash256)); 350238da1703SJohan Hedberg memset(data->rand256, 0, sizeof(data->rand256)); 35030798872eSMarcel Holtmann 35040798872eSMarcel Holtmann BT_DBG("%s for %pMR", hdev->name, bdaddr); 35050798872eSMarcel Holtmann 35060798872eSMarcel Holtmann return 0; 35070798872eSMarcel Holtmann } 35080798872eSMarcel Holtmann 35090798872eSMarcel Holtmann int hci_add_remote_oob_ext_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 351038da1703SJohan Hedberg u8 *hash192, u8 *rand192, 351138da1703SJohan Hedberg u8 *hash256, u8 *rand256) 35120798872eSMarcel Holtmann { 35130798872eSMarcel Holtmann struct oob_data *data; 35140798872eSMarcel Holtmann 35150798872eSMarcel Holtmann data = hci_find_remote_oob_data(hdev, bdaddr); 35160798872eSMarcel Holtmann if (!data) { 35170a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 35180798872eSMarcel Holtmann if (!data) 35190798872eSMarcel Holtmann return -ENOMEM; 35200798872eSMarcel Holtmann 35210798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 35220798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 35230798872eSMarcel Holtmann } 35240798872eSMarcel Holtmann 35250798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 352638da1703SJohan Hedberg memcpy(data->rand192, rand192, sizeof(data->rand192)); 35270798872eSMarcel Holtmann 35280798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 352938da1703SJohan Hedberg memcpy(data->rand256, rand256, sizeof(data->rand256)); 35300798872eSMarcel Holtmann 35316ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 35322763eda6SSzymon Janc 35332763eda6SSzymon Janc return 0; 35342763eda6SSzymon Janc } 35352763eda6SSzymon Janc 3536dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 3537b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 3538b2a66aadSAntti Julku { 3539b2a66aadSAntti Julku struct bdaddr_list *b; 3540b2a66aadSAntti Julku 3541dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 3542b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 3543b2a66aadSAntti Julku return b; 3544b9ee0a78SMarcel Holtmann } 3545b2a66aadSAntti Julku 3546b2a66aadSAntti Julku return NULL; 3547b2a66aadSAntti Julku } 3548b2a66aadSAntti Julku 3549dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 3550b2a66aadSAntti Julku { 3551b2a66aadSAntti Julku struct list_head *p, *n; 3552b2a66aadSAntti Julku 3553dcc36c16SJohan Hedberg list_for_each_safe(p, n, bdaddr_list) { 3554b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 3555b2a66aadSAntti Julku 3556b2a66aadSAntti Julku list_del(p); 3557b2a66aadSAntti Julku kfree(b); 3558b2a66aadSAntti Julku } 3559b2a66aadSAntti Julku } 3560b2a66aadSAntti Julku 3561dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3562b2a66aadSAntti Julku { 3563b2a66aadSAntti Julku struct bdaddr_list *entry; 3564b2a66aadSAntti Julku 3565b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 3566b2a66aadSAntti Julku return -EBADF; 3567b2a66aadSAntti Julku 3568dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 35695e762444SAntti Julku return -EEXIST; 3570b2a66aadSAntti Julku 357127f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 35725e762444SAntti Julku if (!entry) 35735e762444SAntti Julku return -ENOMEM; 3574b2a66aadSAntti Julku 3575b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 3576b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 3577b2a66aadSAntti Julku 3578dcc36c16SJohan Hedberg list_add(&entry->list, list); 3579b2a66aadSAntti Julku 35802a8357f2SJohan Hedberg return 0; 3581b2a66aadSAntti Julku } 3582b2a66aadSAntti Julku 3583dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3584b2a66aadSAntti Julku { 3585b2a66aadSAntti Julku struct bdaddr_list *entry; 3586b2a66aadSAntti Julku 358735f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 3588dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 358935f7498aSJohan Hedberg return 0; 359035f7498aSJohan Hedberg } 3591b2a66aadSAntti Julku 3592dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 3593d2ab0ac1SMarcel Holtmann if (!entry) 3594d2ab0ac1SMarcel Holtmann return -ENOENT; 3595d2ab0ac1SMarcel Holtmann 3596d2ab0ac1SMarcel Holtmann list_del(&entry->list); 3597d2ab0ac1SMarcel Holtmann kfree(entry); 3598d2ab0ac1SMarcel Holtmann 3599d2ab0ac1SMarcel Holtmann return 0; 3600d2ab0ac1SMarcel Holtmann } 3601d2ab0ac1SMarcel Holtmann 360215819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 360315819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 360415819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 360515819a70SAndre Guedes { 360615819a70SAndre Guedes struct hci_conn_params *params; 360715819a70SAndre Guedes 3608738f6185SJohan Hedberg /* The conn params list only contains identity addresses */ 3609738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 3610738f6185SJohan Hedberg return NULL; 3611738f6185SJohan Hedberg 361215819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 361315819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 361415819a70SAndre Guedes params->addr_type == addr_type) { 361515819a70SAndre Guedes return params; 361615819a70SAndre Guedes } 361715819a70SAndre Guedes } 361815819a70SAndre Guedes 361915819a70SAndre Guedes return NULL; 362015819a70SAndre Guedes } 362115819a70SAndre Guedes 3622cef952ceSAndre Guedes static bool is_connected(struct hci_dev *hdev, bdaddr_t *addr, u8 type) 3623cef952ceSAndre Guedes { 3624cef952ceSAndre Guedes struct hci_conn *conn; 3625cef952ceSAndre Guedes 3626cef952ceSAndre Guedes conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, addr); 3627cef952ceSAndre Guedes if (!conn) 3628cef952ceSAndre Guedes return false; 3629cef952ceSAndre Guedes 3630cef952ceSAndre Guedes if (conn->dst_type != type) 3631cef952ceSAndre Guedes return false; 3632cef952ceSAndre Guedes 3633cef952ceSAndre Guedes if (conn->state != BT_CONNECTED) 3634cef952ceSAndre Guedes return false; 3635cef952ceSAndre Guedes 3636cef952ceSAndre Guedes return true; 3637cef952ceSAndre Guedes } 3638cef952ceSAndre Guedes 363915819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 3640501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 36414b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 364215819a70SAndre Guedes { 3643912b42efSJohan Hedberg struct hci_conn_params *param; 364415819a70SAndre Guedes 3645738f6185SJohan Hedberg /* The list only contains identity addresses */ 3646738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 3647738f6185SJohan Hedberg return NULL; 364815819a70SAndre Guedes 3649501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 3650912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 3651912b42efSJohan Hedberg param->addr_type == addr_type) 3652912b42efSJohan Hedberg return param; 36534b10966fSMarcel Holtmann } 36544b10966fSMarcel Holtmann 36554b10966fSMarcel Holtmann return NULL; 365615819a70SAndre Guedes } 365715819a70SAndre Guedes 365815819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 365951d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 366051d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 366115819a70SAndre Guedes { 366215819a70SAndre Guedes struct hci_conn_params *params; 366315819a70SAndre Guedes 3664c46245b3SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 366551d167c0SMarcel Holtmann return NULL; 3666a9b0a04cSAndre Guedes 366715819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 3668cef952ceSAndre Guedes if (params) 366951d167c0SMarcel Holtmann return params; 367015819a70SAndre Guedes 367115819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 367215819a70SAndre Guedes if (!params) { 367315819a70SAndre Guedes BT_ERR("Out of memory"); 367451d167c0SMarcel Holtmann return NULL; 367515819a70SAndre Guedes } 367615819a70SAndre Guedes 367715819a70SAndre Guedes bacpy(¶ms->addr, addr); 367815819a70SAndre Guedes params->addr_type = addr_type; 3679cef952ceSAndre Guedes 3680cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 368193450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 3682cef952ceSAndre Guedes 3683bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 3684bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 3685bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 3686bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 3687bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 3688bf5b3c8bSMarcel Holtmann 3689bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 3690bf5b3c8bSMarcel Holtmann 369151d167c0SMarcel Holtmann return params; 3692bf5b3c8bSMarcel Holtmann } 3693bf5b3c8bSMarcel Holtmann 3694bf5b3c8bSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 3695bf5b3c8bSMarcel Holtmann int hci_conn_params_set(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type, 3696d06b50ceSMarcel Holtmann u8 auto_connect) 369715819a70SAndre Guedes { 369815819a70SAndre Guedes struct hci_conn_params *params; 369915819a70SAndre Guedes 37008c87aae1SMarcel Holtmann params = hci_conn_params_add(hdev, addr, addr_type); 37018c87aae1SMarcel Holtmann if (!params) 37028c87aae1SMarcel Holtmann return -EIO; 370315819a70SAndre Guedes 370442ce26deSJohan Hedberg if (params->auto_connect == auto_connect) 370542ce26deSJohan Hedberg return 0; 370642ce26deSJohan Hedberg 370766f8455aSJohan Hedberg list_del_init(¶ms->action); 370815819a70SAndre Guedes 3709cef952ceSAndre Guedes switch (auto_connect) { 3710cef952ceSAndre Guedes case HCI_AUTO_CONN_DISABLED: 3711cef952ceSAndre Guedes case HCI_AUTO_CONN_LINK_LOSS: 371295305baaSJohan Hedberg hci_update_background_scan(hdev); 3713cef952ceSAndre Guedes break; 3714851efca8SJohan Hedberg case HCI_AUTO_CONN_REPORT: 371595305baaSJohan Hedberg list_add(¶ms->action, &hdev->pend_le_reports); 371695305baaSJohan Hedberg hci_update_background_scan(hdev); 3717851efca8SJohan Hedberg break; 37184b9e7e75SMarcel Holtmann case HCI_AUTO_CONN_DIRECT: 3719cef952ceSAndre Guedes case HCI_AUTO_CONN_ALWAYS: 372095305baaSJohan Hedberg if (!is_connected(hdev, addr, addr_type)) { 372195305baaSJohan Hedberg list_add(¶ms->action, &hdev->pend_le_conns); 372295305baaSJohan Hedberg hci_update_background_scan(hdev); 372395305baaSJohan Hedberg } 3724cef952ceSAndre Guedes break; 3725cef952ceSAndre Guedes } 372615819a70SAndre Guedes 3727851efca8SJohan Hedberg params->auto_connect = auto_connect; 3728851efca8SJohan Hedberg 3729d06b50ceSMarcel Holtmann BT_DBG("addr %pMR (type %u) auto_connect %u", addr, addr_type, 3730d06b50ceSMarcel Holtmann auto_connect); 3731a9b0a04cSAndre Guedes 3732a9b0a04cSAndre Guedes return 0; 373315819a70SAndre Guedes } 373415819a70SAndre Guedes 3735f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 3736f6c63249SJohan Hedberg { 3737f6c63249SJohan Hedberg if (params->conn) { 3738f6c63249SJohan Hedberg hci_conn_drop(params->conn); 3739f6c63249SJohan Hedberg hci_conn_put(params->conn); 3740f6c63249SJohan Hedberg } 3741f6c63249SJohan Hedberg 3742f6c63249SJohan Hedberg list_del(¶ms->action); 3743f6c63249SJohan Hedberg list_del(¶ms->list); 3744f6c63249SJohan Hedberg kfree(params); 3745f6c63249SJohan Hedberg } 3746f6c63249SJohan Hedberg 374715819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 374815819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 374915819a70SAndre Guedes { 375015819a70SAndre Guedes struct hci_conn_params *params; 375115819a70SAndre Guedes 375215819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 375315819a70SAndre Guedes if (!params) 375415819a70SAndre Guedes return; 375515819a70SAndre Guedes 3756f6c63249SJohan Hedberg hci_conn_params_free(params); 375715819a70SAndre Guedes 375895305baaSJohan Hedberg hci_update_background_scan(hdev); 375995305baaSJohan Hedberg 376015819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 376115819a70SAndre Guedes } 376215819a70SAndre Guedes 376315819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 376455af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 376515819a70SAndre Guedes { 376615819a70SAndre Guedes struct hci_conn_params *params, *tmp; 376715819a70SAndre Guedes 376815819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 376955af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 377055af49a8SJohan Hedberg continue; 377115819a70SAndre Guedes list_del(¶ms->list); 377215819a70SAndre Guedes kfree(params); 377315819a70SAndre Guedes } 377415819a70SAndre Guedes 377555af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 377655af49a8SJohan Hedberg } 377755af49a8SJohan Hedberg 377855af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 3779373110c5SJohan Hedberg void hci_conn_params_clear_all(struct hci_dev *hdev) 378015819a70SAndre Guedes { 378115819a70SAndre Guedes struct hci_conn_params *params, *tmp; 378215819a70SAndre Guedes 3783f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 3784f6c63249SJohan Hedberg hci_conn_params_free(params); 378515819a70SAndre Guedes 3786a2f41a8fSJohan Hedberg hci_update_background_scan(hdev); 37871089b67dSMarcel Holtmann 378815819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 378915819a70SAndre Guedes } 379015819a70SAndre Guedes 37914c87eaabSAndre Guedes static void inquiry_complete(struct hci_dev *hdev, u8 status) 37927ba8b4beSAndre Guedes { 37934c87eaabSAndre Guedes if (status) { 37944c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 37957ba8b4beSAndre Guedes 37964c87eaabSAndre Guedes hci_dev_lock(hdev); 37974c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37984c87eaabSAndre Guedes hci_dev_unlock(hdev); 37994c87eaabSAndre Guedes return; 38004c87eaabSAndre Guedes } 38017ba8b4beSAndre Guedes } 38027ba8b4beSAndre Guedes 38034c87eaabSAndre Guedes static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status) 38047ba8b4beSAndre Guedes { 38054c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 38064c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 38074c87eaabSAndre Guedes struct hci_request req; 38084c87eaabSAndre Guedes struct hci_cp_inquiry cp; 38097ba8b4beSAndre Guedes int err; 38107ba8b4beSAndre Guedes 38114c87eaabSAndre Guedes if (status) { 38124c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 38134c87eaabSAndre Guedes return; 38147ba8b4beSAndre Guedes } 38157ba8b4beSAndre Guedes 38164c87eaabSAndre Guedes switch (hdev->discovery.type) { 38174c87eaabSAndre Guedes case DISCOV_TYPE_LE: 38184c87eaabSAndre Guedes hci_dev_lock(hdev); 38194c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 38204c87eaabSAndre Guedes hci_dev_unlock(hdev); 38214c87eaabSAndre Guedes break; 38227dbfac1dSAndre Guedes 38234c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 38244c87eaabSAndre Guedes hci_req_init(&req, hdev); 38257dbfac1dSAndre Guedes 38267dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 38274c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 38284c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 38294c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 38304c87eaabSAndre Guedes 38314c87eaabSAndre Guedes hci_dev_lock(hdev); 38324c87eaabSAndre Guedes 38334c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 38344c87eaabSAndre Guedes 38354c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 38364c87eaabSAndre Guedes if (err) { 38374c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 38384c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 38397dbfac1dSAndre Guedes } 38407dbfac1dSAndre Guedes 38414c87eaabSAndre Guedes hci_dev_unlock(hdev); 38424c87eaabSAndre Guedes break; 38434c87eaabSAndre Guedes } 38447dbfac1dSAndre Guedes } 38457dbfac1dSAndre Guedes 38467ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 38477ba8b4beSAndre Guedes { 38487ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 38497ba8b4beSAndre Guedes le_scan_disable.work); 38504c87eaabSAndre Guedes struct hci_request req; 38514c87eaabSAndre Guedes int err; 38527ba8b4beSAndre Guedes 38537ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 38547ba8b4beSAndre Guedes 38554c87eaabSAndre Guedes hci_req_init(&req, hdev); 38567ba8b4beSAndre Guedes 3857b1efcc28SAndre Guedes hci_req_add_le_scan_disable(&req); 38587ba8b4beSAndre Guedes 38594c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 38604c87eaabSAndre Guedes if (err) 38614c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 386228b75a89SAndre Guedes } 386328b75a89SAndre Guedes 38648d97250eSJohan Hedberg static void set_random_addr(struct hci_request *req, bdaddr_t *rpa) 38658d97250eSJohan Hedberg { 38668d97250eSJohan Hedberg struct hci_dev *hdev = req->hdev; 38678d97250eSJohan Hedberg 38688d97250eSJohan Hedberg /* If we're advertising or initiating an LE connection we can't 38698d97250eSJohan Hedberg * go ahead and change the random address at this time. This is 38708d97250eSJohan Hedberg * because the eventual initiator address used for the 38718d97250eSJohan Hedberg * subsequently created connection will be undefined (some 38728d97250eSJohan Hedberg * controllers use the new address and others the one we had 38738d97250eSJohan Hedberg * when the operation started). 38748d97250eSJohan Hedberg * 38758d97250eSJohan Hedberg * In this kind of scenario skip the update and let the random 38768d97250eSJohan Hedberg * address be updated at the next cycle. 38778d97250eSJohan Hedberg */ 38785ce194c4SJohan Hedberg if (test_bit(HCI_LE_ADV, &hdev->dev_flags) || 38798d97250eSJohan Hedberg hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT)) { 38808d97250eSJohan Hedberg BT_DBG("Deferring random address update"); 38819a783a13SJohan Hedberg set_bit(HCI_RPA_EXPIRED, &hdev->dev_flags); 38828d97250eSJohan Hedberg return; 38838d97250eSJohan Hedberg } 38848d97250eSJohan Hedberg 38858d97250eSJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, rpa); 38868d97250eSJohan Hedberg } 38878d97250eSJohan Hedberg 388894b1fc92SMarcel Holtmann int hci_update_random_address(struct hci_request *req, bool require_privacy, 388994b1fc92SMarcel Holtmann u8 *own_addr_type) 3890ebd3a747SJohan Hedberg { 3891ebd3a747SJohan Hedberg struct hci_dev *hdev = req->hdev; 3892ebd3a747SJohan Hedberg int err; 3893ebd3a747SJohan Hedberg 3894ebd3a747SJohan Hedberg /* If privacy is enabled use a resolvable private address. If 38952b5224dcSMarcel Holtmann * current RPA has expired or there is something else than 38962b5224dcSMarcel Holtmann * the current RPA in use, then generate a new one. 3897ebd3a747SJohan Hedberg */ 3898ebd3a747SJohan Hedberg if (test_bit(HCI_PRIVACY, &hdev->dev_flags)) { 3899ebd3a747SJohan Hedberg int to; 3900ebd3a747SJohan Hedberg 3901ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3902ebd3a747SJohan Hedberg 3903ebd3a747SJohan Hedberg if (!test_and_clear_bit(HCI_RPA_EXPIRED, &hdev->dev_flags) && 39042b5224dcSMarcel Holtmann !bacmp(&hdev->random_addr, &hdev->rpa)) 3905ebd3a747SJohan Hedberg return 0; 3906ebd3a747SJohan Hedberg 3907defce9e8SJohan Hedberg err = smp_generate_rpa(hdev, hdev->irk, &hdev->rpa); 3908ebd3a747SJohan Hedberg if (err < 0) { 3909ebd3a747SJohan Hedberg BT_ERR("%s failed to generate new RPA", hdev->name); 3910ebd3a747SJohan Hedberg return err; 3911ebd3a747SJohan Hedberg } 3912ebd3a747SJohan Hedberg 39138d97250eSJohan Hedberg set_random_addr(req, &hdev->rpa); 3914ebd3a747SJohan Hedberg 3915ebd3a747SJohan Hedberg to = msecs_to_jiffies(hdev->rpa_timeout * 1000); 3916ebd3a747SJohan Hedberg queue_delayed_work(hdev->workqueue, &hdev->rpa_expired, to); 3917ebd3a747SJohan Hedberg 3918ebd3a747SJohan Hedberg return 0; 3919ebd3a747SJohan Hedberg } 3920ebd3a747SJohan Hedberg 392194b1fc92SMarcel Holtmann /* In case of required privacy without resolvable private address, 392294b1fc92SMarcel Holtmann * use an unresolvable private address. This is useful for active 392394b1fc92SMarcel Holtmann * scanning and non-connectable advertising. 392494b1fc92SMarcel Holtmann */ 392594b1fc92SMarcel Holtmann if (require_privacy) { 392694b1fc92SMarcel Holtmann bdaddr_t urpa; 392794b1fc92SMarcel Holtmann 392894b1fc92SMarcel Holtmann get_random_bytes(&urpa, 6); 392994b1fc92SMarcel Holtmann urpa.b[5] &= 0x3f; /* Clear two most significant bits */ 393094b1fc92SMarcel Holtmann 393194b1fc92SMarcel Holtmann *own_addr_type = ADDR_LE_DEV_RANDOM; 39328d97250eSJohan Hedberg set_random_addr(req, &urpa); 393394b1fc92SMarcel Holtmann return 0; 393494b1fc92SMarcel Holtmann } 393594b1fc92SMarcel Holtmann 3936ebd3a747SJohan Hedberg /* If forcing static address is in use or there is no public 3937ebd3a747SJohan Hedberg * address use the static address as random address (but skip 3938ebd3a747SJohan Hedberg * the HCI command if the current random address is already the 3939ebd3a747SJohan Hedberg * static one. 3940ebd3a747SJohan Hedberg */ 3941111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3942ebd3a747SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3943ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3944ebd3a747SJohan Hedberg if (bacmp(&hdev->static_addr, &hdev->random_addr)) 3945ebd3a747SJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, 3946ebd3a747SJohan Hedberg &hdev->static_addr); 3947ebd3a747SJohan Hedberg return 0; 3948ebd3a747SJohan Hedberg } 3949ebd3a747SJohan Hedberg 3950ebd3a747SJohan Hedberg /* Neither privacy nor static address is being used so use a 3951ebd3a747SJohan Hedberg * public address. 3952ebd3a747SJohan Hedberg */ 3953ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_PUBLIC; 3954ebd3a747SJohan Hedberg 3955ebd3a747SJohan Hedberg return 0; 3956ebd3a747SJohan Hedberg } 3957ebd3a747SJohan Hedberg 3958a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 3959a1f4c318SJohan Hedberg * 3960a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 3961a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 3962a1f4c318SJohan Hedberg * the static random address. 3963a1f4c318SJohan Hedberg * 3964a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 3965a1f4c318SJohan Hedberg * public address to use the static random address instead. 3966a1f4c318SJohan Hedberg */ 3967a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 3968a1f4c318SJohan Hedberg u8 *bdaddr_type) 3969a1f4c318SJohan Hedberg { 3970111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3971a1f4c318SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3972a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3973a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3974a1f4c318SJohan Hedberg } else { 3975a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3976a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3977a1f4c318SJohan Hedberg } 3978a1f4c318SJohan Hedberg } 3979a1f4c318SJohan Hedberg 39809be0dab7SDavid Herrmann /* Alloc HCI device */ 39819be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 39829be0dab7SDavid Herrmann { 39839be0dab7SDavid Herrmann struct hci_dev *hdev; 39849be0dab7SDavid Herrmann 398527f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 39869be0dab7SDavid Herrmann if (!hdev) 39879be0dab7SDavid Herrmann return NULL; 39889be0dab7SDavid Herrmann 3989b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3990b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3991b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3992b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3993b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 399496c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3995bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3996bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3997b1b813d4SDavid Herrmann 3998b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3999b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 4000b1b813d4SDavid Herrmann 40013f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 4002628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 4003628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 4004bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 4005bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 40064e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 40074e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 400804fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 400904fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 4010bef64738SMarcel Holtmann 4011d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 4012b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 401331ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 401431ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 4015d6bfd59cSJohan Hedberg 4016b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 4017b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 4018b1b813d4SDavid Herrmann 4019b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 4020b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 40216659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 4022b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 4023b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 4024b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 4025970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 4026b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 4027d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 402815819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 402977a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 403066f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 40316b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 4032b1b813d4SDavid Herrmann 4033b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 4034b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 4035b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 4036b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 4037b1b813d4SDavid Herrmann 4038b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 4039b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 4040b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 4041b1b813d4SDavid Herrmann 4042b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 4043b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 4044b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 4045b1b813d4SDavid Herrmann 4046b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 4047b1b813d4SDavid Herrmann 404865cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 4049b1b813d4SDavid Herrmann 4050b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 4051b1b813d4SDavid Herrmann discovery_init(hdev); 40529be0dab7SDavid Herrmann 40539be0dab7SDavid Herrmann return hdev; 40549be0dab7SDavid Herrmann } 40559be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 40569be0dab7SDavid Herrmann 40579be0dab7SDavid Herrmann /* Free HCI device */ 40589be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 40599be0dab7SDavid Herrmann { 40609be0dab7SDavid Herrmann /* will free via device release */ 40619be0dab7SDavid Herrmann put_device(&hdev->dev); 40629be0dab7SDavid Herrmann } 40639be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 40649be0dab7SDavid Herrmann 40651da177e4SLinus Torvalds /* Register HCI device */ 40661da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 40671da177e4SLinus Torvalds { 4068b1b813d4SDavid Herrmann int id, error; 40691da177e4SLinus Torvalds 407074292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 40711da177e4SLinus Torvalds return -EINVAL; 40721da177e4SLinus Torvalds 407308add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 407408add513SMat Martineau * so the index can be used as the AMP controller ID. 407508add513SMat Martineau */ 40763df92b31SSasha Levin switch (hdev->dev_type) { 40773df92b31SSasha Levin case HCI_BREDR: 40783df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 40791da177e4SLinus Torvalds break; 40803df92b31SSasha Levin case HCI_AMP: 40813df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 40823df92b31SSasha Levin break; 40833df92b31SSasha Levin default: 40843df92b31SSasha Levin return -EINVAL; 40851da177e4SLinus Torvalds } 40861da177e4SLinus Torvalds 40873df92b31SSasha Levin if (id < 0) 40883df92b31SSasha Levin return id; 40893df92b31SSasha Levin 40901da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 40911da177e4SLinus Torvalds hdev->id = id; 40922d8b3a11SAndrei Emeltchenko 40932d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 40942d8b3a11SAndrei Emeltchenko 4095d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 4096d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 409733ca954dSDavid Herrmann if (!hdev->workqueue) { 409833ca954dSDavid Herrmann error = -ENOMEM; 409933ca954dSDavid Herrmann goto err; 410033ca954dSDavid Herrmann } 4101f48fd9c8SMarcel Holtmann 4102d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 4103d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 41046ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 41056ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 41066ead1bbcSJohan Hedberg error = -ENOMEM; 41076ead1bbcSJohan Hedberg goto err; 41086ead1bbcSJohan Hedberg } 41096ead1bbcSJohan Hedberg 41100153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 41110153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 41120153e2ecSMarcel Holtmann 4113bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 4114bdc3e0f1SMarcel Holtmann 4115bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 411633ca954dSDavid Herrmann if (error < 0) 411754506918SJohan Hedberg goto err_wqueue; 41181da177e4SLinus Torvalds 4119611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 4120a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 4121a8c5fb1aSGustavo Padovan hdev); 4122611b30f7SMarcel Holtmann if (hdev->rfkill) { 4123611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 4124611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 4125611b30f7SMarcel Holtmann hdev->rfkill = NULL; 4126611b30f7SMarcel Holtmann } 4127611b30f7SMarcel Holtmann } 4128611b30f7SMarcel Holtmann 41295e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 41305e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 41315e130367SJohan Hedberg 4132a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 4133004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 4134ce2be9acSAndrei Emeltchenko 413501cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 413656f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 413756f87901SJohan Hedberg * through reading supported features during init. 413856f87901SJohan Hedberg */ 413956f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 414056f87901SJohan Hedberg } 4141ce2be9acSAndrei Emeltchenko 4142fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 4143fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 4144fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 4145fcee3377SGustavo Padovan 41464a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 41474a964404SMarcel Holtmann * and should not be included in normal operation. 4148fee746b0SMarcel Holtmann */ 4149fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 41504a964404SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 4151fee746b0SMarcel Holtmann 41521da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 4153dc946bd8SDavid Herrmann hci_dev_hold(hdev); 41541da177e4SLinus Torvalds 415519202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 4156fbe96d6fSMarcel Holtmann 41571da177e4SLinus Torvalds return id; 4158f48fd9c8SMarcel Holtmann 415933ca954dSDavid Herrmann err_wqueue: 416033ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 41616ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 416233ca954dSDavid Herrmann err: 41633df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 4164f48fd9c8SMarcel Holtmann 416533ca954dSDavid Herrmann return error; 41661da177e4SLinus Torvalds } 41671da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 41681da177e4SLinus Torvalds 41691da177e4SLinus Torvalds /* Unregister HCI device */ 417059735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 41711da177e4SLinus Torvalds { 41723df92b31SSasha Levin int i, id; 4173ef222013SMarcel Holtmann 4174c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 41751da177e4SLinus Torvalds 417694324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 417794324962SJohan Hovold 41783df92b31SSasha Levin id = hdev->id; 41793df92b31SSasha Levin 4180f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 41811da177e4SLinus Torvalds list_del(&hdev->list); 4182f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 41831da177e4SLinus Torvalds 41841da177e4SLinus Torvalds hci_dev_do_close(hdev); 41851da177e4SLinus Torvalds 4186cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 4187ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 4188ef222013SMarcel Holtmann 4189b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 4190b9b5ef18SGustavo Padovan 4191ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 4192d603b76bSMarcel Holtmann !test_bit(HCI_SETUP, &hdev->dev_flags) && 4193d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 419409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 4195744cf19eSJohan Hedberg mgmt_index_removed(hdev); 419609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 419756e5cb86SJohan Hedberg } 4198ab81cbf9SJohan Hedberg 41992e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 42002e58ef3eSJohan Hedberg * pending list */ 42012e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 42022e58ef3eSJohan Hedberg 42031da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 42041da177e4SLinus Torvalds 4205611b30f7SMarcel Holtmann if (hdev->rfkill) { 4206611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 4207611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 4208611b30f7SMarcel Holtmann } 4209611b30f7SMarcel Holtmann 4210711eafe3SJohan Hedberg smp_unregister(hdev); 421199780a7bSJohan Hedberg 4212bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 4213147e2d59SDave Young 42140153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 42150153e2ecSMarcel Holtmann 4216f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 42176ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 4218f48fd9c8SMarcel Holtmann 421909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 4220dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 42216659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 42222aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 422355ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 4224b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 4225970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 42262763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 4227dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 4228373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 422909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 4230e2e0cacbSJohan Hedberg 4231dc946bd8SDavid Herrmann hci_dev_put(hdev); 42323df92b31SSasha Levin 42333df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 42341da177e4SLinus Torvalds } 42351da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 42361da177e4SLinus Torvalds 42371da177e4SLinus Torvalds /* Suspend HCI device */ 42381da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 42391da177e4SLinus Torvalds { 42401da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 42411da177e4SLinus Torvalds return 0; 42421da177e4SLinus Torvalds } 42431da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 42441da177e4SLinus Torvalds 42451da177e4SLinus Torvalds /* Resume HCI device */ 42461da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 42471da177e4SLinus Torvalds { 42481da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 42491da177e4SLinus Torvalds return 0; 42501da177e4SLinus Torvalds } 42511da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 42521da177e4SLinus Torvalds 425375e0569fSMarcel Holtmann /* Reset HCI device */ 425475e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 425575e0569fSMarcel Holtmann { 425675e0569fSMarcel Holtmann const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 425775e0569fSMarcel Holtmann struct sk_buff *skb; 425875e0569fSMarcel Holtmann 425975e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 426075e0569fSMarcel Holtmann if (!skb) 426175e0569fSMarcel Holtmann return -ENOMEM; 426275e0569fSMarcel Holtmann 426375e0569fSMarcel Holtmann bt_cb(skb)->pkt_type = HCI_EVENT_PKT; 426475e0569fSMarcel Holtmann memcpy(skb_put(skb, 3), hw_err, 3); 426575e0569fSMarcel Holtmann 426675e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 426775e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 426875e0569fSMarcel Holtmann } 426975e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 427075e0569fSMarcel Holtmann 427176bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 4272e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 427376bca880SMarcel Holtmann { 427476bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 427576bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 427676bca880SMarcel Holtmann kfree_skb(skb); 427776bca880SMarcel Holtmann return -ENXIO; 427876bca880SMarcel Holtmann } 427976bca880SMarcel Holtmann 4280d82603c6SJorrit Schippers /* Incoming skb */ 428176bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 428276bca880SMarcel Holtmann 428376bca880SMarcel Holtmann /* Time stamp */ 428476bca880SMarcel Holtmann __net_timestamp(skb); 428576bca880SMarcel Holtmann 428676bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 4287b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 4288c78ae283SMarcel Holtmann 428976bca880SMarcel Holtmann return 0; 429076bca880SMarcel Holtmann } 429176bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 429276bca880SMarcel Holtmann 429333e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 42941e429f38SGustavo F. Padovan int count, __u8 index) 429533e882a5SSuraj Sumangala { 429633e882a5SSuraj Sumangala int len = 0; 429733e882a5SSuraj Sumangala int hlen = 0; 429833e882a5SSuraj Sumangala int remain = count; 429933e882a5SSuraj Sumangala struct sk_buff *skb; 430033e882a5SSuraj Sumangala struct bt_skb_cb *scb; 430133e882a5SSuraj Sumangala 430233e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 430333e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 430433e882a5SSuraj Sumangala return -EILSEQ; 430533e882a5SSuraj Sumangala 430633e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 430733e882a5SSuraj Sumangala 430833e882a5SSuraj Sumangala if (!skb) { 430933e882a5SSuraj Sumangala switch (type) { 431033e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 431133e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 431233e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 431333e882a5SSuraj Sumangala break; 431433e882a5SSuraj Sumangala case HCI_EVENT_PKT: 431533e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 431633e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 431733e882a5SSuraj Sumangala break; 431833e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 431933e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 432033e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 432133e882a5SSuraj Sumangala break; 432233e882a5SSuraj Sumangala } 432333e882a5SSuraj Sumangala 43241e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 432533e882a5SSuraj Sumangala if (!skb) 432633e882a5SSuraj Sumangala return -ENOMEM; 432733e882a5SSuraj Sumangala 432833e882a5SSuraj Sumangala scb = (void *) skb->cb; 432933e882a5SSuraj Sumangala scb->expect = hlen; 433033e882a5SSuraj Sumangala scb->pkt_type = type; 433133e882a5SSuraj Sumangala 433233e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 433333e882a5SSuraj Sumangala } 433433e882a5SSuraj Sumangala 433533e882a5SSuraj Sumangala while (count) { 433633e882a5SSuraj Sumangala scb = (void *) skb->cb; 433789bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 433833e882a5SSuraj Sumangala 433933e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 434033e882a5SSuraj Sumangala 434133e882a5SSuraj Sumangala count -= len; 434233e882a5SSuraj Sumangala data += len; 434333e882a5SSuraj Sumangala scb->expect -= len; 434433e882a5SSuraj Sumangala remain = count; 434533e882a5SSuraj Sumangala 434633e882a5SSuraj Sumangala switch (type) { 434733e882a5SSuraj Sumangala case HCI_EVENT_PKT: 434833e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 434933e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 435033e882a5SSuraj Sumangala scb->expect = h->plen; 435133e882a5SSuraj Sumangala 435233e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 435333e882a5SSuraj Sumangala kfree_skb(skb); 435433e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 435533e882a5SSuraj Sumangala return -ENOMEM; 435633e882a5SSuraj Sumangala } 435733e882a5SSuraj Sumangala } 435833e882a5SSuraj Sumangala break; 435933e882a5SSuraj Sumangala 436033e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 436133e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 436233e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 436333e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 436433e882a5SSuraj Sumangala 436533e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 436633e882a5SSuraj Sumangala kfree_skb(skb); 436733e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 436833e882a5SSuraj Sumangala return -ENOMEM; 436933e882a5SSuraj Sumangala } 437033e882a5SSuraj Sumangala } 437133e882a5SSuraj Sumangala break; 437233e882a5SSuraj Sumangala 437333e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 437433e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 437533e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 437633e882a5SSuraj Sumangala scb->expect = h->dlen; 437733e882a5SSuraj Sumangala 437833e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 437933e882a5SSuraj Sumangala kfree_skb(skb); 438033e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 438133e882a5SSuraj Sumangala return -ENOMEM; 438233e882a5SSuraj Sumangala } 438333e882a5SSuraj Sumangala } 438433e882a5SSuraj Sumangala break; 438533e882a5SSuraj Sumangala } 438633e882a5SSuraj Sumangala 438733e882a5SSuraj Sumangala if (scb->expect == 0) { 438833e882a5SSuraj Sumangala /* Complete frame */ 438933e882a5SSuraj Sumangala 439033e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 4391e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 439233e882a5SSuraj Sumangala 439333e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 439433e882a5SSuraj Sumangala return remain; 439533e882a5SSuraj Sumangala } 439633e882a5SSuraj Sumangala } 439733e882a5SSuraj Sumangala 439833e882a5SSuraj Sumangala return remain; 439933e882a5SSuraj Sumangala } 440033e882a5SSuraj Sumangala 440199811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 440299811510SSuraj Sumangala 440399811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 440499811510SSuraj Sumangala { 440599811510SSuraj Sumangala int type; 440699811510SSuraj Sumangala int rem = 0; 440799811510SSuraj Sumangala 4408da5f6c37SGustavo F. Padovan while (count) { 440999811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 441099811510SSuraj Sumangala 441199811510SSuraj Sumangala if (!skb) { 441299811510SSuraj Sumangala struct { char type; } *pkt; 441399811510SSuraj Sumangala 441499811510SSuraj Sumangala /* Start of the frame */ 441599811510SSuraj Sumangala pkt = data; 441699811510SSuraj Sumangala type = pkt->type; 441799811510SSuraj Sumangala 441899811510SSuraj Sumangala data++; 441999811510SSuraj Sumangala count--; 442099811510SSuraj Sumangala } else 442199811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 442299811510SSuraj Sumangala 44231e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 44241e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 442599811510SSuraj Sumangala if (rem < 0) 442699811510SSuraj Sumangala return rem; 442799811510SSuraj Sumangala 442899811510SSuraj Sumangala data += (count - rem); 442999811510SSuraj Sumangala count = rem; 4430f81c6224SJoe Perches } 443199811510SSuraj Sumangala 443299811510SSuraj Sumangala return rem; 443399811510SSuraj Sumangala } 443499811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 443599811510SSuraj Sumangala 44361da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 44371da177e4SLinus Torvalds 44381da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 44391da177e4SLinus Torvalds { 44401da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 44411da177e4SLinus Torvalds 4442f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 44431da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 4444f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 44451da177e4SLinus Torvalds 44461da177e4SLinus Torvalds return 0; 44471da177e4SLinus Torvalds } 44481da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 44491da177e4SLinus Torvalds 44501da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 44511da177e4SLinus Torvalds { 44521da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 44531da177e4SLinus Torvalds 4454f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 44551da177e4SLinus Torvalds list_del(&cb->list); 4456f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 44571da177e4SLinus Torvalds 44581da177e4SLinus Torvalds return 0; 44591da177e4SLinus Torvalds } 44601da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 44611da177e4SLinus Torvalds 446251086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 44631da177e4SLinus Torvalds { 4464cdc52faaSMarcel Holtmann int err; 4465cdc52faaSMarcel Holtmann 44660d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 44671da177e4SLinus Torvalds 44681da177e4SLinus Torvalds /* Time stamp */ 4469a61bbcf2SPatrick McHardy __net_timestamp(skb); 44701da177e4SLinus Torvalds 4471cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4472cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4473cd82e61cSMarcel Holtmann 4474cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 4475cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 4476470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 44771da177e4SLinus Torvalds } 44781da177e4SLinus Torvalds 44791da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 44801da177e4SLinus Torvalds skb_orphan(skb); 44811da177e4SLinus Torvalds 4482cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 4483cdc52faaSMarcel Holtmann if (err < 0) { 4484cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 4485cdc52faaSMarcel Holtmann kfree_skb(skb); 4486cdc52faaSMarcel Holtmann } 44871da177e4SLinus Torvalds } 44881da177e4SLinus Torvalds 44893119ae95SJohan Hedberg void hci_req_init(struct hci_request *req, struct hci_dev *hdev) 44903119ae95SJohan Hedberg { 44913119ae95SJohan Hedberg skb_queue_head_init(&req->cmd_q); 44923119ae95SJohan Hedberg req->hdev = hdev; 44935d73e034SAndre Guedes req->err = 0; 44943119ae95SJohan Hedberg } 44953119ae95SJohan Hedberg 44963119ae95SJohan Hedberg int hci_req_run(struct hci_request *req, hci_req_complete_t complete) 44973119ae95SJohan Hedberg { 44983119ae95SJohan Hedberg struct hci_dev *hdev = req->hdev; 44993119ae95SJohan Hedberg struct sk_buff *skb; 45003119ae95SJohan Hedberg unsigned long flags; 45013119ae95SJohan Hedberg 45023119ae95SJohan Hedberg BT_DBG("length %u", skb_queue_len(&req->cmd_q)); 45033119ae95SJohan Hedberg 450449c922bbSStephen Hemminger /* If an error occurred during request building, remove all HCI 45055d73e034SAndre Guedes * commands queued on the HCI request queue. 45065d73e034SAndre Guedes */ 45075d73e034SAndre Guedes if (req->err) { 45085d73e034SAndre Guedes skb_queue_purge(&req->cmd_q); 45095d73e034SAndre Guedes return req->err; 45105d73e034SAndre Guedes } 45115d73e034SAndre Guedes 45123119ae95SJohan Hedberg /* Do not allow empty requests */ 45133119ae95SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 4514382b0c39SAndre Guedes return -ENODATA; 45153119ae95SJohan Hedberg 45163119ae95SJohan Hedberg skb = skb_peek_tail(&req->cmd_q); 45173119ae95SJohan Hedberg bt_cb(skb)->req.complete = complete; 45183119ae95SJohan Hedberg 45193119ae95SJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 45203119ae95SJohan Hedberg skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q); 45213119ae95SJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 45223119ae95SJohan Hedberg 45233119ae95SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 45243119ae95SJohan Hedberg 45253119ae95SJohan Hedberg return 0; 45263119ae95SJohan Hedberg } 45273119ae95SJohan Hedberg 4528899de765SMarcel Holtmann bool hci_req_pending(struct hci_dev *hdev) 4529899de765SMarcel Holtmann { 4530899de765SMarcel Holtmann return (hdev->req_status == HCI_REQ_PEND); 4531899de765SMarcel Holtmann } 4532899de765SMarcel Holtmann 45331ca3a9d0SJohan Hedberg static struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, 453407dc93ddSJohan Hedberg u32 plen, const void *param) 45351da177e4SLinus Torvalds { 45361da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 45371da177e4SLinus Torvalds struct hci_command_hdr *hdr; 45381da177e4SLinus Torvalds struct sk_buff *skb; 45391da177e4SLinus Torvalds 45401da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 45411ca3a9d0SJohan Hedberg if (!skb) 45421ca3a9d0SJohan Hedberg return NULL; 45431da177e4SLinus Torvalds 45441da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 4545a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 45461da177e4SLinus Torvalds hdr->plen = plen; 45471da177e4SLinus Torvalds 45481da177e4SLinus Torvalds if (plen) 45491da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 45501da177e4SLinus Torvalds 45511da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 45521da177e4SLinus Torvalds 45530d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 455443e73e4eSMarcel Holtmann bt_cb(skb)->opcode = opcode; 4555c78ae283SMarcel Holtmann 45561ca3a9d0SJohan Hedberg return skb; 45571ca3a9d0SJohan Hedberg } 45581ca3a9d0SJohan Hedberg 45591ca3a9d0SJohan Hedberg /* Send HCI command */ 456007dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 456107dc93ddSJohan Hedberg const void *param) 45621ca3a9d0SJohan Hedberg { 45631ca3a9d0SJohan Hedberg struct sk_buff *skb; 45641ca3a9d0SJohan Hedberg 45651ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 45661ca3a9d0SJohan Hedberg 45671ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 45681ca3a9d0SJohan Hedberg if (!skb) { 45691ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 45701ca3a9d0SJohan Hedberg return -ENOMEM; 45711ca3a9d0SJohan Hedberg } 45721ca3a9d0SJohan Hedberg 457349c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 457411714b3dSJohan Hedberg * single-command requests. 457511714b3dSJohan Hedberg */ 457611714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 457711714b3dSJohan Hedberg 45781da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 4579c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 45801da177e4SLinus Torvalds 45811da177e4SLinus Torvalds return 0; 45821da177e4SLinus Torvalds } 45831da177e4SLinus Torvalds 458471c76a17SJohan Hedberg /* Queue a command to an asynchronous HCI request */ 458507dc93ddSJohan Hedberg void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen, 458607dc93ddSJohan Hedberg const void *param, u8 event) 458771c76a17SJohan Hedberg { 458871c76a17SJohan Hedberg struct hci_dev *hdev = req->hdev; 458971c76a17SJohan Hedberg struct sk_buff *skb; 459071c76a17SJohan Hedberg 459171c76a17SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 459271c76a17SJohan Hedberg 459349c922bbSStephen Hemminger /* If an error occurred during request building, there is no point in 459434739c1eSAndre Guedes * queueing the HCI command. We can simply return. 459534739c1eSAndre Guedes */ 459634739c1eSAndre Guedes if (req->err) 459734739c1eSAndre Guedes return; 459834739c1eSAndre Guedes 459971c76a17SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 460071c76a17SJohan Hedberg if (!skb) { 46015d73e034SAndre Guedes BT_ERR("%s no memory for command (opcode 0x%4.4x)", 46025d73e034SAndre Guedes hdev->name, opcode); 46035d73e034SAndre Guedes req->err = -ENOMEM; 4604e348fe6bSAndre Guedes return; 460571c76a17SJohan Hedberg } 460671c76a17SJohan Hedberg 460771c76a17SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 460871c76a17SJohan Hedberg bt_cb(skb)->req.start = true; 460971c76a17SJohan Hedberg 461002350a72SJohan Hedberg bt_cb(skb)->req.event = event; 461102350a72SJohan Hedberg 461271c76a17SJohan Hedberg skb_queue_tail(&req->cmd_q, skb); 461371c76a17SJohan Hedberg } 461471c76a17SJohan Hedberg 461507dc93ddSJohan Hedberg void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, 461607dc93ddSJohan Hedberg const void *param) 461702350a72SJohan Hedberg { 461802350a72SJohan Hedberg hci_req_add_ev(req, opcode, plen, param, 0); 461902350a72SJohan Hedberg } 462002350a72SJohan Hedberg 46211da177e4SLinus Torvalds /* Get data from the previously sent command */ 4622a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 46231da177e4SLinus Torvalds { 46241da177e4SLinus Torvalds struct hci_command_hdr *hdr; 46251da177e4SLinus Torvalds 46261da177e4SLinus Torvalds if (!hdev->sent_cmd) 46271da177e4SLinus Torvalds return NULL; 46281da177e4SLinus Torvalds 46291da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 46301da177e4SLinus Torvalds 4631a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 46321da177e4SLinus Torvalds return NULL; 46331da177e4SLinus Torvalds 4634f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 46351da177e4SLinus Torvalds 46361da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 46371da177e4SLinus Torvalds } 46381da177e4SLinus Torvalds 46391da177e4SLinus Torvalds /* Send ACL data */ 46401da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 46411da177e4SLinus Torvalds { 46421da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 46431da177e4SLinus Torvalds int len = skb->len; 46441da177e4SLinus Torvalds 4645badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 4646badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 46479c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 4648aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 4649aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 46501da177e4SLinus Torvalds } 46511da177e4SLinus Torvalds 4652ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 465373d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 46541da177e4SLinus Torvalds { 4655ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 46561da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 46571da177e4SLinus Torvalds struct sk_buff *list; 46581da177e4SLinus Torvalds 4659087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 4660087bfd99SGustavo Padovan skb->data_len = 0; 4661087bfd99SGustavo Padovan 4662087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4663204a6e54SAndrei Emeltchenko 4664204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 4665204a6e54SAndrei Emeltchenko case HCI_BREDR: 4666087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 4667204a6e54SAndrei Emeltchenko break; 4668204a6e54SAndrei Emeltchenko case HCI_AMP: 4669204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 4670204a6e54SAndrei Emeltchenko break; 4671204a6e54SAndrei Emeltchenko default: 4672204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 4673204a6e54SAndrei Emeltchenko return; 4674204a6e54SAndrei Emeltchenko } 4675087bfd99SGustavo Padovan 467670f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 467770f23020SAndrei Emeltchenko if (!list) { 46781da177e4SLinus Torvalds /* Non fragmented */ 46791da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 46801da177e4SLinus Torvalds 468173d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 46821da177e4SLinus Torvalds } else { 46831da177e4SLinus Torvalds /* Fragmented */ 46841da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 46851da177e4SLinus Torvalds 46861da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 46871da177e4SLinus Torvalds 46889cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 46899cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 46909cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 46919cfd5a23SJukka Rissanen * deadlocks. 46929cfd5a23SJukka Rissanen */ 46939cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 46941da177e4SLinus Torvalds 469573d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 4696e702112fSAndrei Emeltchenko 4697e702112fSAndrei Emeltchenko flags &= ~ACL_START; 4698e702112fSAndrei Emeltchenko flags |= ACL_CONT; 46991da177e4SLinus Torvalds do { 47001da177e4SLinus Torvalds skb = list; list = list->next; 47011da177e4SLinus Torvalds 47020d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4703e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 47041da177e4SLinus Torvalds 47051da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 47061da177e4SLinus Torvalds 470773d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 47081da177e4SLinus Torvalds } while (list); 47091da177e4SLinus Torvalds 47109cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 47111da177e4SLinus Torvalds } 471273d80debSLuiz Augusto von Dentz } 471373d80debSLuiz Augusto von Dentz 471473d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 471573d80debSLuiz Augusto von Dentz { 4716ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 471773d80debSLuiz Augusto von Dentz 4718f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 471973d80debSLuiz Augusto von Dentz 4720ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 47211da177e4SLinus Torvalds 47223eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 47231da177e4SLinus Torvalds } 47241da177e4SLinus Torvalds 47251da177e4SLinus Torvalds /* Send SCO data */ 47260d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 47271da177e4SLinus Torvalds { 47281da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 47291da177e4SLinus Torvalds struct hci_sco_hdr hdr; 47301da177e4SLinus Torvalds 47311da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 47321da177e4SLinus Torvalds 4733aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 47341da177e4SLinus Torvalds hdr.dlen = skb->len; 47351da177e4SLinus Torvalds 4736badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 4737badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 47389c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 47391da177e4SLinus Torvalds 47400d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 4741c78ae283SMarcel Holtmann 47421da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 47433eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 47441da177e4SLinus Torvalds } 47451da177e4SLinus Torvalds 47461da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 47471da177e4SLinus Torvalds 47481da177e4SLinus Torvalds /* HCI Connection scheduler */ 47496039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 4750a8c5fb1aSGustavo Padovan int *quote) 47511da177e4SLinus Torvalds { 47521da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 47538035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 4754abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 47551da177e4SLinus Torvalds 47561da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 47571da177e4SLinus Torvalds * added and removed with TX task disabled. */ 4758bf4c6325SGustavo F. Padovan 4759bf4c6325SGustavo F. Padovan rcu_read_lock(); 4760bf4c6325SGustavo F. Padovan 4761bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4762769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 47631da177e4SLinus Torvalds continue; 4764769be974SMarcel Holtmann 4765769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 4766769be974SMarcel Holtmann continue; 4767769be974SMarcel Holtmann 47681da177e4SLinus Torvalds num++; 47691da177e4SLinus Torvalds 47701da177e4SLinus Torvalds if (c->sent < min) { 47711da177e4SLinus Torvalds min = c->sent; 47721da177e4SLinus Torvalds conn = c; 47731da177e4SLinus Torvalds } 477452087a79SLuiz Augusto von Dentz 477552087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 477652087a79SLuiz Augusto von Dentz break; 47771da177e4SLinus Torvalds } 47781da177e4SLinus Torvalds 4779bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4780bf4c6325SGustavo F. Padovan 47811da177e4SLinus Torvalds if (conn) { 47826ed58ec5SVille Tervo int cnt, q; 47836ed58ec5SVille Tervo 47846ed58ec5SVille Tervo switch (conn->type) { 47856ed58ec5SVille Tervo case ACL_LINK: 47866ed58ec5SVille Tervo cnt = hdev->acl_cnt; 47876ed58ec5SVille Tervo break; 47886ed58ec5SVille Tervo case SCO_LINK: 47896ed58ec5SVille Tervo case ESCO_LINK: 47906ed58ec5SVille Tervo cnt = hdev->sco_cnt; 47916ed58ec5SVille Tervo break; 47926ed58ec5SVille Tervo case LE_LINK: 47936ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 47946ed58ec5SVille Tervo break; 47956ed58ec5SVille Tervo default: 47966ed58ec5SVille Tervo cnt = 0; 47976ed58ec5SVille Tervo BT_ERR("Unknown link type"); 47986ed58ec5SVille Tervo } 47996ed58ec5SVille Tervo 48006ed58ec5SVille Tervo q = cnt / num; 48011da177e4SLinus Torvalds *quote = q ? q : 1; 48021da177e4SLinus Torvalds } else 48031da177e4SLinus Torvalds *quote = 0; 48041da177e4SLinus Torvalds 48051da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 48061da177e4SLinus Torvalds return conn; 48071da177e4SLinus Torvalds } 48081da177e4SLinus Torvalds 48096039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 48101da177e4SLinus Torvalds { 48111da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 48121da177e4SLinus Torvalds struct hci_conn *c; 48131da177e4SLinus Torvalds 4814bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 48151da177e4SLinus Torvalds 4816bf4c6325SGustavo F. Padovan rcu_read_lock(); 4817bf4c6325SGustavo F. Padovan 48181da177e4SLinus Torvalds /* Kill stalled connections */ 4819bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4820bae1f5d9SVille Tervo if (c->type == type && c->sent) { 48216ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 48226ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 4823bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 48241da177e4SLinus Torvalds } 48251da177e4SLinus Torvalds } 4826bf4c6325SGustavo F. Padovan 4827bf4c6325SGustavo F. Padovan rcu_read_unlock(); 48281da177e4SLinus Torvalds } 48291da177e4SLinus Torvalds 48306039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 483173d80debSLuiz Augusto von Dentz int *quote) 483273d80debSLuiz Augusto von Dentz { 483373d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 483473d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 4835abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 483673d80debSLuiz Augusto von Dentz struct hci_conn *conn; 483773d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 483873d80debSLuiz Augusto von Dentz 483973d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 484073d80debSLuiz Augusto von Dentz 4841bf4c6325SGustavo F. Padovan rcu_read_lock(); 4842bf4c6325SGustavo F. Padovan 4843bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 484473d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 484573d80debSLuiz Augusto von Dentz 484673d80debSLuiz Augusto von Dentz if (conn->type != type) 484773d80debSLuiz Augusto von Dentz continue; 484873d80debSLuiz Augusto von Dentz 484973d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 485073d80debSLuiz Augusto von Dentz continue; 485173d80debSLuiz Augusto von Dentz 485273d80debSLuiz Augusto von Dentz conn_num++; 485373d80debSLuiz Augusto von Dentz 48548192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 485573d80debSLuiz Augusto von Dentz struct sk_buff *skb; 485673d80debSLuiz Augusto von Dentz 485773d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 485873d80debSLuiz Augusto von Dentz continue; 485973d80debSLuiz Augusto von Dentz 486073d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 486173d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 486273d80debSLuiz Augusto von Dentz continue; 486373d80debSLuiz Augusto von Dentz 486473d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 486573d80debSLuiz Augusto von Dentz num = 0; 486673d80debSLuiz Augusto von Dentz min = ~0; 486773d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 486873d80debSLuiz Augusto von Dentz } 486973d80debSLuiz Augusto von Dentz 487073d80debSLuiz Augusto von Dentz num++; 487173d80debSLuiz Augusto von Dentz 487273d80debSLuiz Augusto von Dentz if (conn->sent < min) { 487373d80debSLuiz Augusto von Dentz min = conn->sent; 487473d80debSLuiz Augusto von Dentz chan = tmp; 487573d80debSLuiz Augusto von Dentz } 487673d80debSLuiz Augusto von Dentz } 487773d80debSLuiz Augusto von Dentz 487873d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 487973d80debSLuiz Augusto von Dentz break; 488073d80debSLuiz Augusto von Dentz } 488173d80debSLuiz Augusto von Dentz 4882bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4883bf4c6325SGustavo F. Padovan 488473d80debSLuiz Augusto von Dentz if (!chan) 488573d80debSLuiz Augusto von Dentz return NULL; 488673d80debSLuiz Augusto von Dentz 488773d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 488873d80debSLuiz Augusto von Dentz case ACL_LINK: 488973d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 489073d80debSLuiz Augusto von Dentz break; 4891bd1eb66bSAndrei Emeltchenko case AMP_LINK: 4892bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 4893bd1eb66bSAndrei Emeltchenko break; 489473d80debSLuiz Augusto von Dentz case SCO_LINK: 489573d80debSLuiz Augusto von Dentz case ESCO_LINK: 489673d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 489773d80debSLuiz Augusto von Dentz break; 489873d80debSLuiz Augusto von Dentz case LE_LINK: 489973d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 490073d80debSLuiz Augusto von Dentz break; 490173d80debSLuiz Augusto von Dentz default: 490273d80debSLuiz Augusto von Dentz cnt = 0; 490373d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 490473d80debSLuiz Augusto von Dentz } 490573d80debSLuiz Augusto von Dentz 490673d80debSLuiz Augusto von Dentz q = cnt / num; 490773d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 490873d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 490973d80debSLuiz Augusto von Dentz return chan; 491073d80debSLuiz Augusto von Dentz } 491173d80debSLuiz Augusto von Dentz 491202b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 491302b20f0bSLuiz Augusto von Dentz { 491402b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 491502b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 491602b20f0bSLuiz Augusto von Dentz int num = 0; 491702b20f0bSLuiz Augusto von Dentz 491802b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 491902b20f0bSLuiz Augusto von Dentz 4920bf4c6325SGustavo F. Padovan rcu_read_lock(); 4921bf4c6325SGustavo F. Padovan 4922bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 492302b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 492402b20f0bSLuiz Augusto von Dentz 492502b20f0bSLuiz Augusto von Dentz if (conn->type != type) 492602b20f0bSLuiz Augusto von Dentz continue; 492702b20f0bSLuiz Augusto von Dentz 492802b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 492902b20f0bSLuiz Augusto von Dentz continue; 493002b20f0bSLuiz Augusto von Dentz 493102b20f0bSLuiz Augusto von Dentz num++; 493202b20f0bSLuiz Augusto von Dentz 49338192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 493402b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 493502b20f0bSLuiz Augusto von Dentz 493602b20f0bSLuiz Augusto von Dentz if (chan->sent) { 493702b20f0bSLuiz Augusto von Dentz chan->sent = 0; 493802b20f0bSLuiz Augusto von Dentz continue; 493902b20f0bSLuiz Augusto von Dentz } 494002b20f0bSLuiz Augusto von Dentz 494102b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 494202b20f0bSLuiz Augusto von Dentz continue; 494302b20f0bSLuiz Augusto von Dentz 494402b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 494502b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 494602b20f0bSLuiz Augusto von Dentz continue; 494702b20f0bSLuiz Augusto von Dentz 494802b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 494902b20f0bSLuiz Augusto von Dentz 495002b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 495102b20f0bSLuiz Augusto von Dentz skb->priority); 495202b20f0bSLuiz Augusto von Dentz } 495302b20f0bSLuiz Augusto von Dentz 495402b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 495502b20f0bSLuiz Augusto von Dentz break; 495602b20f0bSLuiz Augusto von Dentz } 4957bf4c6325SGustavo F. Padovan 4958bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4959bf4c6325SGustavo F. Padovan 496002b20f0bSLuiz Augusto von Dentz } 496102b20f0bSLuiz Augusto von Dentz 4962b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 4963b71d385aSAndrei Emeltchenko { 4964b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 4965b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 4966b71d385aSAndrei Emeltchenko } 4967b71d385aSAndrei Emeltchenko 49686039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 49691da177e4SLinus Torvalds { 49704a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 49711da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 49721da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 497363d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 49745f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 4975bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 49761da177e4SLinus Torvalds } 497763d2bc1bSAndrei Emeltchenko } 49781da177e4SLinus Torvalds 49796039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 498063d2bc1bSAndrei Emeltchenko { 498163d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 498263d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 498363d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 498463d2bc1bSAndrei Emeltchenko int quote; 498563d2bc1bSAndrei Emeltchenko 498663d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 498704837f64SMarcel Holtmann 498873d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 498973d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 4990ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4991ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 499273d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 499373d80debSLuiz Augusto von Dentz skb->len, skb->priority); 499473d80debSLuiz Augusto von Dentz 4995ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4996ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4997ec1cce24SLuiz Augusto von Dentz break; 4998ec1cce24SLuiz Augusto von Dentz 4999ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 5000ec1cce24SLuiz Augusto von Dentz 500173d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 500273d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 500304837f64SMarcel Holtmann 500457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 50051da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 50061da177e4SLinus Torvalds 50071da177e4SLinus Torvalds hdev->acl_cnt--; 500873d80debSLuiz Augusto von Dentz chan->sent++; 500973d80debSLuiz Augusto von Dentz chan->conn->sent++; 50101da177e4SLinus Torvalds } 50111da177e4SLinus Torvalds } 501202b20f0bSLuiz Augusto von Dentz 501302b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 501402b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 50151da177e4SLinus Torvalds } 50161da177e4SLinus Torvalds 50176039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 5018b71d385aSAndrei Emeltchenko { 501963d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 5020b71d385aSAndrei Emeltchenko struct hci_chan *chan; 5021b71d385aSAndrei Emeltchenko struct sk_buff *skb; 5022b71d385aSAndrei Emeltchenko int quote; 5023bd1eb66bSAndrei Emeltchenko u8 type; 5024b71d385aSAndrei Emeltchenko 502563d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 5026b71d385aSAndrei Emeltchenko 5027bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 5028bd1eb66bSAndrei Emeltchenko 5029bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 5030bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 5031bd1eb66bSAndrei Emeltchenko else 5032bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 5033bd1eb66bSAndrei Emeltchenko 5034b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 5035bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 5036b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 5037b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 5038b71d385aSAndrei Emeltchenko int blocks; 5039b71d385aSAndrei Emeltchenko 5040b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 5041b71d385aSAndrei Emeltchenko skb->len, skb->priority); 5042b71d385aSAndrei Emeltchenko 5043b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 5044b71d385aSAndrei Emeltchenko if (skb->priority < priority) 5045b71d385aSAndrei Emeltchenko break; 5046b71d385aSAndrei Emeltchenko 5047b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 5048b71d385aSAndrei Emeltchenko 5049b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 5050b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 5051b71d385aSAndrei Emeltchenko return; 5052b71d385aSAndrei Emeltchenko 5053b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 5054b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 5055b71d385aSAndrei Emeltchenko 505657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 5057b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 5058b71d385aSAndrei Emeltchenko 5059b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 5060b71d385aSAndrei Emeltchenko quote -= blocks; 5061b71d385aSAndrei Emeltchenko 5062b71d385aSAndrei Emeltchenko chan->sent += blocks; 5063b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 5064b71d385aSAndrei Emeltchenko } 5065b71d385aSAndrei Emeltchenko } 5066b71d385aSAndrei Emeltchenko 5067b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 5068bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 5069b71d385aSAndrei Emeltchenko } 5070b71d385aSAndrei Emeltchenko 50716039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 5072b71d385aSAndrei Emeltchenko { 5073b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 5074b71d385aSAndrei Emeltchenko 5075bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 5076bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 5077bd1eb66bSAndrei Emeltchenko return; 5078bd1eb66bSAndrei Emeltchenko 5079bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 5080bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 5081b71d385aSAndrei Emeltchenko return; 5082b71d385aSAndrei Emeltchenko 5083b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 5084b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 5085b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 5086b71d385aSAndrei Emeltchenko break; 5087b71d385aSAndrei Emeltchenko 5088b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 5089b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 5090b71d385aSAndrei Emeltchenko break; 5091b71d385aSAndrei Emeltchenko } 5092b71d385aSAndrei Emeltchenko } 5093b71d385aSAndrei Emeltchenko 50941da177e4SLinus Torvalds /* Schedule SCO */ 50956039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 50961da177e4SLinus Torvalds { 50971da177e4SLinus Torvalds struct hci_conn *conn; 50981da177e4SLinus Torvalds struct sk_buff *skb; 50991da177e4SLinus Torvalds int quote; 51001da177e4SLinus Torvalds 51011da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 51021da177e4SLinus Torvalds 510352087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 510452087a79SLuiz Augusto von Dentz return; 510552087a79SLuiz Augusto von Dentz 51061da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 51071da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 51081da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 510957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 51101da177e4SLinus Torvalds 51111da177e4SLinus Torvalds conn->sent++; 51121da177e4SLinus Torvalds if (conn->sent == ~0) 51131da177e4SLinus Torvalds conn->sent = 0; 51141da177e4SLinus Torvalds } 51151da177e4SLinus Torvalds } 51161da177e4SLinus Torvalds } 51171da177e4SLinus Torvalds 51186039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 5119b6a0dc82SMarcel Holtmann { 5120b6a0dc82SMarcel Holtmann struct hci_conn *conn; 5121b6a0dc82SMarcel Holtmann struct sk_buff *skb; 5122b6a0dc82SMarcel Holtmann int quote; 5123b6a0dc82SMarcel Holtmann 5124b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 5125b6a0dc82SMarcel Holtmann 512652087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 512752087a79SLuiz Augusto von Dentz return; 512852087a79SLuiz Augusto von Dentz 51298fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 51308fc9ced3SGustavo Padovan "e))) { 5131b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 5132b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 513357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 5134b6a0dc82SMarcel Holtmann 5135b6a0dc82SMarcel Holtmann conn->sent++; 5136b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 5137b6a0dc82SMarcel Holtmann conn->sent = 0; 5138b6a0dc82SMarcel Holtmann } 5139b6a0dc82SMarcel Holtmann } 5140b6a0dc82SMarcel Holtmann } 5141b6a0dc82SMarcel Holtmann 51426039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 51436ed58ec5SVille Tervo { 514473d80debSLuiz Augusto von Dentz struct hci_chan *chan; 51456ed58ec5SVille Tervo struct sk_buff *skb; 514602b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 51476ed58ec5SVille Tervo 51486ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 51496ed58ec5SVille Tervo 515052087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 515152087a79SLuiz Augusto von Dentz return; 515252087a79SLuiz Augusto von Dentz 51534a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 51546ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 51556ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 5156bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 51576ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 5158bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 51596ed58ec5SVille Tervo } 51606ed58ec5SVille Tervo 51616ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 516202b20f0bSLuiz Augusto von Dentz tmp = cnt; 516373d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 5164ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 5165ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 516673d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 516773d80debSLuiz Augusto von Dentz skb->len, skb->priority); 51686ed58ec5SVille Tervo 5169ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 5170ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 5171ec1cce24SLuiz Augusto von Dentz break; 5172ec1cce24SLuiz Augusto von Dentz 5173ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 5174ec1cce24SLuiz Augusto von Dentz 517557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 51766ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 51776ed58ec5SVille Tervo 51786ed58ec5SVille Tervo cnt--; 517973d80debSLuiz Augusto von Dentz chan->sent++; 518073d80debSLuiz Augusto von Dentz chan->conn->sent++; 51816ed58ec5SVille Tervo } 51826ed58ec5SVille Tervo } 518373d80debSLuiz Augusto von Dentz 51846ed58ec5SVille Tervo if (hdev->le_pkts) 51856ed58ec5SVille Tervo hdev->le_cnt = cnt; 51866ed58ec5SVille Tervo else 51876ed58ec5SVille Tervo hdev->acl_cnt = cnt; 518802b20f0bSLuiz Augusto von Dentz 518902b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 519002b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 51916ed58ec5SVille Tervo } 51926ed58ec5SVille Tervo 51933eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 51941da177e4SLinus Torvalds { 51953eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 51961da177e4SLinus Torvalds struct sk_buff *skb; 51971da177e4SLinus Torvalds 51986ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 51996ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 52001da177e4SLinus Torvalds 520152de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 52021da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 52031da177e4SLinus Torvalds hci_sched_acl(hdev); 52041da177e4SLinus Torvalds hci_sched_sco(hdev); 5205b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 52066ed58ec5SVille Tervo hci_sched_le(hdev); 520752de599eSMarcel Holtmann } 52086ed58ec5SVille Tervo 52091da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 52101da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 521157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 52121da177e4SLinus Torvalds } 52131da177e4SLinus Torvalds 521425985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 52151da177e4SLinus Torvalds 52161da177e4SLinus Torvalds /* ACL data packet */ 52176039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 52181da177e4SLinus Torvalds { 52191da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 52201da177e4SLinus Torvalds struct hci_conn *conn; 52211da177e4SLinus Torvalds __u16 handle, flags; 52221da177e4SLinus Torvalds 52231da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 52241da177e4SLinus Torvalds 52251da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 52261da177e4SLinus Torvalds flags = hci_flags(handle); 52271da177e4SLinus Torvalds handle = hci_handle(handle); 52281da177e4SLinus Torvalds 5229f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 5230a8c5fb1aSGustavo Padovan handle, flags); 52311da177e4SLinus Torvalds 52321da177e4SLinus Torvalds hdev->stat.acl_rx++; 52331da177e4SLinus Torvalds 52341da177e4SLinus Torvalds hci_dev_lock(hdev); 52351da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 52361da177e4SLinus Torvalds hci_dev_unlock(hdev); 52371da177e4SLinus Torvalds 52381da177e4SLinus Torvalds if (conn) { 523965983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 524004837f64SMarcel Holtmann 52411da177e4SLinus Torvalds /* Send to upper protocol */ 5242686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 52431da177e4SLinus Torvalds return; 52441da177e4SLinus Torvalds } else { 52451da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 52461da177e4SLinus Torvalds hdev->name, handle); 52471da177e4SLinus Torvalds } 52481da177e4SLinus Torvalds 52491da177e4SLinus Torvalds kfree_skb(skb); 52501da177e4SLinus Torvalds } 52511da177e4SLinus Torvalds 52521da177e4SLinus Torvalds /* SCO data packet */ 52536039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 52541da177e4SLinus Torvalds { 52551da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 52561da177e4SLinus Torvalds struct hci_conn *conn; 52571da177e4SLinus Torvalds __u16 handle; 52581da177e4SLinus Torvalds 52591da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 52601da177e4SLinus Torvalds 52611da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 52621da177e4SLinus Torvalds 5263f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 52641da177e4SLinus Torvalds 52651da177e4SLinus Torvalds hdev->stat.sco_rx++; 52661da177e4SLinus Torvalds 52671da177e4SLinus Torvalds hci_dev_lock(hdev); 52681da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 52691da177e4SLinus Torvalds hci_dev_unlock(hdev); 52701da177e4SLinus Torvalds 52711da177e4SLinus Torvalds if (conn) { 52721da177e4SLinus Torvalds /* Send to upper protocol */ 5273686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 52741da177e4SLinus Torvalds return; 52751da177e4SLinus Torvalds } else { 52761da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 52771da177e4SLinus Torvalds hdev->name, handle); 52781da177e4SLinus Torvalds } 52791da177e4SLinus Torvalds 52801da177e4SLinus Torvalds kfree_skb(skb); 52811da177e4SLinus Torvalds } 52821da177e4SLinus Torvalds 52839238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 52849238f36aSJohan Hedberg { 52859238f36aSJohan Hedberg struct sk_buff *skb; 52869238f36aSJohan Hedberg 52879238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 52889238f36aSJohan Hedberg if (!skb) 52899238f36aSJohan Hedberg return true; 52909238f36aSJohan Hedberg 52919238f36aSJohan Hedberg return bt_cb(skb)->req.start; 52929238f36aSJohan Hedberg } 52939238f36aSJohan Hedberg 529442c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 529542c6b129SJohan Hedberg { 529642c6b129SJohan Hedberg struct hci_command_hdr *sent; 529742c6b129SJohan Hedberg struct sk_buff *skb; 529842c6b129SJohan Hedberg u16 opcode; 529942c6b129SJohan Hedberg 530042c6b129SJohan Hedberg if (!hdev->sent_cmd) 530142c6b129SJohan Hedberg return; 530242c6b129SJohan Hedberg 530342c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 530442c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 530542c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 530642c6b129SJohan Hedberg return; 530742c6b129SJohan Hedberg 530842c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 530942c6b129SJohan Hedberg if (!skb) 531042c6b129SJohan Hedberg return; 531142c6b129SJohan Hedberg 531242c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 531342c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 531442c6b129SJohan Hedberg } 531542c6b129SJohan Hedberg 53169238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 53179238f36aSJohan Hedberg { 53189238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 53199238f36aSJohan Hedberg struct sk_buff *skb; 53209238f36aSJohan Hedberg unsigned long flags; 53219238f36aSJohan Hedberg 53229238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 53239238f36aSJohan Hedberg 532442c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 532542c6b129SJohan Hedberg * sent we need to do special handling of it. 53269238f36aSJohan Hedberg */ 532742c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 532842c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 532942c6b129SJohan Hedberg * reset complete event during init and any pending 533042c6b129SJohan Hedberg * command will never be completed. In such a case we 533142c6b129SJohan Hedberg * need to resend whatever was the last sent 533242c6b129SJohan Hedberg * command. 533342c6b129SJohan Hedberg */ 533442c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 533542c6b129SJohan Hedberg hci_resend_last(hdev); 533642c6b129SJohan Hedberg 53379238f36aSJohan Hedberg return; 533842c6b129SJohan Hedberg } 53399238f36aSJohan Hedberg 53409238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 53419238f36aSJohan Hedberg * this request the request is not yet complete. 53429238f36aSJohan Hedberg */ 53439238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 53449238f36aSJohan Hedberg return; 53459238f36aSJohan Hedberg 53469238f36aSJohan Hedberg /* If this was the last command in a request the complete 53479238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 53489238f36aSJohan Hedberg * command queue (hdev->cmd_q). 53499238f36aSJohan Hedberg */ 53509238f36aSJohan Hedberg if (hdev->sent_cmd) { 53519238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 535253e21fbcSJohan Hedberg 535353e21fbcSJohan Hedberg if (req_complete) { 535453e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 535553e21fbcSJohan Hedberg * avoid calling the callback more than once if 535653e21fbcSJohan Hedberg * this function gets called again. 535753e21fbcSJohan Hedberg */ 535853e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 535953e21fbcSJohan Hedberg 53609238f36aSJohan Hedberg goto call_complete; 53619238f36aSJohan Hedberg } 536253e21fbcSJohan Hedberg } 53639238f36aSJohan Hedberg 53649238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 53659238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 53669238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 53679238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 53689238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 53699238f36aSJohan Hedberg break; 53709238f36aSJohan Hedberg } 53719238f36aSJohan Hedberg 53729238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 53739238f36aSJohan Hedberg kfree_skb(skb); 53749238f36aSJohan Hedberg } 53759238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 53769238f36aSJohan Hedberg 53779238f36aSJohan Hedberg call_complete: 53789238f36aSJohan Hedberg if (req_complete) 53799238f36aSJohan Hedberg req_complete(hdev, status); 53809238f36aSJohan Hedberg } 53819238f36aSJohan Hedberg 5382b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 53831da177e4SLinus Torvalds { 5384b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 53851da177e4SLinus Torvalds struct sk_buff *skb; 53861da177e4SLinus Torvalds 53871da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 53881da177e4SLinus Torvalds 53891da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 5390cd82e61cSMarcel Holtmann /* Send copy to monitor */ 5391cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 5392cd82e61cSMarcel Holtmann 53931da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 53941da177e4SLinus Torvalds /* Send copy to the sockets */ 5395470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 53961da177e4SLinus Torvalds } 53971da177e4SLinus Torvalds 5398fee746b0SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 53991da177e4SLinus Torvalds kfree_skb(skb); 54001da177e4SLinus Torvalds continue; 54011da177e4SLinus Torvalds } 54021da177e4SLinus Torvalds 54031da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 54041da177e4SLinus Torvalds /* Don't process data packets in this states. */ 54050d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 54061da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 54071da177e4SLinus Torvalds case HCI_SCODATA_PKT: 54081da177e4SLinus Torvalds kfree_skb(skb); 54091da177e4SLinus Torvalds continue; 54103ff50b79SStephen Hemminger } 54111da177e4SLinus Torvalds } 54121da177e4SLinus Torvalds 54131da177e4SLinus Torvalds /* Process frame */ 54140d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 54151da177e4SLinus Torvalds case HCI_EVENT_PKT: 5416b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 54171da177e4SLinus Torvalds hci_event_packet(hdev, skb); 54181da177e4SLinus Torvalds break; 54191da177e4SLinus Torvalds 54201da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 54211da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 54221da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 54231da177e4SLinus Torvalds break; 54241da177e4SLinus Torvalds 54251da177e4SLinus Torvalds case HCI_SCODATA_PKT: 54261da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 54271da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 54281da177e4SLinus Torvalds break; 54291da177e4SLinus Torvalds 54301da177e4SLinus Torvalds default: 54311da177e4SLinus Torvalds kfree_skb(skb); 54321da177e4SLinus Torvalds break; 54331da177e4SLinus Torvalds } 54341da177e4SLinus Torvalds } 54351da177e4SLinus Torvalds } 54361da177e4SLinus Torvalds 5437c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 54381da177e4SLinus Torvalds { 5439c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 54401da177e4SLinus Torvalds struct sk_buff *skb; 54411da177e4SLinus Torvalds 54422104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 54432104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 54441da177e4SLinus Torvalds 54451da177e4SLinus Torvalds /* Send queued commands */ 54465a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 54475a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 54485a08ecceSAndrei Emeltchenko if (!skb) 54495a08ecceSAndrei Emeltchenko return; 54505a08ecceSAndrei Emeltchenko 54511da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 54521da177e4SLinus Torvalds 5453a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 545470f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 54551da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 545657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 54577bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 545865cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 54597bdb8a5cSSzymon Janc else 546065cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 546165cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 54621da177e4SLinus Torvalds } else { 54631da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 5464c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 54651da177e4SLinus Torvalds } 54661da177e4SLinus Torvalds } 54671da177e4SLinus Torvalds } 5468b1efcc28SAndre Guedes 5469b1efcc28SAndre Guedes void hci_req_add_le_scan_disable(struct hci_request *req) 5470b1efcc28SAndre Guedes { 5471b1efcc28SAndre Guedes struct hci_cp_le_set_scan_enable cp; 5472b1efcc28SAndre Guedes 5473b1efcc28SAndre Guedes memset(&cp, 0, sizeof(cp)); 5474b1efcc28SAndre Guedes cp.enable = LE_SCAN_DISABLE; 5475b1efcc28SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 5476b1efcc28SAndre Guedes } 5477a4790dbdSAndre Guedes 54788540f6c0SMarcel Holtmann static void add_to_white_list(struct hci_request *req, 54798540f6c0SMarcel Holtmann struct hci_conn_params *params) 54808540f6c0SMarcel Holtmann { 54818540f6c0SMarcel Holtmann struct hci_cp_le_add_to_white_list cp; 54828540f6c0SMarcel Holtmann 54838540f6c0SMarcel Holtmann cp.bdaddr_type = params->addr_type; 54848540f6c0SMarcel Holtmann bacpy(&cp.bdaddr, ¶ms->addr); 54858540f6c0SMarcel Holtmann 54868540f6c0SMarcel Holtmann hci_req_add(req, HCI_OP_LE_ADD_TO_WHITE_LIST, sizeof(cp), &cp); 54878540f6c0SMarcel Holtmann } 54888540f6c0SMarcel Holtmann 54898540f6c0SMarcel Holtmann static u8 update_white_list(struct hci_request *req) 54908540f6c0SMarcel Holtmann { 54918540f6c0SMarcel Holtmann struct hci_dev *hdev = req->hdev; 54928540f6c0SMarcel Holtmann struct hci_conn_params *params; 54938540f6c0SMarcel Holtmann struct bdaddr_list *b; 54948540f6c0SMarcel Holtmann uint8_t white_list_entries = 0; 54958540f6c0SMarcel Holtmann 54968540f6c0SMarcel Holtmann /* Go through the current white list programmed into the 54978540f6c0SMarcel Holtmann * controller one by one and check if that address is still 54988540f6c0SMarcel Holtmann * in the list of pending connections or list of devices to 54998540f6c0SMarcel Holtmann * report. If not present in either list, then queue the 55008540f6c0SMarcel Holtmann * command to remove it from the controller. 55018540f6c0SMarcel Holtmann */ 55028540f6c0SMarcel Holtmann list_for_each_entry(b, &hdev->le_white_list, list) { 55038540f6c0SMarcel Holtmann struct hci_cp_le_del_from_white_list cp; 55048540f6c0SMarcel Holtmann 55058540f6c0SMarcel Holtmann if (hci_pend_le_action_lookup(&hdev->pend_le_conns, 55068540f6c0SMarcel Holtmann &b->bdaddr, b->bdaddr_type) || 55078540f6c0SMarcel Holtmann hci_pend_le_action_lookup(&hdev->pend_le_reports, 55088540f6c0SMarcel Holtmann &b->bdaddr, b->bdaddr_type)) { 55098540f6c0SMarcel Holtmann white_list_entries++; 55108540f6c0SMarcel Holtmann continue; 55118540f6c0SMarcel Holtmann } 55128540f6c0SMarcel Holtmann 55138540f6c0SMarcel Holtmann cp.bdaddr_type = b->bdaddr_type; 55148540f6c0SMarcel Holtmann bacpy(&cp.bdaddr, &b->bdaddr); 55158540f6c0SMarcel Holtmann 55168540f6c0SMarcel Holtmann hci_req_add(req, HCI_OP_LE_DEL_FROM_WHITE_LIST, 55178540f6c0SMarcel Holtmann sizeof(cp), &cp); 55188540f6c0SMarcel Holtmann } 55198540f6c0SMarcel Holtmann 55208540f6c0SMarcel Holtmann /* Since all no longer valid white list entries have been 55218540f6c0SMarcel Holtmann * removed, walk through the list of pending connections 55228540f6c0SMarcel Holtmann * and ensure that any new device gets programmed into 55238540f6c0SMarcel Holtmann * the controller. 55248540f6c0SMarcel Holtmann * 55258540f6c0SMarcel Holtmann * If the list of the devices is larger than the list of 55268540f6c0SMarcel Holtmann * available white list entries in the controller, then 55278540f6c0SMarcel Holtmann * just abort and return filer policy value to not use the 55288540f6c0SMarcel Holtmann * white list. 55298540f6c0SMarcel Holtmann */ 55308540f6c0SMarcel Holtmann list_for_each_entry(params, &hdev->pend_le_conns, action) { 55318540f6c0SMarcel Holtmann if (hci_bdaddr_list_lookup(&hdev->le_white_list, 55328540f6c0SMarcel Holtmann ¶ms->addr, params->addr_type)) 55338540f6c0SMarcel Holtmann continue; 55348540f6c0SMarcel Holtmann 55358540f6c0SMarcel Holtmann if (white_list_entries >= hdev->le_white_list_size) { 55368540f6c0SMarcel Holtmann /* Select filter policy to accept all advertising */ 55378540f6c0SMarcel Holtmann return 0x00; 55388540f6c0SMarcel Holtmann } 55398540f6c0SMarcel Holtmann 554066d8e837SMarcel Holtmann if (hci_find_irk_by_addr(hdev, ¶ms->addr, 554166d8e837SMarcel Holtmann params->addr_type)) { 554266d8e837SMarcel Holtmann /* White list can not be used with RPAs */ 554366d8e837SMarcel Holtmann return 0x00; 554466d8e837SMarcel Holtmann } 554566d8e837SMarcel Holtmann 55468540f6c0SMarcel Holtmann white_list_entries++; 55478540f6c0SMarcel Holtmann add_to_white_list(req, params); 55488540f6c0SMarcel Holtmann } 55498540f6c0SMarcel Holtmann 55508540f6c0SMarcel Holtmann /* After adding all new pending connections, walk through 55518540f6c0SMarcel Holtmann * the list of pending reports and also add these to the 55528540f6c0SMarcel Holtmann * white list if there is still space. 55538540f6c0SMarcel Holtmann */ 55548540f6c0SMarcel Holtmann list_for_each_entry(params, &hdev->pend_le_reports, action) { 55558540f6c0SMarcel Holtmann if (hci_bdaddr_list_lookup(&hdev->le_white_list, 55568540f6c0SMarcel Holtmann ¶ms->addr, params->addr_type)) 55578540f6c0SMarcel Holtmann continue; 55588540f6c0SMarcel Holtmann 55598540f6c0SMarcel Holtmann if (white_list_entries >= hdev->le_white_list_size) { 55608540f6c0SMarcel Holtmann /* Select filter policy to accept all advertising */ 55618540f6c0SMarcel Holtmann return 0x00; 55628540f6c0SMarcel Holtmann } 55638540f6c0SMarcel Holtmann 556466d8e837SMarcel Holtmann if (hci_find_irk_by_addr(hdev, ¶ms->addr, 556566d8e837SMarcel Holtmann params->addr_type)) { 556666d8e837SMarcel Holtmann /* White list can not be used with RPAs */ 556766d8e837SMarcel Holtmann return 0x00; 556866d8e837SMarcel Holtmann } 556966d8e837SMarcel Holtmann 55708540f6c0SMarcel Holtmann white_list_entries++; 55718540f6c0SMarcel Holtmann add_to_white_list(req, params); 55728540f6c0SMarcel Holtmann } 55738540f6c0SMarcel Holtmann 55748540f6c0SMarcel Holtmann /* Select filter policy to use white list */ 55758540f6c0SMarcel Holtmann return 0x01; 55768540f6c0SMarcel Holtmann } 55778540f6c0SMarcel Holtmann 55788ef30fd3SAndre Guedes void hci_req_add_le_passive_scan(struct hci_request *req) 55798ef30fd3SAndre Guedes { 55808ef30fd3SAndre Guedes struct hci_cp_le_set_scan_param param_cp; 55818ef30fd3SAndre Guedes struct hci_cp_le_set_scan_enable enable_cp; 55828ef30fd3SAndre Guedes struct hci_dev *hdev = req->hdev; 55838ef30fd3SAndre Guedes u8 own_addr_type; 55848540f6c0SMarcel Holtmann u8 filter_policy; 55858ef30fd3SAndre Guedes 55866ab535a7SMarcel Holtmann /* Set require_privacy to false since no SCAN_REQ are send 55876ab535a7SMarcel Holtmann * during passive scanning. Not using an unresolvable address 55886ab535a7SMarcel Holtmann * here is important so that peer devices using direct 55896ab535a7SMarcel Holtmann * advertising with our address will be correctly reported 55906ab535a7SMarcel Holtmann * by the controller. 55918ef30fd3SAndre Guedes */ 55926ab535a7SMarcel Holtmann if (hci_update_random_address(req, false, &own_addr_type)) 55938ef30fd3SAndre Guedes return; 55948ef30fd3SAndre Guedes 55958540f6c0SMarcel Holtmann /* Adding or removing entries from the white list must 55968540f6c0SMarcel Holtmann * happen before enabling scanning. The controller does 55978540f6c0SMarcel Holtmann * not allow white list modification while scanning. 55988540f6c0SMarcel Holtmann */ 55998540f6c0SMarcel Holtmann filter_policy = update_white_list(req); 56008540f6c0SMarcel Holtmann 56018ef30fd3SAndre Guedes memset(¶m_cp, 0, sizeof(param_cp)); 56028ef30fd3SAndre Guedes param_cp.type = LE_SCAN_PASSIVE; 56038ef30fd3SAndre Guedes param_cp.interval = cpu_to_le16(hdev->le_scan_interval); 56048ef30fd3SAndre Guedes param_cp.window = cpu_to_le16(hdev->le_scan_window); 56058ef30fd3SAndre Guedes param_cp.own_address_type = own_addr_type; 56068540f6c0SMarcel Holtmann param_cp.filter_policy = filter_policy; 56078ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_PARAM, sizeof(param_cp), 56088ef30fd3SAndre Guedes ¶m_cp); 56098ef30fd3SAndre Guedes 56108ef30fd3SAndre Guedes memset(&enable_cp, 0, sizeof(enable_cp)); 56118ef30fd3SAndre Guedes enable_cp.enable = LE_SCAN_ENABLE; 56124340a124SAndre Guedes enable_cp.filter_dup = LE_SCAN_FILTER_DUP_ENABLE; 56138ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(enable_cp), 56148ef30fd3SAndre Guedes &enable_cp); 56158ef30fd3SAndre Guedes } 56168ef30fd3SAndre Guedes 5617a4790dbdSAndre Guedes static void update_background_scan_complete(struct hci_dev *hdev, u8 status) 5618a4790dbdSAndre Guedes { 5619a4790dbdSAndre Guedes if (status) 5620a4790dbdSAndre Guedes BT_DBG("HCI request failed to update background scanning: " 5621a4790dbdSAndre Guedes "status 0x%2.2x", status); 5622a4790dbdSAndre Guedes } 5623a4790dbdSAndre Guedes 5624a4790dbdSAndre Guedes /* This function controls the background scanning based on hdev->pend_le_conns 5625a4790dbdSAndre Guedes * list. If there are pending LE connection we start the background scanning, 5626a4790dbdSAndre Guedes * otherwise we stop it. 5627a4790dbdSAndre Guedes * 5628a4790dbdSAndre Guedes * This function requires the caller holds hdev->lock. 5629a4790dbdSAndre Guedes */ 5630a4790dbdSAndre Guedes void hci_update_background_scan(struct hci_dev *hdev) 5631a4790dbdSAndre Guedes { 5632a4790dbdSAndre Guedes struct hci_request req; 5633a4790dbdSAndre Guedes struct hci_conn *conn; 5634a4790dbdSAndre Guedes int err; 5635a4790dbdSAndre Guedes 5636c20c02d5SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags) || 5637c20c02d5SMarcel Holtmann test_bit(HCI_INIT, &hdev->flags) || 5638c20c02d5SMarcel Holtmann test_bit(HCI_SETUP, &hdev->dev_flags) || 5639d603b76bSMarcel Holtmann test_bit(HCI_CONFIG, &hdev->dev_flags) || 5640b8221770SMarcel Holtmann test_bit(HCI_AUTO_OFF, &hdev->dev_flags) || 5641c20c02d5SMarcel Holtmann test_bit(HCI_UNREGISTER, &hdev->dev_flags)) 56421c1697c0SMarcel Holtmann return; 56431c1697c0SMarcel Holtmann 5644a70f4b5fSJohan Hedberg /* No point in doing scanning if LE support hasn't been enabled */ 5645a70f4b5fSJohan Hedberg if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 5646a70f4b5fSJohan Hedberg return; 5647a70f4b5fSJohan Hedberg 5648ae23ada4SJohan Hedberg /* If discovery is active don't interfere with it */ 5649ae23ada4SJohan Hedberg if (hdev->discovery.state != DISCOVERY_STOPPED) 5650ae23ada4SJohan Hedberg return; 5651ae23ada4SJohan Hedberg 5652a4790dbdSAndre Guedes hci_req_init(&req, hdev); 5653a4790dbdSAndre Guedes 5654d1d588c1SJohan Hedberg if (list_empty(&hdev->pend_le_conns) && 565566f8455aSJohan Hedberg list_empty(&hdev->pend_le_reports)) { 56560d2bf134SJohan Hedberg /* If there is no pending LE connections or devices 56570d2bf134SJohan Hedberg * to be scanned for, we should stop the background 56580d2bf134SJohan Hedberg * scanning. 5659a4790dbdSAndre Guedes */ 5660a4790dbdSAndre Guedes 5661a4790dbdSAndre Guedes /* If controller is not scanning we are done. */ 5662a4790dbdSAndre Guedes if (!test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 5663a4790dbdSAndre Guedes return; 5664a4790dbdSAndre Guedes 5665a4790dbdSAndre Guedes hci_req_add_le_scan_disable(&req); 5666a4790dbdSAndre Guedes 5667a4790dbdSAndre Guedes BT_DBG("%s stopping background scanning", hdev->name); 5668a4790dbdSAndre Guedes } else { 5669a4790dbdSAndre Guedes /* If there is at least one pending LE connection, we should 5670a4790dbdSAndre Guedes * keep the background scan running. 5671a4790dbdSAndre Guedes */ 5672a4790dbdSAndre Guedes 5673a4790dbdSAndre Guedes /* If controller is connecting, we should not start scanning 5674a4790dbdSAndre Guedes * since some controllers are not able to scan and connect at 5675a4790dbdSAndre Guedes * the same time. 5676a4790dbdSAndre Guedes */ 5677a4790dbdSAndre Guedes conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT); 5678a4790dbdSAndre Guedes if (conn) 5679a4790dbdSAndre Guedes return; 5680a4790dbdSAndre Guedes 56814340a124SAndre Guedes /* If controller is currently scanning, we stop it to ensure we 56824340a124SAndre Guedes * don't miss any advertising (due to duplicates filter). 56834340a124SAndre Guedes */ 56844340a124SAndre Guedes if (test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 56854340a124SAndre Guedes hci_req_add_le_scan_disable(&req); 56864340a124SAndre Guedes 56878ef30fd3SAndre Guedes hci_req_add_le_passive_scan(&req); 5688a4790dbdSAndre Guedes 5689a4790dbdSAndre Guedes BT_DBG("%s starting background scanning", hdev->name); 5690a4790dbdSAndre Guedes } 5691a4790dbdSAndre Guedes 5692a4790dbdSAndre Guedes err = hci_req_run(&req, update_background_scan_complete); 5693a4790dbdSAndre Guedes if (err) 5694a4790dbdSAndre Guedes BT_ERR("Failed to run HCI request: err %d", err); 5695a4790dbdSAndre Guedes } 5696432df05eSJohan Hedberg 569722f433dcSJohan Hedberg static bool disconnected_whitelist_entries(struct hci_dev *hdev) 569822f433dcSJohan Hedberg { 569922f433dcSJohan Hedberg struct bdaddr_list *b; 570022f433dcSJohan Hedberg 570122f433dcSJohan Hedberg list_for_each_entry(b, &hdev->whitelist, list) { 570222f433dcSJohan Hedberg struct hci_conn *conn; 570322f433dcSJohan Hedberg 570422f433dcSJohan Hedberg conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &b->bdaddr); 570522f433dcSJohan Hedberg if (!conn) 570622f433dcSJohan Hedberg return true; 570722f433dcSJohan Hedberg 570822f433dcSJohan Hedberg if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 570922f433dcSJohan Hedberg return true; 571022f433dcSJohan Hedberg } 571122f433dcSJohan Hedberg 571222f433dcSJohan Hedberg return false; 571322f433dcSJohan Hedberg } 571422f433dcSJohan Hedberg 5715432df05eSJohan Hedberg void hci_update_page_scan(struct hci_dev *hdev, struct hci_request *req) 5716432df05eSJohan Hedberg { 5717432df05eSJohan Hedberg u8 scan; 5718432df05eSJohan Hedberg 5719432df05eSJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) 5720432df05eSJohan Hedberg return; 5721432df05eSJohan Hedberg 5722432df05eSJohan Hedberg if (!hdev_is_powered(hdev)) 5723432df05eSJohan Hedberg return; 5724432df05eSJohan Hedberg 5725432df05eSJohan Hedberg if (mgmt_powering_down(hdev)) 5726432df05eSJohan Hedberg return; 5727432df05eSJohan Hedberg 5728432df05eSJohan Hedberg if (test_bit(HCI_CONNECTABLE, &hdev->dev_flags) || 572922f433dcSJohan Hedberg disconnected_whitelist_entries(hdev)) 5730432df05eSJohan Hedberg scan = SCAN_PAGE; 5731432df05eSJohan Hedberg else 5732432df05eSJohan Hedberg scan = SCAN_DISABLED; 5733432df05eSJohan Hedberg 5734432df05eSJohan Hedberg if (test_bit(HCI_PSCAN, &hdev->flags) == !!(scan & SCAN_PAGE)) 5735432df05eSJohan Hedberg return; 5736432df05eSJohan Hedberg 5737432df05eSJohan Hedberg if (test_bit(HCI_DISCOVERABLE, &hdev->dev_flags)) 5738432df05eSJohan Hedberg scan |= SCAN_INQUIRY; 5739432df05eSJohan Hedberg 5740432df05eSJohan Hedberg if (req) 5741432df05eSJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 5742432df05eSJohan Hedberg else 5743432df05eSJohan Hedberg hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 5744432df05eSJohan Hedberg } 5745