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 2036659358eSJohan Hedberg static int whitelist_show(struct seq_file *f, void *p) 2046659358eSJohan Hedberg { 2056659358eSJohan Hedberg struct hci_dev *hdev = f->private; 2066659358eSJohan Hedberg struct bdaddr_list *b; 2076659358eSJohan Hedberg 2086659358eSJohan Hedberg hci_dev_lock(hdev); 2096659358eSJohan Hedberg list_for_each_entry(b, &hdev->whitelist, list) 2106659358eSJohan Hedberg seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 2116659358eSJohan Hedberg hci_dev_unlock(hdev); 2126659358eSJohan Hedberg 2136659358eSJohan Hedberg return 0; 2146659358eSJohan Hedberg } 2156659358eSJohan Hedberg 2166659358eSJohan Hedberg static int whitelist_open(struct inode *inode, struct file *file) 2176659358eSJohan Hedberg { 2186659358eSJohan Hedberg return single_open(file, whitelist_show, inode->i_private); 2196659358eSJohan Hedberg } 2206659358eSJohan Hedberg 2216659358eSJohan Hedberg static const struct file_operations whitelist_fops = { 2226659358eSJohan Hedberg .open = whitelist_open, 2236659358eSJohan Hedberg .read = seq_read, 2246659358eSJohan Hedberg .llseek = seq_lseek, 2256659358eSJohan Hedberg .release = single_release, 2266659358eSJohan Hedberg }; 2276659358eSJohan Hedberg 22847219839SMarcel Holtmann static int uuids_show(struct seq_file *f, void *p) 22947219839SMarcel Holtmann { 23047219839SMarcel Holtmann struct hci_dev *hdev = f->private; 23147219839SMarcel Holtmann struct bt_uuid *uuid; 23247219839SMarcel Holtmann 23347219839SMarcel Holtmann hci_dev_lock(hdev); 23447219839SMarcel Holtmann list_for_each_entry(uuid, &hdev->uuids, list) { 23558f01aa9SMarcel Holtmann u8 i, val[16]; 23647219839SMarcel Holtmann 23758f01aa9SMarcel Holtmann /* The Bluetooth UUID values are stored in big endian, 23858f01aa9SMarcel Holtmann * but with reversed byte order. So convert them into 23958f01aa9SMarcel Holtmann * the right order for the %pUb modifier. 24058f01aa9SMarcel Holtmann */ 24158f01aa9SMarcel Holtmann for (i = 0; i < 16; i++) 24258f01aa9SMarcel Holtmann val[i] = uuid->uuid[15 - i]; 24347219839SMarcel Holtmann 24458f01aa9SMarcel Holtmann seq_printf(f, "%pUb\n", val); 24547219839SMarcel Holtmann } 24647219839SMarcel Holtmann hci_dev_unlock(hdev); 24747219839SMarcel Holtmann 24847219839SMarcel Holtmann return 0; 24947219839SMarcel Holtmann } 25047219839SMarcel Holtmann 25147219839SMarcel Holtmann static int uuids_open(struct inode *inode, struct file *file) 25247219839SMarcel Holtmann { 25347219839SMarcel Holtmann return single_open(file, uuids_show, inode->i_private); 25447219839SMarcel Holtmann } 25547219839SMarcel Holtmann 25647219839SMarcel Holtmann static const struct file_operations uuids_fops = { 25747219839SMarcel Holtmann .open = uuids_open, 25847219839SMarcel Holtmann .read = seq_read, 25947219839SMarcel Holtmann .llseek = seq_lseek, 26047219839SMarcel Holtmann .release = single_release, 26147219839SMarcel Holtmann }; 26247219839SMarcel Holtmann 263baf27f6eSMarcel Holtmann static int inquiry_cache_show(struct seq_file *f, void *p) 264baf27f6eSMarcel Holtmann { 265baf27f6eSMarcel Holtmann struct hci_dev *hdev = f->private; 266baf27f6eSMarcel Holtmann struct discovery_state *cache = &hdev->discovery; 267baf27f6eSMarcel Holtmann struct inquiry_entry *e; 268baf27f6eSMarcel Holtmann 269baf27f6eSMarcel Holtmann hci_dev_lock(hdev); 270baf27f6eSMarcel Holtmann 271baf27f6eSMarcel Holtmann list_for_each_entry(e, &cache->all, all) { 272baf27f6eSMarcel Holtmann struct inquiry_data *data = &e->data; 273baf27f6eSMarcel Holtmann seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n", 274baf27f6eSMarcel Holtmann &data->bdaddr, 275baf27f6eSMarcel Holtmann data->pscan_rep_mode, data->pscan_period_mode, 276baf27f6eSMarcel Holtmann data->pscan_mode, data->dev_class[2], 277baf27f6eSMarcel Holtmann data->dev_class[1], data->dev_class[0], 278baf27f6eSMarcel Holtmann __le16_to_cpu(data->clock_offset), 279baf27f6eSMarcel Holtmann data->rssi, data->ssp_mode, e->timestamp); 280baf27f6eSMarcel Holtmann } 281baf27f6eSMarcel Holtmann 282baf27f6eSMarcel Holtmann hci_dev_unlock(hdev); 283baf27f6eSMarcel Holtmann 284baf27f6eSMarcel Holtmann return 0; 285baf27f6eSMarcel Holtmann } 286baf27f6eSMarcel Holtmann 287baf27f6eSMarcel Holtmann static int inquiry_cache_open(struct inode *inode, struct file *file) 288baf27f6eSMarcel Holtmann { 289baf27f6eSMarcel Holtmann return single_open(file, inquiry_cache_show, inode->i_private); 290baf27f6eSMarcel Holtmann } 291baf27f6eSMarcel Holtmann 292baf27f6eSMarcel Holtmann static const struct file_operations inquiry_cache_fops = { 293baf27f6eSMarcel Holtmann .open = inquiry_cache_open, 294baf27f6eSMarcel Holtmann .read = seq_read, 295baf27f6eSMarcel Holtmann .llseek = seq_lseek, 296baf27f6eSMarcel Holtmann .release = single_release, 297baf27f6eSMarcel Holtmann }; 298baf27f6eSMarcel Holtmann 29902d08d15SMarcel Holtmann static int link_keys_show(struct seq_file *f, void *ptr) 30002d08d15SMarcel Holtmann { 30102d08d15SMarcel Holtmann struct hci_dev *hdev = f->private; 30202d08d15SMarcel Holtmann struct list_head *p, *n; 30302d08d15SMarcel Holtmann 30402d08d15SMarcel Holtmann hci_dev_lock(hdev); 30502d08d15SMarcel Holtmann list_for_each_safe(p, n, &hdev->link_keys) { 30602d08d15SMarcel Holtmann struct link_key *key = list_entry(p, struct link_key, list); 30702d08d15SMarcel Holtmann seq_printf(f, "%pMR %u %*phN %u\n", &key->bdaddr, key->type, 30802d08d15SMarcel Holtmann HCI_LINK_KEY_SIZE, key->val, key->pin_len); 30902d08d15SMarcel Holtmann } 31002d08d15SMarcel Holtmann hci_dev_unlock(hdev); 31102d08d15SMarcel Holtmann 31202d08d15SMarcel Holtmann return 0; 31302d08d15SMarcel Holtmann } 31402d08d15SMarcel Holtmann 31502d08d15SMarcel Holtmann static int link_keys_open(struct inode *inode, struct file *file) 31602d08d15SMarcel Holtmann { 31702d08d15SMarcel Holtmann return single_open(file, link_keys_show, inode->i_private); 31802d08d15SMarcel Holtmann } 31902d08d15SMarcel Holtmann 32002d08d15SMarcel Holtmann static const struct file_operations link_keys_fops = { 32102d08d15SMarcel Holtmann .open = link_keys_open, 32202d08d15SMarcel Holtmann .read = seq_read, 32302d08d15SMarcel Holtmann .llseek = seq_lseek, 32402d08d15SMarcel Holtmann .release = single_release, 32502d08d15SMarcel Holtmann }; 32602d08d15SMarcel Holtmann 327babdbb3cSMarcel Holtmann static int dev_class_show(struct seq_file *f, void *ptr) 328babdbb3cSMarcel Holtmann { 329babdbb3cSMarcel Holtmann struct hci_dev *hdev = f->private; 330babdbb3cSMarcel Holtmann 331babdbb3cSMarcel Holtmann hci_dev_lock(hdev); 332babdbb3cSMarcel Holtmann seq_printf(f, "0x%.2x%.2x%.2x\n", hdev->dev_class[2], 333babdbb3cSMarcel Holtmann hdev->dev_class[1], hdev->dev_class[0]); 334babdbb3cSMarcel Holtmann hci_dev_unlock(hdev); 335babdbb3cSMarcel Holtmann 336babdbb3cSMarcel Holtmann return 0; 337babdbb3cSMarcel Holtmann } 338babdbb3cSMarcel Holtmann 339babdbb3cSMarcel Holtmann static int dev_class_open(struct inode *inode, struct file *file) 340babdbb3cSMarcel Holtmann { 341babdbb3cSMarcel Holtmann return single_open(file, dev_class_show, inode->i_private); 342babdbb3cSMarcel Holtmann } 343babdbb3cSMarcel Holtmann 344babdbb3cSMarcel Holtmann static const struct file_operations dev_class_fops = { 345babdbb3cSMarcel Holtmann .open = dev_class_open, 346babdbb3cSMarcel Holtmann .read = seq_read, 347babdbb3cSMarcel Holtmann .llseek = seq_lseek, 348babdbb3cSMarcel Holtmann .release = single_release, 349babdbb3cSMarcel Holtmann }; 350babdbb3cSMarcel Holtmann 351041000b9SMarcel Holtmann static int voice_setting_get(void *data, u64 *val) 352041000b9SMarcel Holtmann { 353041000b9SMarcel Holtmann struct hci_dev *hdev = data; 354041000b9SMarcel Holtmann 355041000b9SMarcel Holtmann hci_dev_lock(hdev); 356041000b9SMarcel Holtmann *val = hdev->voice_setting; 357041000b9SMarcel Holtmann hci_dev_unlock(hdev); 358041000b9SMarcel Holtmann 359041000b9SMarcel Holtmann return 0; 360041000b9SMarcel Holtmann } 361041000b9SMarcel Holtmann 362041000b9SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get, 363041000b9SMarcel Holtmann NULL, "0x%4.4llx\n"); 364041000b9SMarcel Holtmann 365ebd1e33bSMarcel Holtmann static int auto_accept_delay_set(void *data, u64 val) 366ebd1e33bSMarcel Holtmann { 367ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 368ebd1e33bSMarcel Holtmann 369ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 370ebd1e33bSMarcel Holtmann hdev->auto_accept_delay = val; 371ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 372ebd1e33bSMarcel Holtmann 373ebd1e33bSMarcel Holtmann return 0; 374ebd1e33bSMarcel Holtmann } 375ebd1e33bSMarcel Holtmann 376ebd1e33bSMarcel Holtmann static int auto_accept_delay_get(void *data, u64 *val) 377ebd1e33bSMarcel Holtmann { 378ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 379ebd1e33bSMarcel Holtmann 380ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 381ebd1e33bSMarcel Holtmann *val = hdev->auto_accept_delay; 382ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 383ebd1e33bSMarcel Holtmann 384ebd1e33bSMarcel Holtmann return 0; 385ebd1e33bSMarcel Holtmann } 386ebd1e33bSMarcel Holtmann 387ebd1e33bSMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get, 388ebd1e33bSMarcel Holtmann auto_accept_delay_set, "%llu\n"); 389ebd1e33bSMarcel Holtmann 3905afeac14SMarcel Holtmann static ssize_t force_sc_support_read(struct file *file, char __user *user_buf, 3915afeac14SMarcel Holtmann size_t count, loff_t *ppos) 3925afeac14SMarcel Holtmann { 3935afeac14SMarcel Holtmann struct hci_dev *hdev = file->private_data; 3945afeac14SMarcel Holtmann char buf[3]; 3955afeac14SMarcel Holtmann 396111902f7SMarcel Holtmann buf[0] = test_bit(HCI_FORCE_SC, &hdev->dbg_flags) ? 'Y': 'N'; 3975afeac14SMarcel Holtmann buf[1] = '\n'; 3985afeac14SMarcel Holtmann buf[2] = '\0'; 3995afeac14SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 4005afeac14SMarcel Holtmann } 4015afeac14SMarcel Holtmann 4025afeac14SMarcel Holtmann static ssize_t force_sc_support_write(struct file *file, 4035afeac14SMarcel Holtmann const char __user *user_buf, 4045afeac14SMarcel Holtmann size_t count, loff_t *ppos) 4055afeac14SMarcel Holtmann { 4065afeac14SMarcel Holtmann struct hci_dev *hdev = file->private_data; 4075afeac14SMarcel Holtmann char buf[32]; 4085afeac14SMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 4095afeac14SMarcel Holtmann bool enable; 4105afeac14SMarcel Holtmann 4115afeac14SMarcel Holtmann if (test_bit(HCI_UP, &hdev->flags)) 4125afeac14SMarcel Holtmann return -EBUSY; 4135afeac14SMarcel Holtmann 4145afeac14SMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 4155afeac14SMarcel Holtmann return -EFAULT; 4165afeac14SMarcel Holtmann 4175afeac14SMarcel Holtmann buf[buf_size] = '\0'; 4185afeac14SMarcel Holtmann if (strtobool(buf, &enable)) 4195afeac14SMarcel Holtmann return -EINVAL; 4205afeac14SMarcel Holtmann 421111902f7SMarcel Holtmann if (enable == test_bit(HCI_FORCE_SC, &hdev->dbg_flags)) 4225afeac14SMarcel Holtmann return -EALREADY; 4235afeac14SMarcel Holtmann 424111902f7SMarcel Holtmann change_bit(HCI_FORCE_SC, &hdev->dbg_flags); 4255afeac14SMarcel Holtmann 4265afeac14SMarcel Holtmann return count; 4275afeac14SMarcel Holtmann } 4285afeac14SMarcel Holtmann 4295afeac14SMarcel Holtmann static const struct file_operations force_sc_support_fops = { 4305afeac14SMarcel Holtmann .open = simple_open, 4315afeac14SMarcel Holtmann .read = force_sc_support_read, 4325afeac14SMarcel Holtmann .write = force_sc_support_write, 4335afeac14SMarcel Holtmann .llseek = default_llseek, 4345afeac14SMarcel Holtmann }; 4355afeac14SMarcel Holtmann 436134c2a89SMarcel Holtmann static ssize_t sc_only_mode_read(struct file *file, char __user *user_buf, 437134c2a89SMarcel Holtmann size_t count, loff_t *ppos) 438134c2a89SMarcel Holtmann { 439134c2a89SMarcel Holtmann struct hci_dev *hdev = file->private_data; 440134c2a89SMarcel Holtmann char buf[3]; 441134c2a89SMarcel Holtmann 442134c2a89SMarcel Holtmann buf[0] = test_bit(HCI_SC_ONLY, &hdev->dev_flags) ? 'Y': 'N'; 443134c2a89SMarcel Holtmann buf[1] = '\n'; 444134c2a89SMarcel Holtmann buf[2] = '\0'; 445134c2a89SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 446134c2a89SMarcel Holtmann } 447134c2a89SMarcel Holtmann 448134c2a89SMarcel Holtmann static const struct file_operations sc_only_mode_fops = { 449134c2a89SMarcel Holtmann .open = simple_open, 450134c2a89SMarcel Holtmann .read = sc_only_mode_read, 451134c2a89SMarcel Holtmann .llseek = default_llseek, 452134c2a89SMarcel Holtmann }; 453134c2a89SMarcel Holtmann 4542bfa3531SMarcel Holtmann static int idle_timeout_set(void *data, u64 val) 4552bfa3531SMarcel Holtmann { 4562bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4572bfa3531SMarcel Holtmann 4582bfa3531SMarcel Holtmann if (val != 0 && (val < 500 || val > 3600000)) 4592bfa3531SMarcel Holtmann return -EINVAL; 4602bfa3531SMarcel Holtmann 4612bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4622bfa3531SMarcel Holtmann hdev->idle_timeout = val; 4632bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4642bfa3531SMarcel Holtmann 4652bfa3531SMarcel Holtmann return 0; 4662bfa3531SMarcel Holtmann } 4672bfa3531SMarcel Holtmann 4682bfa3531SMarcel Holtmann static int idle_timeout_get(void *data, u64 *val) 4692bfa3531SMarcel Holtmann { 4702bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4712bfa3531SMarcel Holtmann 4722bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4732bfa3531SMarcel Holtmann *val = hdev->idle_timeout; 4742bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4752bfa3531SMarcel Holtmann 4762bfa3531SMarcel Holtmann return 0; 4772bfa3531SMarcel Holtmann } 4782bfa3531SMarcel Holtmann 4792bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get, 4802bfa3531SMarcel Holtmann idle_timeout_set, "%llu\n"); 4812bfa3531SMarcel Holtmann 482c982b2eaSJohan Hedberg static int rpa_timeout_set(void *data, u64 val) 483c982b2eaSJohan Hedberg { 484c982b2eaSJohan Hedberg struct hci_dev *hdev = data; 485c982b2eaSJohan Hedberg 486c982b2eaSJohan Hedberg /* Require the RPA timeout to be at least 30 seconds and at most 487c982b2eaSJohan Hedberg * 24 hours. 488c982b2eaSJohan Hedberg */ 489c982b2eaSJohan Hedberg if (val < 30 || val > (60 * 60 * 24)) 490c982b2eaSJohan Hedberg return -EINVAL; 491c982b2eaSJohan Hedberg 492c982b2eaSJohan Hedberg hci_dev_lock(hdev); 493c982b2eaSJohan Hedberg hdev->rpa_timeout = val; 494c982b2eaSJohan Hedberg hci_dev_unlock(hdev); 495c982b2eaSJohan Hedberg 496c982b2eaSJohan Hedberg return 0; 497c982b2eaSJohan Hedberg } 498c982b2eaSJohan Hedberg 499c982b2eaSJohan Hedberg static int rpa_timeout_get(void *data, u64 *val) 500c982b2eaSJohan Hedberg { 501c982b2eaSJohan Hedberg struct hci_dev *hdev = data; 502c982b2eaSJohan Hedberg 503c982b2eaSJohan Hedberg hci_dev_lock(hdev); 504c982b2eaSJohan Hedberg *val = hdev->rpa_timeout; 505c982b2eaSJohan Hedberg hci_dev_unlock(hdev); 506c982b2eaSJohan Hedberg 507c982b2eaSJohan Hedberg return 0; 508c982b2eaSJohan Hedberg } 509c982b2eaSJohan Hedberg 510c982b2eaSJohan Hedberg DEFINE_SIMPLE_ATTRIBUTE(rpa_timeout_fops, rpa_timeout_get, 511c982b2eaSJohan Hedberg rpa_timeout_set, "%llu\n"); 512c982b2eaSJohan Hedberg 5132bfa3531SMarcel Holtmann static int sniff_min_interval_set(void *data, u64 val) 5142bfa3531SMarcel Holtmann { 5152bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 5162bfa3531SMarcel Holtmann 5172bfa3531SMarcel Holtmann if (val == 0 || val % 2 || val > hdev->sniff_max_interval) 5182bfa3531SMarcel Holtmann return -EINVAL; 5192bfa3531SMarcel Holtmann 5202bfa3531SMarcel Holtmann hci_dev_lock(hdev); 5212bfa3531SMarcel Holtmann hdev->sniff_min_interval = val; 5222bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 5232bfa3531SMarcel Holtmann 5242bfa3531SMarcel Holtmann return 0; 5252bfa3531SMarcel Holtmann } 5262bfa3531SMarcel Holtmann 5272bfa3531SMarcel Holtmann static int sniff_min_interval_get(void *data, u64 *val) 5282bfa3531SMarcel Holtmann { 5292bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 5302bfa3531SMarcel Holtmann 5312bfa3531SMarcel Holtmann hci_dev_lock(hdev); 5322bfa3531SMarcel Holtmann *val = hdev->sniff_min_interval; 5332bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 5342bfa3531SMarcel Holtmann 5352bfa3531SMarcel Holtmann return 0; 5362bfa3531SMarcel Holtmann } 5372bfa3531SMarcel Holtmann 5382bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get, 5392bfa3531SMarcel Holtmann sniff_min_interval_set, "%llu\n"); 5402bfa3531SMarcel Holtmann 5412bfa3531SMarcel Holtmann static int sniff_max_interval_set(void *data, u64 val) 5422bfa3531SMarcel Holtmann { 5432bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 5442bfa3531SMarcel Holtmann 5452bfa3531SMarcel Holtmann if (val == 0 || val % 2 || val < hdev->sniff_min_interval) 5462bfa3531SMarcel Holtmann return -EINVAL; 5472bfa3531SMarcel Holtmann 5482bfa3531SMarcel Holtmann hci_dev_lock(hdev); 5492bfa3531SMarcel Holtmann hdev->sniff_max_interval = val; 5502bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 5512bfa3531SMarcel Holtmann 5522bfa3531SMarcel Holtmann return 0; 5532bfa3531SMarcel Holtmann } 5542bfa3531SMarcel Holtmann 5552bfa3531SMarcel Holtmann static int sniff_max_interval_get(void *data, u64 *val) 5562bfa3531SMarcel Holtmann { 5572bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 5582bfa3531SMarcel Holtmann 5592bfa3531SMarcel Holtmann hci_dev_lock(hdev); 5602bfa3531SMarcel Holtmann *val = hdev->sniff_max_interval; 5612bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 5622bfa3531SMarcel Holtmann 5632bfa3531SMarcel Holtmann return 0; 5642bfa3531SMarcel Holtmann } 5652bfa3531SMarcel Holtmann 5662bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get, 5672bfa3531SMarcel Holtmann sniff_max_interval_set, "%llu\n"); 5682bfa3531SMarcel Holtmann 56931ad1691SAndrzej Kaczmarek static int conn_info_min_age_set(void *data, u64 val) 57031ad1691SAndrzej Kaczmarek { 57131ad1691SAndrzej Kaczmarek struct hci_dev *hdev = data; 57231ad1691SAndrzej Kaczmarek 57331ad1691SAndrzej Kaczmarek if (val == 0 || val > hdev->conn_info_max_age) 57431ad1691SAndrzej Kaczmarek return -EINVAL; 57531ad1691SAndrzej Kaczmarek 57631ad1691SAndrzej Kaczmarek hci_dev_lock(hdev); 57731ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = val; 57831ad1691SAndrzej Kaczmarek hci_dev_unlock(hdev); 57931ad1691SAndrzej Kaczmarek 58031ad1691SAndrzej Kaczmarek return 0; 58131ad1691SAndrzej Kaczmarek } 58231ad1691SAndrzej Kaczmarek 58331ad1691SAndrzej Kaczmarek static int conn_info_min_age_get(void *data, u64 *val) 58431ad1691SAndrzej Kaczmarek { 58531ad1691SAndrzej Kaczmarek struct hci_dev *hdev = data; 58631ad1691SAndrzej Kaczmarek 58731ad1691SAndrzej Kaczmarek hci_dev_lock(hdev); 58831ad1691SAndrzej Kaczmarek *val = hdev->conn_info_min_age; 58931ad1691SAndrzej Kaczmarek hci_dev_unlock(hdev); 59031ad1691SAndrzej Kaczmarek 59131ad1691SAndrzej Kaczmarek return 0; 59231ad1691SAndrzej Kaczmarek } 59331ad1691SAndrzej Kaczmarek 59431ad1691SAndrzej Kaczmarek DEFINE_SIMPLE_ATTRIBUTE(conn_info_min_age_fops, conn_info_min_age_get, 59531ad1691SAndrzej Kaczmarek conn_info_min_age_set, "%llu\n"); 59631ad1691SAndrzej Kaczmarek 59731ad1691SAndrzej Kaczmarek static int conn_info_max_age_set(void *data, u64 val) 59831ad1691SAndrzej Kaczmarek { 59931ad1691SAndrzej Kaczmarek struct hci_dev *hdev = data; 60031ad1691SAndrzej Kaczmarek 60131ad1691SAndrzej Kaczmarek if (val == 0 || val < hdev->conn_info_min_age) 60231ad1691SAndrzej Kaczmarek return -EINVAL; 60331ad1691SAndrzej Kaczmarek 60431ad1691SAndrzej Kaczmarek hci_dev_lock(hdev); 60531ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = val; 60631ad1691SAndrzej Kaczmarek hci_dev_unlock(hdev); 60731ad1691SAndrzej Kaczmarek 60831ad1691SAndrzej Kaczmarek return 0; 60931ad1691SAndrzej Kaczmarek } 61031ad1691SAndrzej Kaczmarek 61131ad1691SAndrzej Kaczmarek static int conn_info_max_age_get(void *data, u64 *val) 61231ad1691SAndrzej Kaczmarek { 61331ad1691SAndrzej Kaczmarek struct hci_dev *hdev = data; 61431ad1691SAndrzej Kaczmarek 61531ad1691SAndrzej Kaczmarek hci_dev_lock(hdev); 61631ad1691SAndrzej Kaczmarek *val = hdev->conn_info_max_age; 61731ad1691SAndrzej Kaczmarek hci_dev_unlock(hdev); 61831ad1691SAndrzej Kaczmarek 61931ad1691SAndrzej Kaczmarek return 0; 62031ad1691SAndrzej Kaczmarek } 62131ad1691SAndrzej Kaczmarek 62231ad1691SAndrzej Kaczmarek DEFINE_SIMPLE_ATTRIBUTE(conn_info_max_age_fops, conn_info_max_age_get, 62331ad1691SAndrzej Kaczmarek conn_info_max_age_set, "%llu\n"); 62431ad1691SAndrzej Kaczmarek 625ac345813SMarcel Holtmann static int identity_show(struct seq_file *f, void *p) 626ac345813SMarcel Holtmann { 627ac345813SMarcel Holtmann struct hci_dev *hdev = f->private; 628a1f4c318SJohan Hedberg bdaddr_t addr; 629ac345813SMarcel Holtmann u8 addr_type; 630ac345813SMarcel Holtmann 631ac345813SMarcel Holtmann hci_dev_lock(hdev); 632ac345813SMarcel Holtmann 633a1f4c318SJohan Hedberg hci_copy_identity_address(hdev, &addr, &addr_type); 634ac345813SMarcel Holtmann 635a1f4c318SJohan Hedberg seq_printf(f, "%pMR (type %u) %*phN %pMR\n", &addr, addr_type, 636473deef2SMarcel Holtmann 16, hdev->irk, &hdev->rpa); 637ac345813SMarcel Holtmann 638ac345813SMarcel Holtmann hci_dev_unlock(hdev); 639ac345813SMarcel Holtmann 640ac345813SMarcel Holtmann return 0; 641ac345813SMarcel Holtmann } 642ac345813SMarcel Holtmann 643ac345813SMarcel Holtmann static int identity_open(struct inode *inode, struct file *file) 644ac345813SMarcel Holtmann { 645ac345813SMarcel Holtmann return single_open(file, identity_show, inode->i_private); 646ac345813SMarcel Holtmann } 647ac345813SMarcel Holtmann 648ac345813SMarcel Holtmann static const struct file_operations identity_fops = { 649ac345813SMarcel Holtmann .open = identity_open, 650ac345813SMarcel Holtmann .read = seq_read, 651ac345813SMarcel Holtmann .llseek = seq_lseek, 652ac345813SMarcel Holtmann .release = single_release, 653ac345813SMarcel Holtmann }; 654ac345813SMarcel Holtmann 6557a4cd51dSMarcel Holtmann static int random_address_show(struct seq_file *f, void *p) 6567a4cd51dSMarcel Holtmann { 6577a4cd51dSMarcel Holtmann struct hci_dev *hdev = f->private; 6587a4cd51dSMarcel Holtmann 6597a4cd51dSMarcel Holtmann hci_dev_lock(hdev); 6607a4cd51dSMarcel Holtmann seq_printf(f, "%pMR\n", &hdev->random_addr); 6617a4cd51dSMarcel Holtmann hci_dev_unlock(hdev); 6627a4cd51dSMarcel Holtmann 6637a4cd51dSMarcel Holtmann return 0; 6647a4cd51dSMarcel Holtmann } 6657a4cd51dSMarcel Holtmann 6667a4cd51dSMarcel Holtmann static int random_address_open(struct inode *inode, struct file *file) 6677a4cd51dSMarcel Holtmann { 6687a4cd51dSMarcel Holtmann return single_open(file, random_address_show, inode->i_private); 6697a4cd51dSMarcel Holtmann } 6707a4cd51dSMarcel Holtmann 6717a4cd51dSMarcel Holtmann static const struct file_operations random_address_fops = { 6727a4cd51dSMarcel Holtmann .open = random_address_open, 6737a4cd51dSMarcel Holtmann .read = seq_read, 6747a4cd51dSMarcel Holtmann .llseek = seq_lseek, 6757a4cd51dSMarcel Holtmann .release = single_release, 6767a4cd51dSMarcel Holtmann }; 6777a4cd51dSMarcel Holtmann 678e7b8fc92SMarcel Holtmann static int static_address_show(struct seq_file *f, void *p) 679e7b8fc92SMarcel Holtmann { 680e7b8fc92SMarcel Holtmann struct hci_dev *hdev = f->private; 681e7b8fc92SMarcel Holtmann 682e7b8fc92SMarcel Holtmann hci_dev_lock(hdev); 683e7b8fc92SMarcel Holtmann seq_printf(f, "%pMR\n", &hdev->static_addr); 684e7b8fc92SMarcel Holtmann hci_dev_unlock(hdev); 685e7b8fc92SMarcel Holtmann 686e7b8fc92SMarcel Holtmann return 0; 687e7b8fc92SMarcel Holtmann } 688e7b8fc92SMarcel Holtmann 689e7b8fc92SMarcel Holtmann static int static_address_open(struct inode *inode, struct file *file) 690e7b8fc92SMarcel Holtmann { 691e7b8fc92SMarcel Holtmann return single_open(file, static_address_show, inode->i_private); 692e7b8fc92SMarcel Holtmann } 693e7b8fc92SMarcel Holtmann 694e7b8fc92SMarcel Holtmann static const struct file_operations static_address_fops = { 695e7b8fc92SMarcel Holtmann .open = static_address_open, 696e7b8fc92SMarcel Holtmann .read = seq_read, 697e7b8fc92SMarcel Holtmann .llseek = seq_lseek, 698e7b8fc92SMarcel Holtmann .release = single_release, 699e7b8fc92SMarcel Holtmann }; 700e7b8fc92SMarcel Holtmann 701b32bba6cSMarcel Holtmann static ssize_t force_static_address_read(struct file *file, 702b32bba6cSMarcel Holtmann char __user *user_buf, 703b32bba6cSMarcel Holtmann size_t count, loff_t *ppos) 70492202185SMarcel Holtmann { 705b32bba6cSMarcel Holtmann struct hci_dev *hdev = file->private_data; 706b32bba6cSMarcel Holtmann char buf[3]; 70792202185SMarcel Holtmann 708111902f7SMarcel Holtmann buf[0] = test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) ? 'Y': 'N'; 709b32bba6cSMarcel Holtmann buf[1] = '\n'; 710b32bba6cSMarcel Holtmann buf[2] = '\0'; 711b32bba6cSMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 712b32bba6cSMarcel Holtmann } 713b32bba6cSMarcel Holtmann 714b32bba6cSMarcel Holtmann static ssize_t force_static_address_write(struct file *file, 715b32bba6cSMarcel Holtmann const char __user *user_buf, 716b32bba6cSMarcel Holtmann size_t count, loff_t *ppos) 717b32bba6cSMarcel Holtmann { 718b32bba6cSMarcel Holtmann struct hci_dev *hdev = file->private_data; 719b32bba6cSMarcel Holtmann char buf[32]; 720b32bba6cSMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 721b32bba6cSMarcel Holtmann bool enable; 722b32bba6cSMarcel Holtmann 723b32bba6cSMarcel Holtmann if (test_bit(HCI_UP, &hdev->flags)) 724b32bba6cSMarcel Holtmann return -EBUSY; 725b32bba6cSMarcel Holtmann 726b32bba6cSMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 727b32bba6cSMarcel Holtmann return -EFAULT; 728b32bba6cSMarcel Holtmann 729b32bba6cSMarcel Holtmann buf[buf_size] = '\0'; 730b32bba6cSMarcel Holtmann if (strtobool(buf, &enable)) 73192202185SMarcel Holtmann return -EINVAL; 73292202185SMarcel Holtmann 733111902f7SMarcel Holtmann if (enable == test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags)) 734b32bba6cSMarcel Holtmann return -EALREADY; 73592202185SMarcel Holtmann 736111902f7SMarcel Holtmann change_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags); 737b32bba6cSMarcel Holtmann 738b32bba6cSMarcel Holtmann return count; 73992202185SMarcel Holtmann } 74092202185SMarcel Holtmann 741b32bba6cSMarcel Holtmann static const struct file_operations force_static_address_fops = { 742b32bba6cSMarcel Holtmann .open = simple_open, 743b32bba6cSMarcel Holtmann .read = force_static_address_read, 744b32bba6cSMarcel Holtmann .write = force_static_address_write, 745b32bba6cSMarcel Holtmann .llseek = default_llseek, 746b32bba6cSMarcel Holtmann }; 74792202185SMarcel Holtmann 748d2ab0ac1SMarcel Holtmann static int white_list_show(struct seq_file *f, void *ptr) 749d2ab0ac1SMarcel Holtmann { 750d2ab0ac1SMarcel Holtmann struct hci_dev *hdev = f->private; 751d2ab0ac1SMarcel Holtmann struct bdaddr_list *b; 752d2ab0ac1SMarcel Holtmann 753d2ab0ac1SMarcel Holtmann hci_dev_lock(hdev); 754d2ab0ac1SMarcel Holtmann list_for_each_entry(b, &hdev->le_white_list, list) 755d2ab0ac1SMarcel Holtmann seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 756d2ab0ac1SMarcel Holtmann hci_dev_unlock(hdev); 757d2ab0ac1SMarcel Holtmann 758d2ab0ac1SMarcel Holtmann return 0; 759d2ab0ac1SMarcel Holtmann } 760d2ab0ac1SMarcel Holtmann 761d2ab0ac1SMarcel Holtmann static int white_list_open(struct inode *inode, struct file *file) 762d2ab0ac1SMarcel Holtmann { 763d2ab0ac1SMarcel Holtmann return single_open(file, white_list_show, inode->i_private); 764d2ab0ac1SMarcel Holtmann } 765d2ab0ac1SMarcel Holtmann 766d2ab0ac1SMarcel Holtmann static const struct file_operations white_list_fops = { 767d2ab0ac1SMarcel Holtmann .open = white_list_open, 768d2ab0ac1SMarcel Holtmann .read = seq_read, 769d2ab0ac1SMarcel Holtmann .llseek = seq_lseek, 770d2ab0ac1SMarcel Holtmann .release = single_release, 771d2ab0ac1SMarcel Holtmann }; 772d2ab0ac1SMarcel Holtmann 7733698d704SMarcel Holtmann static int identity_resolving_keys_show(struct seq_file *f, void *ptr) 7743698d704SMarcel Holtmann { 7753698d704SMarcel Holtmann struct hci_dev *hdev = f->private; 7763698d704SMarcel Holtmann struct list_head *p, *n; 7773698d704SMarcel Holtmann 7783698d704SMarcel Holtmann hci_dev_lock(hdev); 7793698d704SMarcel Holtmann list_for_each_safe(p, n, &hdev->identity_resolving_keys) { 7803698d704SMarcel Holtmann struct smp_irk *irk = list_entry(p, struct smp_irk, list); 7813698d704SMarcel Holtmann seq_printf(f, "%pMR (type %u) %*phN %pMR\n", 7823698d704SMarcel Holtmann &irk->bdaddr, irk->addr_type, 7833698d704SMarcel Holtmann 16, irk->val, &irk->rpa); 7843698d704SMarcel Holtmann } 7853698d704SMarcel Holtmann hci_dev_unlock(hdev); 7863698d704SMarcel Holtmann 7873698d704SMarcel Holtmann return 0; 7883698d704SMarcel Holtmann } 7893698d704SMarcel Holtmann 7903698d704SMarcel Holtmann static int identity_resolving_keys_open(struct inode *inode, struct file *file) 7913698d704SMarcel Holtmann { 7923698d704SMarcel Holtmann return single_open(file, identity_resolving_keys_show, 7933698d704SMarcel Holtmann inode->i_private); 7943698d704SMarcel Holtmann } 7953698d704SMarcel Holtmann 7963698d704SMarcel Holtmann static const struct file_operations identity_resolving_keys_fops = { 7973698d704SMarcel Holtmann .open = identity_resolving_keys_open, 7983698d704SMarcel Holtmann .read = seq_read, 7993698d704SMarcel Holtmann .llseek = seq_lseek, 8003698d704SMarcel Holtmann .release = single_release, 8013698d704SMarcel Holtmann }; 8023698d704SMarcel Holtmann 8038f8625cdSMarcel Holtmann static int long_term_keys_show(struct seq_file *f, void *ptr) 8048f8625cdSMarcel Holtmann { 8058f8625cdSMarcel Holtmann struct hci_dev *hdev = f->private; 8068f8625cdSMarcel Holtmann struct list_head *p, *n; 8078f8625cdSMarcel Holtmann 8088f8625cdSMarcel Holtmann hci_dev_lock(hdev); 809f813f1beSJohan Hedberg list_for_each_safe(p, n, &hdev->long_term_keys) { 8108f8625cdSMarcel Holtmann struct smp_ltk *ltk = list_entry(p, struct smp_ltk, list); 811fe39c7b2SMarcel Holtmann seq_printf(f, "%pMR (type %u) %u 0x%02x %u %.4x %.16llx %*phN\n", 8128f8625cdSMarcel Holtmann <k->bdaddr, ltk->bdaddr_type, ltk->authenticated, 8138f8625cdSMarcel Holtmann ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv), 814fe39c7b2SMarcel Holtmann __le64_to_cpu(ltk->rand), 16, ltk->val); 8158f8625cdSMarcel Holtmann } 8168f8625cdSMarcel Holtmann hci_dev_unlock(hdev); 8178f8625cdSMarcel Holtmann 8188f8625cdSMarcel Holtmann return 0; 8198f8625cdSMarcel Holtmann } 8208f8625cdSMarcel Holtmann 8218f8625cdSMarcel Holtmann static int long_term_keys_open(struct inode *inode, struct file *file) 8228f8625cdSMarcel Holtmann { 8238f8625cdSMarcel Holtmann return single_open(file, long_term_keys_show, inode->i_private); 8248f8625cdSMarcel Holtmann } 8258f8625cdSMarcel Holtmann 8268f8625cdSMarcel Holtmann static const struct file_operations long_term_keys_fops = { 8278f8625cdSMarcel Holtmann .open = long_term_keys_open, 8288f8625cdSMarcel Holtmann .read = seq_read, 8298f8625cdSMarcel Holtmann .llseek = seq_lseek, 8308f8625cdSMarcel Holtmann .release = single_release, 8318f8625cdSMarcel Holtmann }; 8328f8625cdSMarcel Holtmann 8334e70c7e7SMarcel Holtmann static int conn_min_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_max_interval) 8384e70c7e7SMarcel Holtmann return -EINVAL; 8394e70c7e7SMarcel Holtmann 8404e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 8414e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = val; 8424e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 8434e70c7e7SMarcel Holtmann 8444e70c7e7SMarcel Holtmann return 0; 8454e70c7e7SMarcel Holtmann } 8464e70c7e7SMarcel Holtmann 8474e70c7e7SMarcel Holtmann static int conn_min_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_min_interval; 8534e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 8544e70c7e7SMarcel Holtmann 8554e70c7e7SMarcel Holtmann return 0; 8564e70c7e7SMarcel Holtmann } 8574e70c7e7SMarcel Holtmann 8584e70c7e7SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get, 8594e70c7e7SMarcel Holtmann conn_min_interval_set, "%llu\n"); 8604e70c7e7SMarcel Holtmann 8614e70c7e7SMarcel Holtmann static int conn_max_interval_set(void *data, u64 val) 8624e70c7e7SMarcel Holtmann { 8634e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 8644e70c7e7SMarcel Holtmann 8654e70c7e7SMarcel Holtmann if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval) 8664e70c7e7SMarcel Holtmann return -EINVAL; 8674e70c7e7SMarcel Holtmann 8684e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 8694e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = val; 8704e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 8714e70c7e7SMarcel Holtmann 8724e70c7e7SMarcel Holtmann return 0; 8734e70c7e7SMarcel Holtmann } 8744e70c7e7SMarcel Holtmann 8754e70c7e7SMarcel Holtmann static int conn_max_interval_get(void *data, u64 *val) 8764e70c7e7SMarcel Holtmann { 8774e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 8784e70c7e7SMarcel Holtmann 8794e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 8804e70c7e7SMarcel Holtmann *val = hdev->le_conn_max_interval; 8814e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 8824e70c7e7SMarcel Holtmann 8834e70c7e7SMarcel Holtmann return 0; 8844e70c7e7SMarcel Holtmann } 8854e70c7e7SMarcel Holtmann 8864e70c7e7SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get, 8874e70c7e7SMarcel Holtmann conn_max_interval_set, "%llu\n"); 8884e70c7e7SMarcel Holtmann 889816a93d1SMarcel Holtmann static int conn_latency_set(void *data, u64 val) 890816a93d1SMarcel Holtmann { 891816a93d1SMarcel Holtmann struct hci_dev *hdev = data; 892816a93d1SMarcel Holtmann 893816a93d1SMarcel Holtmann if (val > 0x01f3) 894816a93d1SMarcel Holtmann return -EINVAL; 895816a93d1SMarcel Holtmann 896816a93d1SMarcel Holtmann hci_dev_lock(hdev); 897816a93d1SMarcel Holtmann hdev->le_conn_latency = val; 898816a93d1SMarcel Holtmann hci_dev_unlock(hdev); 899816a93d1SMarcel Holtmann 900816a93d1SMarcel Holtmann return 0; 901816a93d1SMarcel Holtmann } 902816a93d1SMarcel Holtmann 903816a93d1SMarcel Holtmann static int conn_latency_get(void *data, u64 *val) 904816a93d1SMarcel Holtmann { 905816a93d1SMarcel Holtmann struct hci_dev *hdev = data; 906816a93d1SMarcel Holtmann 907816a93d1SMarcel Holtmann hci_dev_lock(hdev); 908816a93d1SMarcel Holtmann *val = hdev->le_conn_latency; 909816a93d1SMarcel Holtmann hci_dev_unlock(hdev); 910816a93d1SMarcel Holtmann 911816a93d1SMarcel Holtmann return 0; 912816a93d1SMarcel Holtmann } 913816a93d1SMarcel Holtmann 914816a93d1SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(conn_latency_fops, conn_latency_get, 915816a93d1SMarcel Holtmann conn_latency_set, "%llu\n"); 916816a93d1SMarcel Holtmann 917f1649577SMarcel Holtmann static int supervision_timeout_set(void *data, u64 val) 918f1649577SMarcel Holtmann { 919f1649577SMarcel Holtmann struct hci_dev *hdev = data; 920f1649577SMarcel Holtmann 921f1649577SMarcel Holtmann if (val < 0x000a || val > 0x0c80) 922f1649577SMarcel Holtmann return -EINVAL; 923f1649577SMarcel Holtmann 924f1649577SMarcel Holtmann hci_dev_lock(hdev); 925f1649577SMarcel Holtmann hdev->le_supv_timeout = val; 926f1649577SMarcel Holtmann hci_dev_unlock(hdev); 927f1649577SMarcel Holtmann 928f1649577SMarcel Holtmann return 0; 929f1649577SMarcel Holtmann } 930f1649577SMarcel Holtmann 931f1649577SMarcel Holtmann static int supervision_timeout_get(void *data, u64 *val) 932f1649577SMarcel Holtmann { 933f1649577SMarcel Holtmann struct hci_dev *hdev = data; 934f1649577SMarcel Holtmann 935f1649577SMarcel Holtmann hci_dev_lock(hdev); 936f1649577SMarcel Holtmann *val = hdev->le_supv_timeout; 937f1649577SMarcel Holtmann hci_dev_unlock(hdev); 938f1649577SMarcel Holtmann 939f1649577SMarcel Holtmann return 0; 940f1649577SMarcel Holtmann } 941f1649577SMarcel Holtmann 942f1649577SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(supervision_timeout_fops, supervision_timeout_get, 943f1649577SMarcel Holtmann supervision_timeout_set, "%llu\n"); 944f1649577SMarcel Holtmann 9453f959d46SMarcel Holtmann static int adv_channel_map_set(void *data, u64 val) 9463f959d46SMarcel Holtmann { 9473f959d46SMarcel Holtmann struct hci_dev *hdev = data; 9483f959d46SMarcel Holtmann 9493f959d46SMarcel Holtmann if (val < 0x01 || val > 0x07) 9503f959d46SMarcel Holtmann return -EINVAL; 9513f959d46SMarcel Holtmann 9523f959d46SMarcel Holtmann hci_dev_lock(hdev); 9533f959d46SMarcel Holtmann hdev->le_adv_channel_map = val; 9543f959d46SMarcel Holtmann hci_dev_unlock(hdev); 9553f959d46SMarcel Holtmann 9563f959d46SMarcel Holtmann return 0; 9573f959d46SMarcel Holtmann } 9583f959d46SMarcel Holtmann 9593f959d46SMarcel Holtmann static int adv_channel_map_get(void *data, u64 *val) 9603f959d46SMarcel Holtmann { 9613f959d46SMarcel Holtmann struct hci_dev *hdev = data; 9623f959d46SMarcel Holtmann 9633f959d46SMarcel Holtmann hci_dev_lock(hdev); 9643f959d46SMarcel Holtmann *val = hdev->le_adv_channel_map; 9653f959d46SMarcel Holtmann hci_dev_unlock(hdev); 9663f959d46SMarcel Holtmann 9673f959d46SMarcel Holtmann return 0; 9683f959d46SMarcel Holtmann } 9693f959d46SMarcel Holtmann 9703f959d46SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(adv_channel_map_fops, adv_channel_map_get, 9713f959d46SMarcel Holtmann adv_channel_map_set, "%llu\n"); 9723f959d46SMarcel Holtmann 973729a1051SGeorg Lukas static int adv_min_interval_set(void *data, u64 val) 97489863109SJukka Rissanen { 975729a1051SGeorg Lukas struct hci_dev *hdev = data; 97689863109SJukka Rissanen 977729a1051SGeorg Lukas if (val < 0x0020 || val > 0x4000 || val > hdev->le_adv_max_interval) 97889863109SJukka Rissanen return -EINVAL; 97989863109SJukka Rissanen 9807d474e06SAndre Guedes hci_dev_lock(hdev); 981729a1051SGeorg Lukas hdev->le_adv_min_interval = val; 9827d474e06SAndre Guedes hci_dev_unlock(hdev); 9837d474e06SAndre Guedes 9847d474e06SAndre Guedes return 0; 9857d474e06SAndre Guedes } 9867d474e06SAndre Guedes 987729a1051SGeorg Lukas static int adv_min_interval_get(void *data, u64 *val) 9887d474e06SAndre Guedes { 989729a1051SGeorg Lukas struct hci_dev *hdev = data; 990729a1051SGeorg Lukas 991729a1051SGeorg Lukas hci_dev_lock(hdev); 992729a1051SGeorg Lukas *val = hdev->le_adv_min_interval; 993729a1051SGeorg Lukas hci_dev_unlock(hdev); 994729a1051SGeorg Lukas 995729a1051SGeorg Lukas return 0; 9967d474e06SAndre Guedes } 9977d474e06SAndre Guedes 998729a1051SGeorg Lukas DEFINE_SIMPLE_ATTRIBUTE(adv_min_interval_fops, adv_min_interval_get, 999729a1051SGeorg Lukas adv_min_interval_set, "%llu\n"); 10007d474e06SAndre Guedes 1001729a1051SGeorg Lukas static int adv_max_interval_set(void *data, u64 val) 1002729a1051SGeorg Lukas { 1003729a1051SGeorg Lukas struct hci_dev *hdev = data; 1004729a1051SGeorg Lukas 1005729a1051SGeorg Lukas if (val < 0x0020 || val > 0x4000 || val < hdev->le_adv_min_interval) 10067d474e06SAndre Guedes return -EINVAL; 10077d474e06SAndre Guedes 10087d474e06SAndre Guedes hci_dev_lock(hdev); 1009729a1051SGeorg Lukas hdev->le_adv_max_interval = val; 10107d474e06SAndre Guedes hci_dev_unlock(hdev); 10117d474e06SAndre Guedes 1012729a1051SGeorg Lukas return 0; 10137d474e06SAndre Guedes } 10147d474e06SAndre Guedes 1015729a1051SGeorg Lukas static int adv_max_interval_get(void *data, u64 *val) 1016729a1051SGeorg Lukas { 1017729a1051SGeorg Lukas struct hci_dev *hdev = data; 1018729a1051SGeorg Lukas 10197d474e06SAndre Guedes hci_dev_lock(hdev); 1020729a1051SGeorg Lukas *val = hdev->le_adv_max_interval; 10217d474e06SAndre Guedes hci_dev_unlock(hdev); 1022729a1051SGeorg Lukas 1023729a1051SGeorg Lukas return 0; 1024729a1051SGeorg Lukas } 1025729a1051SGeorg Lukas 1026729a1051SGeorg Lukas DEFINE_SIMPLE_ATTRIBUTE(adv_max_interval_fops, adv_max_interval_get, 1027729a1051SGeorg Lukas adv_max_interval_set, "%llu\n"); 1028729a1051SGeorg Lukas 10290b3c7d37SMarcel Holtmann static int device_list_show(struct seq_file *f, void *ptr) 10307d474e06SAndre Guedes { 10310b3c7d37SMarcel Holtmann struct hci_dev *hdev = f->private; 10327d474e06SAndre Guedes struct hci_conn_params *p; 10337d474e06SAndre Guedes 10347d474e06SAndre Guedes hci_dev_lock(hdev); 10357d474e06SAndre Guedes list_for_each_entry(p, &hdev->le_conn_params, list) { 10360b3c7d37SMarcel Holtmann seq_printf(f, "%pMR %u %u\n", &p->addr, p->addr_type, 10377d474e06SAndre Guedes p->auto_connect); 10387d474e06SAndre Guedes } 10397d474e06SAndre Guedes hci_dev_unlock(hdev); 10407d474e06SAndre Guedes 10417d474e06SAndre Guedes return 0; 10427d474e06SAndre Guedes } 10437d474e06SAndre Guedes 10440b3c7d37SMarcel Holtmann static int device_list_open(struct inode *inode, struct file *file) 10457d474e06SAndre Guedes { 10460b3c7d37SMarcel Holtmann return single_open(file, device_list_show, inode->i_private); 10477d474e06SAndre Guedes } 10487d474e06SAndre Guedes 10490b3c7d37SMarcel Holtmann static const struct file_operations device_list_fops = { 10500b3c7d37SMarcel Holtmann .open = device_list_open, 10517d474e06SAndre Guedes .read = seq_read, 10527d474e06SAndre Guedes .llseek = seq_lseek, 10537d474e06SAndre Guedes .release = single_release, 10547d474e06SAndre Guedes }; 10557d474e06SAndre Guedes 10561da177e4SLinus Torvalds /* ---- HCI requests ---- */ 10571da177e4SLinus Torvalds 105842c6b129SJohan Hedberg static void hci_req_sync_complete(struct hci_dev *hdev, u8 result) 10591da177e4SLinus Torvalds { 106042c6b129SJohan Hedberg BT_DBG("%s result 0x%2.2x", hdev->name, result); 106175fb0e32SJohan Hedberg 10621da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 10631da177e4SLinus Torvalds hdev->req_result = result; 10641da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 10651da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 10661da177e4SLinus Torvalds } 10671da177e4SLinus Torvalds } 10681da177e4SLinus Torvalds 10691da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 10701da177e4SLinus Torvalds { 10711da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 10721da177e4SLinus Torvalds 10731da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 10741da177e4SLinus Torvalds hdev->req_result = err; 10751da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 10761da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 10771da177e4SLinus Torvalds } 10781da177e4SLinus Torvalds } 10791da177e4SLinus Torvalds 108077a63e0aSFengguang Wu static struct sk_buff *hci_get_cmd_complete(struct hci_dev *hdev, u16 opcode, 108177a63e0aSFengguang Wu u8 event) 108275e84b7cSJohan Hedberg { 108375e84b7cSJohan Hedberg struct hci_ev_cmd_complete *ev; 108475e84b7cSJohan Hedberg struct hci_event_hdr *hdr; 108575e84b7cSJohan Hedberg struct sk_buff *skb; 108675e84b7cSJohan Hedberg 108775e84b7cSJohan Hedberg hci_dev_lock(hdev); 108875e84b7cSJohan Hedberg 108975e84b7cSJohan Hedberg skb = hdev->recv_evt; 109075e84b7cSJohan Hedberg hdev->recv_evt = NULL; 109175e84b7cSJohan Hedberg 109275e84b7cSJohan Hedberg hci_dev_unlock(hdev); 109375e84b7cSJohan Hedberg 109475e84b7cSJohan Hedberg if (!skb) 109575e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 109675e84b7cSJohan Hedberg 109775e84b7cSJohan Hedberg if (skb->len < sizeof(*hdr)) { 109875e84b7cSJohan Hedberg BT_ERR("Too short HCI event"); 109975e84b7cSJohan Hedberg goto failed; 110075e84b7cSJohan Hedberg } 110175e84b7cSJohan Hedberg 110275e84b7cSJohan Hedberg hdr = (void *) skb->data; 110375e84b7cSJohan Hedberg skb_pull(skb, HCI_EVENT_HDR_SIZE); 110475e84b7cSJohan Hedberg 11057b1abbbeSJohan Hedberg if (event) { 11067b1abbbeSJohan Hedberg if (hdr->evt != event) 11077b1abbbeSJohan Hedberg goto failed; 11087b1abbbeSJohan Hedberg return skb; 11097b1abbbeSJohan Hedberg } 11107b1abbbeSJohan Hedberg 111175e84b7cSJohan Hedberg if (hdr->evt != HCI_EV_CMD_COMPLETE) { 111275e84b7cSJohan Hedberg BT_DBG("Last event is not cmd complete (0x%2.2x)", hdr->evt); 111375e84b7cSJohan Hedberg goto failed; 111475e84b7cSJohan Hedberg } 111575e84b7cSJohan Hedberg 111675e84b7cSJohan Hedberg if (skb->len < sizeof(*ev)) { 111775e84b7cSJohan Hedberg BT_ERR("Too short cmd_complete event"); 111875e84b7cSJohan Hedberg goto failed; 111975e84b7cSJohan Hedberg } 112075e84b7cSJohan Hedberg 112175e84b7cSJohan Hedberg ev = (void *) skb->data; 112275e84b7cSJohan Hedberg skb_pull(skb, sizeof(*ev)); 112375e84b7cSJohan Hedberg 112475e84b7cSJohan Hedberg if (opcode == __le16_to_cpu(ev->opcode)) 112575e84b7cSJohan Hedberg return skb; 112675e84b7cSJohan Hedberg 112775e84b7cSJohan Hedberg BT_DBG("opcode doesn't match (0x%2.2x != 0x%2.2x)", opcode, 112875e84b7cSJohan Hedberg __le16_to_cpu(ev->opcode)); 112975e84b7cSJohan Hedberg 113075e84b7cSJohan Hedberg failed: 113175e84b7cSJohan Hedberg kfree_skb(skb); 113275e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 113375e84b7cSJohan Hedberg } 113475e84b7cSJohan Hedberg 11357b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, 113607dc93ddSJohan Hedberg const void *param, u8 event, u32 timeout) 113775e84b7cSJohan Hedberg { 113875e84b7cSJohan Hedberg DECLARE_WAITQUEUE(wait, current); 113975e84b7cSJohan Hedberg struct hci_request req; 114075e84b7cSJohan Hedberg int err = 0; 114175e84b7cSJohan Hedberg 114275e84b7cSJohan Hedberg BT_DBG("%s", hdev->name); 114375e84b7cSJohan Hedberg 114475e84b7cSJohan Hedberg hci_req_init(&req, hdev); 114575e84b7cSJohan Hedberg 11467b1abbbeSJohan Hedberg hci_req_add_ev(&req, opcode, plen, param, event); 114775e84b7cSJohan Hedberg 114875e84b7cSJohan Hedberg hdev->req_status = HCI_REQ_PEND; 114975e84b7cSJohan Hedberg 115075e84b7cSJohan Hedberg add_wait_queue(&hdev->req_wait_q, &wait); 115175e84b7cSJohan Hedberg set_current_state(TASK_INTERRUPTIBLE); 115275e84b7cSJohan Hedberg 1153039fada5SChan-yeol Park err = hci_req_run(&req, hci_req_sync_complete); 1154039fada5SChan-yeol Park if (err < 0) { 1155039fada5SChan-yeol Park remove_wait_queue(&hdev->req_wait_q, &wait); 1156039fada5SChan-yeol Park return ERR_PTR(err); 1157039fada5SChan-yeol Park } 1158039fada5SChan-yeol Park 115975e84b7cSJohan Hedberg schedule_timeout(timeout); 116075e84b7cSJohan Hedberg 116175e84b7cSJohan Hedberg remove_wait_queue(&hdev->req_wait_q, &wait); 116275e84b7cSJohan Hedberg 116375e84b7cSJohan Hedberg if (signal_pending(current)) 116475e84b7cSJohan Hedberg return ERR_PTR(-EINTR); 116575e84b7cSJohan Hedberg 116675e84b7cSJohan Hedberg switch (hdev->req_status) { 116775e84b7cSJohan Hedberg case HCI_REQ_DONE: 116875e84b7cSJohan Hedberg err = -bt_to_errno(hdev->req_result); 116975e84b7cSJohan Hedberg break; 117075e84b7cSJohan Hedberg 117175e84b7cSJohan Hedberg case HCI_REQ_CANCELED: 117275e84b7cSJohan Hedberg err = -hdev->req_result; 117375e84b7cSJohan Hedberg break; 117475e84b7cSJohan Hedberg 117575e84b7cSJohan Hedberg default: 117675e84b7cSJohan Hedberg err = -ETIMEDOUT; 117775e84b7cSJohan Hedberg break; 117875e84b7cSJohan Hedberg } 117975e84b7cSJohan Hedberg 118075e84b7cSJohan Hedberg hdev->req_status = hdev->req_result = 0; 118175e84b7cSJohan Hedberg 118275e84b7cSJohan Hedberg BT_DBG("%s end: err %d", hdev->name, err); 118375e84b7cSJohan Hedberg 118475e84b7cSJohan Hedberg if (err < 0) 118575e84b7cSJohan Hedberg return ERR_PTR(err); 118675e84b7cSJohan Hedberg 11877b1abbbeSJohan Hedberg return hci_get_cmd_complete(hdev, opcode, event); 11887b1abbbeSJohan Hedberg } 11897b1abbbeSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync_ev); 11907b1abbbeSJohan Hedberg 11917b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 119207dc93ddSJohan Hedberg const void *param, u32 timeout) 11937b1abbbeSJohan Hedberg { 11947b1abbbeSJohan Hedberg return __hci_cmd_sync_ev(hdev, opcode, plen, param, 0, timeout); 119575e84b7cSJohan Hedberg } 119675e84b7cSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync); 119775e84b7cSJohan Hedberg 11981da177e4SLinus Torvalds /* Execute request and wait for completion. */ 119901178cd4SJohan Hedberg static int __hci_req_sync(struct hci_dev *hdev, 120042c6b129SJohan Hedberg void (*func)(struct hci_request *req, 120142c6b129SJohan Hedberg unsigned long opt), 12021da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 12031da177e4SLinus Torvalds { 120442c6b129SJohan Hedberg struct hci_request req; 12051da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 12061da177e4SLinus Torvalds int err = 0; 12071da177e4SLinus Torvalds 12081da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 12091da177e4SLinus Torvalds 121042c6b129SJohan Hedberg hci_req_init(&req, hdev); 121142c6b129SJohan Hedberg 12121da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 12131da177e4SLinus Torvalds 121442c6b129SJohan Hedberg func(&req, opt); 121553cce22dSJohan Hedberg 1216039fada5SChan-yeol Park add_wait_queue(&hdev->req_wait_q, &wait); 1217039fada5SChan-yeol Park set_current_state(TASK_INTERRUPTIBLE); 1218039fada5SChan-yeol Park 121942c6b129SJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 122042c6b129SJohan Hedberg if (err < 0) { 122153cce22dSJohan Hedberg hdev->req_status = 0; 1222920c8300SAndre Guedes 1223039fada5SChan-yeol Park remove_wait_queue(&hdev->req_wait_q, &wait); 1224039fada5SChan-yeol Park 1225920c8300SAndre Guedes /* ENODATA means the HCI request command queue is empty. 1226920c8300SAndre Guedes * This can happen when a request with conditionals doesn't 1227920c8300SAndre Guedes * trigger any commands to be sent. This is normal behavior 1228920c8300SAndre Guedes * and should not trigger an error return. 122942c6b129SJohan Hedberg */ 1230920c8300SAndre Guedes if (err == -ENODATA) 123142c6b129SJohan Hedberg return 0; 1232920c8300SAndre Guedes 1233920c8300SAndre Guedes return err; 123453cce22dSJohan Hedberg } 123553cce22dSJohan Hedberg 12361da177e4SLinus Torvalds schedule_timeout(timeout); 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 12391da177e4SLinus Torvalds 12401da177e4SLinus Torvalds if (signal_pending(current)) 12411da177e4SLinus Torvalds return -EINTR; 12421da177e4SLinus Torvalds 12431da177e4SLinus Torvalds switch (hdev->req_status) { 12441da177e4SLinus Torvalds case HCI_REQ_DONE: 1245e175072fSJoe Perches err = -bt_to_errno(hdev->req_result); 12461da177e4SLinus Torvalds break; 12471da177e4SLinus Torvalds 12481da177e4SLinus Torvalds case HCI_REQ_CANCELED: 12491da177e4SLinus Torvalds err = -hdev->req_result; 12501da177e4SLinus Torvalds break; 12511da177e4SLinus Torvalds 12521da177e4SLinus Torvalds default: 12531da177e4SLinus Torvalds err = -ETIMEDOUT; 12541da177e4SLinus Torvalds break; 12553ff50b79SStephen Hemminger } 12561da177e4SLinus Torvalds 1257a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 12581da177e4SLinus Torvalds 12591da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 12601da177e4SLinus Torvalds 12611da177e4SLinus Torvalds return err; 12621da177e4SLinus Torvalds } 12631da177e4SLinus Torvalds 126401178cd4SJohan Hedberg static int hci_req_sync(struct hci_dev *hdev, 126542c6b129SJohan Hedberg void (*req)(struct hci_request *req, 126642c6b129SJohan Hedberg unsigned long opt), 12671da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 12681da177e4SLinus Torvalds { 12691da177e4SLinus Torvalds int ret; 12701da177e4SLinus Torvalds 12717c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 12727c6a329eSMarcel Holtmann return -ENETDOWN; 12737c6a329eSMarcel Holtmann 12741da177e4SLinus Torvalds /* Serialize all requests */ 12751da177e4SLinus Torvalds hci_req_lock(hdev); 127601178cd4SJohan Hedberg ret = __hci_req_sync(hdev, req, opt, timeout); 12771da177e4SLinus Torvalds hci_req_unlock(hdev); 12781da177e4SLinus Torvalds 12791da177e4SLinus Torvalds return ret; 12801da177e4SLinus Torvalds } 12811da177e4SLinus Torvalds 128242c6b129SJohan Hedberg static void hci_reset_req(struct hci_request *req, unsigned long opt) 12831da177e4SLinus Torvalds { 128442c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 12851da177e4SLinus Torvalds 12861da177e4SLinus Torvalds /* Reset device */ 128742c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 128842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 12891da177e4SLinus Torvalds } 12901da177e4SLinus Torvalds 129142c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 12921da177e4SLinus Torvalds { 129342c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 12942455a3eaSAndrei Emeltchenko 12951da177e4SLinus Torvalds /* Read Local Supported Features */ 129642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 12971da177e4SLinus Torvalds 12981143e5a6SMarcel Holtmann /* Read Local Version */ 129942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 13002177bab5SJohan Hedberg 13012177bab5SJohan Hedberg /* Read BD Address */ 130242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 13031da177e4SLinus Torvalds } 13041da177e4SLinus Torvalds 130542c6b129SJohan Hedberg static void amp_init(struct hci_request *req) 1306e61ef499SAndrei Emeltchenko { 130742c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 13082455a3eaSAndrei Emeltchenko 1309e61ef499SAndrei Emeltchenko /* Read Local Version */ 131042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 13116bcbc489SAndrei Emeltchenko 1312f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 1313f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 1314f6996cfeSMarcel Holtmann 1315f6996cfeSMarcel Holtmann /* Read Local Supported Features */ 1316f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 1317f6996cfeSMarcel Holtmann 13186bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 131942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 1320e71dfabaSAndrei Emeltchenko 1321e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 132242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 13237528ca1cSMarcel Holtmann 1324f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 1325f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 1326f38ba941SMarcel Holtmann 13277528ca1cSMarcel Holtmann /* Read Location Data */ 13287528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 1329e61ef499SAndrei Emeltchenko } 1330e61ef499SAndrei Emeltchenko 133142c6b129SJohan Hedberg static void hci_init1_req(struct hci_request *req, unsigned long opt) 1332e61ef499SAndrei Emeltchenko { 133342c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 1334e61ef499SAndrei Emeltchenko 1335e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 1336e61ef499SAndrei Emeltchenko 133711778716SAndrei Emeltchenko /* Reset */ 133811778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 133942c6b129SJohan Hedberg hci_reset_req(req, 0); 134011778716SAndrei Emeltchenko 1341e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 1342e61ef499SAndrei Emeltchenko case HCI_BREDR: 134342c6b129SJohan Hedberg bredr_init(req); 1344e61ef499SAndrei Emeltchenko break; 1345e61ef499SAndrei Emeltchenko 1346e61ef499SAndrei Emeltchenko case HCI_AMP: 134742c6b129SJohan Hedberg amp_init(req); 1348e61ef499SAndrei Emeltchenko break; 1349e61ef499SAndrei Emeltchenko 1350e61ef499SAndrei Emeltchenko default: 1351e61ef499SAndrei Emeltchenko BT_ERR("Unknown device type %d", hdev->dev_type); 1352e61ef499SAndrei Emeltchenko break; 1353e61ef499SAndrei Emeltchenko } 1354e61ef499SAndrei Emeltchenko } 1355e61ef499SAndrei Emeltchenko 135642c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 13572177bab5SJohan Hedberg { 13584ca048e3SMarcel Holtmann struct hci_dev *hdev = req->hdev; 13594ca048e3SMarcel Holtmann 13602177bab5SJohan Hedberg __le16 param; 13612177bab5SJohan Hedberg __u8 flt_type; 13622177bab5SJohan Hedberg 13632177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 136442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 13652177bab5SJohan Hedberg 13662177bab5SJohan Hedberg /* Read Class of Device */ 136742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 13682177bab5SJohan Hedberg 13692177bab5SJohan Hedberg /* Read Local Name */ 137042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 13712177bab5SJohan Hedberg 13722177bab5SJohan Hedberg /* Read Voice Setting */ 137342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 13742177bab5SJohan Hedberg 1375b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 1376b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 1377b4cb9fb2SMarcel Holtmann 13784b836f39SMarcel Holtmann /* Read Current IAC LAP */ 13794b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 13804b836f39SMarcel Holtmann 13812177bab5SJohan Hedberg /* Clear Event Filters */ 13822177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 138342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 13842177bab5SJohan Hedberg 13852177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 1386dcf4adbfSJoe Perches param = cpu_to_le16(0x7d00); 138742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 13882177bab5SJohan Hedberg 13894ca048e3SMarcel Holtmann /* AVM Berlin (31), aka "BlueFRITZ!", reports version 1.2, 13904ca048e3SMarcel Holtmann * but it does not support page scan related HCI commands. 13914ca048e3SMarcel Holtmann */ 13924ca048e3SMarcel Holtmann if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) { 1393f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 1394f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 1395f332ec66SJohan Hedberg } 13962177bab5SJohan Hedberg } 13972177bab5SJohan Hedberg 139842c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 13992177bab5SJohan Hedberg { 1400c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 1401c73eee91SJohan Hedberg 14022177bab5SJohan Hedberg /* Read LE Buffer Size */ 140342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 14042177bab5SJohan Hedberg 14052177bab5SJohan Hedberg /* Read LE Local Supported Features */ 140642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 14072177bab5SJohan Hedberg 1408747d3f03SMarcel Holtmann /* Read LE Supported States */ 1409747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 1410747d3f03SMarcel Holtmann 14112177bab5SJohan Hedberg /* Read LE White List Size */ 141242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 0, NULL); 14132177bab5SJohan Hedberg 1414747d3f03SMarcel Holtmann /* Clear LE White List */ 1415747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 1416c73eee91SJohan Hedberg 1417c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 1418c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1419c73eee91SJohan Hedberg set_bit(HCI_LE_ENABLED, &hdev->dev_flags); 14202177bab5SJohan Hedberg } 14212177bab5SJohan Hedberg 14222177bab5SJohan Hedberg static u8 hci_get_inquiry_mode(struct hci_dev *hdev) 14232177bab5SJohan Hedberg { 14242177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 14252177bab5SJohan Hedberg return 0x02; 14262177bab5SJohan Hedberg 14272177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 14282177bab5SJohan Hedberg return 0x01; 14292177bab5SJohan Hedberg 14302177bab5SJohan Hedberg if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 && 14312177bab5SJohan Hedberg hdev->lmp_subver == 0x0757) 14322177bab5SJohan Hedberg return 0x01; 14332177bab5SJohan Hedberg 14342177bab5SJohan Hedberg if (hdev->manufacturer == 15) { 14352177bab5SJohan Hedberg if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963) 14362177bab5SJohan Hedberg return 0x01; 14372177bab5SJohan Hedberg if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963) 14382177bab5SJohan Hedberg return 0x01; 14392177bab5SJohan Hedberg if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965) 14402177bab5SJohan Hedberg return 0x01; 14412177bab5SJohan Hedberg } 14422177bab5SJohan Hedberg 14432177bab5SJohan Hedberg if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 && 14442177bab5SJohan Hedberg hdev->lmp_subver == 0x1805) 14452177bab5SJohan Hedberg return 0x01; 14462177bab5SJohan Hedberg 14472177bab5SJohan Hedberg return 0x00; 14482177bab5SJohan Hedberg } 14492177bab5SJohan Hedberg 145042c6b129SJohan Hedberg static void hci_setup_inquiry_mode(struct hci_request *req) 14512177bab5SJohan Hedberg { 14522177bab5SJohan Hedberg u8 mode; 14532177bab5SJohan Hedberg 145442c6b129SJohan Hedberg mode = hci_get_inquiry_mode(req->hdev); 14552177bab5SJohan Hedberg 145642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 14572177bab5SJohan Hedberg } 14582177bab5SJohan Hedberg 145942c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 14602177bab5SJohan Hedberg { 146142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 146242c6b129SJohan Hedberg 14632177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 14642177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 14652177bab5SJohan Hedberg * command otherwise. 14662177bab5SJohan Hedberg */ 14672177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 14682177bab5SJohan Hedberg 14692177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 14702177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 14712177bab5SJohan Hedberg */ 14722177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 14732177bab5SJohan Hedberg return; 14742177bab5SJohan Hedberg 14752177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 14762177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 14772177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 14782177bab5SJohan Hedberg events[4] |= 0x04; /* Read Remote Extended Features Complete */ 14792177bab5SJohan Hedberg events[5] |= 0x08; /* Synchronous Connection Complete */ 14802177bab5SJohan Hedberg events[5] |= 0x10; /* Synchronous Connection Changed */ 1481c7882cbdSMarcel Holtmann } else { 1482c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 1483c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 1484c7882cbdSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 1485c7882cbdSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information Complete */ 1486c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 1487c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 1488c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 1489c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 1490c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 14910da71f1bSMarcel Holtmann 14920da71f1bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) { 14930da71f1bSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 1494c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 14952177bab5SJohan Hedberg } 14960da71f1bSMarcel Holtmann } 14972177bab5SJohan Hedberg 14982177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 14992177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 15002177bab5SJohan Hedberg 15012177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 15022177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 15032177bab5SJohan Hedberg 15042177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 15052177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 15062177bab5SJohan Hedberg 15072177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 15082177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 15092177bab5SJohan Hedberg 15102177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 15112177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 15122177bab5SJohan Hedberg 15132177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 15142177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 15152177bab5SJohan Hedberg 15162177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 15172177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 15182177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 15192177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 15202177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 15212177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 15222177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 15232177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 15242177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 15252177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 15262177bab5SJohan Hedberg * Features Notification 15272177bab5SJohan Hedberg */ 15282177bab5SJohan Hedberg } 15292177bab5SJohan Hedberg 15302177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 15312177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 15322177bab5SJohan Hedberg 153342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 15342177bab5SJohan Hedberg } 15352177bab5SJohan Hedberg 153642c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 15372177bab5SJohan Hedberg { 153842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 153942c6b129SJohan Hedberg 15402177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 154142c6b129SJohan Hedberg bredr_setup(req); 154256f87901SJohan Hedberg else 154356f87901SJohan Hedberg clear_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 15442177bab5SJohan Hedberg 15452177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 154642c6b129SJohan Hedberg le_setup(req); 15472177bab5SJohan Hedberg 15483f8e2d75SJohan Hedberg /* AVM Berlin (31), aka "BlueFRITZ!", doesn't support the read 15493f8e2d75SJohan Hedberg * local supported commands HCI command. 15503f8e2d75SJohan Hedberg */ 15513f8e2d75SJohan Hedberg if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) 155242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 15532177bab5SJohan Hedberg 15542177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 155557af75a8SMarcel Holtmann /* When SSP is available, then the host features page 155657af75a8SMarcel Holtmann * should also be available as well. However some 155757af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 155857af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 155957af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 156057af75a8SMarcel Holtmann */ 156157af75a8SMarcel Holtmann hdev->max_page = 0x01; 156257af75a8SMarcel Holtmann 15632177bab5SJohan Hedberg if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) { 15642177bab5SJohan Hedberg u8 mode = 0x01; 156542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 15662177bab5SJohan Hedberg sizeof(mode), &mode); 15672177bab5SJohan Hedberg } else { 15682177bab5SJohan Hedberg struct hci_cp_write_eir cp; 15692177bab5SJohan Hedberg 15702177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 15712177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 15722177bab5SJohan Hedberg 157342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 15742177bab5SJohan Hedberg } 15752177bab5SJohan Hedberg } 15762177bab5SJohan Hedberg 15772177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 157842c6b129SJohan Hedberg hci_setup_inquiry_mode(req); 15792177bab5SJohan Hedberg 15802177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 158142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 15822177bab5SJohan Hedberg 15832177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 15842177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 15852177bab5SJohan Hedberg 15862177bab5SJohan Hedberg cp.page = 0x01; 158742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 158842c6b129SJohan Hedberg sizeof(cp), &cp); 15892177bab5SJohan Hedberg } 15902177bab5SJohan Hedberg 15912177bab5SJohan Hedberg if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) { 15922177bab5SJohan Hedberg u8 enable = 1; 159342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 15942177bab5SJohan Hedberg &enable); 15952177bab5SJohan Hedberg } 15962177bab5SJohan Hedberg } 15972177bab5SJohan Hedberg 159842c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 15992177bab5SJohan Hedberg { 160042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 16012177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 16022177bab5SJohan Hedberg u16 link_policy = 0; 16032177bab5SJohan Hedberg 16042177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 16052177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 16062177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 16072177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 16082177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 16092177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 16102177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 16112177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 16122177bab5SJohan Hedberg 16132177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 161442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 16152177bab5SJohan Hedberg } 16162177bab5SJohan Hedberg 161742c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 16182177bab5SJohan Hedberg { 161942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 16202177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 16212177bab5SJohan Hedberg 1622c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 1623c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1624c73eee91SJohan Hedberg return; 1625c73eee91SJohan Hedberg 16262177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 16272177bab5SJohan Hedberg 16282177bab5SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) { 16292177bab5SJohan Hedberg cp.le = 0x01; 163032226e4fSMarcel Holtmann cp.simul = 0x00; 16312177bab5SJohan Hedberg } 16322177bab5SJohan Hedberg 16332177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 163442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 16352177bab5SJohan Hedberg &cp); 16362177bab5SJohan Hedberg } 16372177bab5SJohan Hedberg 1638d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 1639d62e6d67SJohan Hedberg { 1640d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 1641d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 1642d62e6d67SJohan Hedberg 1643d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 1644d62e6d67SJohan Hedberg * enable all necessary events for it. 1645d62e6d67SJohan Hedberg */ 164653b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 1647d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 1648d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 1649d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 1650d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 1651d62e6d67SJohan Hedberg } 1652d62e6d67SJohan Hedberg 1653d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 1654d62e6d67SJohan Hedberg * enable all necessary events for it. 1655d62e6d67SJohan Hedberg */ 165653b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 1657d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 1658d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 1659d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 1660d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 1661d62e6d67SJohan Hedberg } 1662d62e6d67SJohan Hedberg 166340c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 1664cd7ca0ecSMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) 166540c59fcbSMarcel Holtmann events[2] |= 0x80; 166640c59fcbSMarcel Holtmann 1667d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 1668d62e6d67SJohan Hedberg } 1669d62e6d67SJohan Hedberg 167042c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 16712177bab5SJohan Hedberg { 167242c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 1673d2c5d77fSJohan Hedberg u8 p; 167442c6b129SJohan Hedberg 16750da71f1bSMarcel Holtmann hci_setup_event_mask(req); 16760da71f1bSMarcel Holtmann 1677b8f4e068SGustavo Padovan /* Some Broadcom based Bluetooth controllers do not support the 1678b8f4e068SGustavo Padovan * Delete Stored Link Key command. They are clearly indicating its 1679b8f4e068SGustavo Padovan * absence in the bit mask of supported commands. 1680b8f4e068SGustavo Padovan * 1681b8f4e068SGustavo Padovan * Check the supported commands and only if the the command is marked 1682b8f4e068SGustavo Padovan * as supported send it. If not supported assume that the controller 1683b8f4e068SGustavo Padovan * does not have actual support for stored link keys which makes this 1684b8f4e068SGustavo Padovan * command redundant anyway. 1685f9f462faSMarcel Holtmann * 1686f9f462faSMarcel Holtmann * Some controllers indicate that they support handling deleting 1687f9f462faSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 1688f9f462faSMarcel Holtmann * just disable this command. 1689b8f4e068SGustavo Padovan */ 1690f9f462faSMarcel Holtmann if (hdev->commands[6] & 0x80 && 1691f9f462faSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 169259f45d57SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 169359f45d57SJohan Hedberg 169459f45d57SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 169559f45d57SJohan Hedberg cp.delete_all = 0x01; 169659f45d57SJohan Hedberg hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 169759f45d57SJohan Hedberg sizeof(cp), &cp); 169859f45d57SJohan Hedberg } 169959f45d57SJohan Hedberg 17002177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 170142c6b129SJohan Hedberg hci_setup_link_policy(req); 17022177bab5SJohan Hedberg 17039193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 17049193c6e8SAndre Guedes u8 events[8]; 17059193c6e8SAndre Guedes 17069193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 17074d6c705bSMarcel Holtmann events[0] = 0x0f; 17084d6c705bSMarcel Holtmann 17094d6c705bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) 17104d6c705bSMarcel Holtmann events[0] |= 0x10; /* LE Long Term Key Request */ 1711662bc2e6SAndre Guedes 1712662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 1713662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 1714662bc2e6SAndre Guedes */ 1715662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 1716662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 1717662bc2e6SAndre Guedes * Parameter Request 1718662bc2e6SAndre Guedes */ 1719662bc2e6SAndre Guedes 17209193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 17219193c6e8SAndre Guedes events); 17229193c6e8SAndre Guedes 172315a49ccaSMarcel Holtmann if (hdev->commands[25] & 0x40) { 172415a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 172515a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 172615a49ccaSMarcel Holtmann } 172715a49ccaSMarcel Holtmann 172842c6b129SJohan Hedberg hci_set_le_support(req); 17299193c6e8SAndre Guedes } 1730d2c5d77fSJohan Hedberg 1731d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 1732d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 1733d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 1734d2c5d77fSJohan Hedberg 1735d2c5d77fSJohan Hedberg cp.page = p; 1736d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 1737d2c5d77fSJohan Hedberg sizeof(cp), &cp); 1738d2c5d77fSJohan Hedberg } 17392177bab5SJohan Hedberg } 17402177bab5SJohan Hedberg 17415d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 17425d4e7e8dSJohan Hedberg { 17435d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 17445d4e7e8dSJohan Hedberg 1745d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 1746d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 1747d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 1748d62e6d67SJohan Hedberg 1749109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 1750109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 1751109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 1752109e3191SMarcel Holtmann 1753f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 1754f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 1755f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 1756f4fe73edSMarcel Holtmann 17575d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 175853b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 17595d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 1760a6d0d690SMarcel Holtmann 1761a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 17625afeac14SMarcel Holtmann if ((lmp_sc_capable(hdev) || 1763111902f7SMarcel Holtmann test_bit(HCI_FORCE_SC, &hdev->dbg_flags)) && 1764a6d0d690SMarcel Holtmann test_bit(HCI_SC_ENABLED, &hdev->dev_flags)) { 1765a6d0d690SMarcel Holtmann u8 support = 0x01; 1766a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 1767a6d0d690SMarcel Holtmann sizeof(support), &support); 1768a6d0d690SMarcel Holtmann } 17695d4e7e8dSJohan Hedberg } 17705d4e7e8dSJohan Hedberg 17712177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 17722177bab5SJohan Hedberg { 17732177bab5SJohan Hedberg int err; 17742177bab5SJohan Hedberg 17752177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 17762177bab5SJohan Hedberg if (err < 0) 17772177bab5SJohan Hedberg return err; 17782177bab5SJohan Hedberg 17794b4148e9SMarcel Holtmann /* The Device Under Test (DUT) mode is special and available for 17804b4148e9SMarcel Holtmann * all controller types. So just create it early on. 17814b4148e9SMarcel Holtmann */ 17824b4148e9SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 17834b4148e9SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 17844b4148e9SMarcel Holtmann &dut_mode_fops); 17854b4148e9SMarcel Holtmann } 17864b4148e9SMarcel Holtmann 17872177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 17882177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 17892177bab5SJohan Hedberg * first stage init. 17902177bab5SJohan Hedberg */ 17912177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 17922177bab5SJohan Hedberg return 0; 17932177bab5SJohan Hedberg 17942177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 17952177bab5SJohan Hedberg if (err < 0) 17962177bab5SJohan Hedberg return err; 17972177bab5SJohan Hedberg 17985d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 17995d4e7e8dSJohan Hedberg if (err < 0) 18005d4e7e8dSJohan Hedberg return err; 18015d4e7e8dSJohan Hedberg 1802baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 1803baf27f6eSMarcel Holtmann if (err < 0) 1804baf27f6eSMarcel Holtmann return err; 1805baf27f6eSMarcel Holtmann 1806baf27f6eSMarcel Holtmann /* Only create debugfs entries during the initial setup 1807baf27f6eSMarcel Holtmann * phase and not every time the controller gets powered on. 1808baf27f6eSMarcel Holtmann */ 1809baf27f6eSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 1810baf27f6eSMarcel Holtmann return 0; 1811baf27f6eSMarcel Holtmann 1812dfb826a8SMarcel Holtmann debugfs_create_file("features", 0444, hdev->debugfs, hdev, 1813dfb826a8SMarcel Holtmann &features_fops); 1814ceeb3bc0SMarcel Holtmann debugfs_create_u16("manufacturer", 0444, hdev->debugfs, 1815ceeb3bc0SMarcel Holtmann &hdev->manufacturer); 1816ceeb3bc0SMarcel Holtmann debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver); 1817ceeb3bc0SMarcel Holtmann debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev); 181870afe0b8SMarcel Holtmann debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev, 181970afe0b8SMarcel Holtmann &blacklist_fops); 18206659358eSJohan Hedberg debugfs_create_file("whitelist", 0444, hdev->debugfs, hdev, 18216659358eSJohan Hedberg &whitelist_fops); 182247219839SMarcel Holtmann debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 182347219839SMarcel Holtmann 182431ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev, 182531ad1691SAndrzej Kaczmarek &conn_info_min_age_fops); 182631ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev, 182731ad1691SAndrzej Kaczmarek &conn_info_max_age_fops); 182831ad1691SAndrzej Kaczmarek 1829baf27f6eSMarcel Holtmann if (lmp_bredr_capable(hdev)) { 1830baf27f6eSMarcel Holtmann debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, 1831baf27f6eSMarcel Holtmann hdev, &inquiry_cache_fops); 183202d08d15SMarcel Holtmann debugfs_create_file("link_keys", 0400, hdev->debugfs, 183302d08d15SMarcel Holtmann hdev, &link_keys_fops); 1834babdbb3cSMarcel Holtmann debugfs_create_file("dev_class", 0444, hdev->debugfs, 1835babdbb3cSMarcel Holtmann hdev, &dev_class_fops); 1836041000b9SMarcel Holtmann debugfs_create_file("voice_setting", 0444, hdev->debugfs, 1837041000b9SMarcel Holtmann hdev, &voice_setting_fops); 1838baf27f6eSMarcel Holtmann } 1839baf27f6eSMarcel Holtmann 184006f5b778SMarcel Holtmann if (lmp_ssp_capable(hdev)) { 1841ebd1e33bSMarcel Holtmann debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 1842ebd1e33bSMarcel Holtmann hdev, &auto_accept_delay_fops); 18435afeac14SMarcel Holtmann debugfs_create_file("force_sc_support", 0644, hdev->debugfs, 18445afeac14SMarcel Holtmann hdev, &force_sc_support_fops); 1845134c2a89SMarcel Holtmann debugfs_create_file("sc_only_mode", 0444, hdev->debugfs, 1846134c2a89SMarcel Holtmann hdev, &sc_only_mode_fops); 184706f5b778SMarcel Holtmann } 1848ebd1e33bSMarcel Holtmann 18492bfa3531SMarcel Holtmann if (lmp_sniff_capable(hdev)) { 18502bfa3531SMarcel Holtmann debugfs_create_file("idle_timeout", 0644, hdev->debugfs, 18512bfa3531SMarcel Holtmann hdev, &idle_timeout_fops); 18522bfa3531SMarcel Holtmann debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs, 18532bfa3531SMarcel Holtmann hdev, &sniff_min_interval_fops); 18542bfa3531SMarcel Holtmann debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs, 18552bfa3531SMarcel Holtmann hdev, &sniff_max_interval_fops); 18562bfa3531SMarcel Holtmann } 18572bfa3531SMarcel Holtmann 1858d0f729b8SMarcel Holtmann if (lmp_le_capable(hdev)) { 1859ac345813SMarcel Holtmann debugfs_create_file("identity", 0400, hdev->debugfs, 1860ac345813SMarcel Holtmann hdev, &identity_fops); 1861ac345813SMarcel Holtmann debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, 1862ac345813SMarcel Holtmann hdev, &rpa_timeout_fops); 18637a4cd51dSMarcel Holtmann debugfs_create_file("random_address", 0444, hdev->debugfs, 18647a4cd51dSMarcel Holtmann hdev, &random_address_fops); 1865e7b8fc92SMarcel Holtmann debugfs_create_file("static_address", 0444, hdev->debugfs, 1866e7b8fc92SMarcel Holtmann hdev, &static_address_fops); 1867b32bba6cSMarcel Holtmann 1868b32bba6cSMarcel Holtmann /* For controllers with a public address, provide a debug 1869b32bba6cSMarcel Holtmann * option to force the usage of the configured static 1870b32bba6cSMarcel Holtmann * address. By default the public address is used. 1871b32bba6cSMarcel Holtmann */ 1872b32bba6cSMarcel Holtmann if (bacmp(&hdev->bdaddr, BDADDR_ANY)) 1873b32bba6cSMarcel Holtmann debugfs_create_file("force_static_address", 0644, 1874b32bba6cSMarcel Holtmann hdev->debugfs, hdev, 1875b32bba6cSMarcel Holtmann &force_static_address_fops); 1876b32bba6cSMarcel Holtmann 1877b32bba6cSMarcel Holtmann debugfs_create_u8("white_list_size", 0444, hdev->debugfs, 1878b32bba6cSMarcel Holtmann &hdev->le_white_list_size); 1879d2ab0ac1SMarcel Holtmann debugfs_create_file("white_list", 0444, hdev->debugfs, hdev, 1880d2ab0ac1SMarcel Holtmann &white_list_fops); 18813698d704SMarcel Holtmann debugfs_create_file("identity_resolving_keys", 0400, 18823698d704SMarcel Holtmann hdev->debugfs, hdev, 18833698d704SMarcel Holtmann &identity_resolving_keys_fops); 18848f8625cdSMarcel Holtmann debugfs_create_file("long_term_keys", 0400, hdev->debugfs, 18858f8625cdSMarcel Holtmann hdev, &long_term_keys_fops); 18864e70c7e7SMarcel Holtmann debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, 18874e70c7e7SMarcel Holtmann hdev, &conn_min_interval_fops); 18884e70c7e7SMarcel Holtmann debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, 18894e70c7e7SMarcel Holtmann hdev, &conn_max_interval_fops); 1890816a93d1SMarcel Holtmann debugfs_create_file("conn_latency", 0644, hdev->debugfs, 1891816a93d1SMarcel Holtmann hdev, &conn_latency_fops); 1892f1649577SMarcel Holtmann debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, 1893f1649577SMarcel Holtmann hdev, &supervision_timeout_fops); 18943f959d46SMarcel Holtmann debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, 18953f959d46SMarcel Holtmann hdev, &adv_channel_map_fops); 1896729a1051SGeorg Lukas debugfs_create_file("adv_min_interval", 0644, hdev->debugfs, 1897729a1051SGeorg Lukas hdev, &adv_min_interval_fops); 1898729a1051SGeorg Lukas debugfs_create_file("adv_max_interval", 0644, hdev->debugfs, 1899729a1051SGeorg Lukas hdev, &adv_max_interval_fops); 19000b3c7d37SMarcel Holtmann debugfs_create_file("device_list", 0444, hdev->debugfs, hdev, 19010b3c7d37SMarcel Holtmann &device_list_fops); 1902b9a7a61eSLukasz Rymanowski debugfs_create_u16("discov_interleaved_timeout", 0644, 1903b9a7a61eSLukasz Rymanowski hdev->debugfs, 1904b9a7a61eSLukasz Rymanowski &hdev->discov_interleaved_timeout); 190554506918SJohan Hedberg 1906711eafe3SJohan Hedberg smp_register(hdev); 1907d0f729b8SMarcel Holtmann } 1908e7b8fc92SMarcel Holtmann 1909baf27f6eSMarcel Holtmann return 0; 19102177bab5SJohan Hedberg } 19112177bab5SJohan Hedberg 19120ebca7d6SMarcel Holtmann static void hci_init0_req(struct hci_request *req, unsigned long opt) 19130ebca7d6SMarcel Holtmann { 19140ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 19150ebca7d6SMarcel Holtmann 19160ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 19170ebca7d6SMarcel Holtmann 19180ebca7d6SMarcel Holtmann /* Reset */ 19190ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 19200ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 19210ebca7d6SMarcel Holtmann 19220ebca7d6SMarcel Holtmann /* Read Local Version */ 19230ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 19240ebca7d6SMarcel Holtmann 19250ebca7d6SMarcel Holtmann /* Read BD Address */ 19260ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 19270ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 19280ebca7d6SMarcel Holtmann } 19290ebca7d6SMarcel Holtmann 19300ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 19310ebca7d6SMarcel Holtmann { 19320ebca7d6SMarcel Holtmann int err; 19330ebca7d6SMarcel Holtmann 1934cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 1935cc78b44bSMarcel Holtmann return 0; 1936cc78b44bSMarcel Holtmann 19370ebca7d6SMarcel Holtmann err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT); 19380ebca7d6SMarcel Holtmann if (err < 0) 19390ebca7d6SMarcel Holtmann return err; 19400ebca7d6SMarcel Holtmann 19410ebca7d6SMarcel Holtmann return 0; 19420ebca7d6SMarcel Holtmann } 19430ebca7d6SMarcel Holtmann 194442c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 19451da177e4SLinus Torvalds { 19461da177e4SLinus Torvalds __u8 scan = opt; 19471da177e4SLinus Torvalds 194842c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 19491da177e4SLinus Torvalds 19501da177e4SLinus Torvalds /* Inquiry and Page scans */ 195142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 19521da177e4SLinus Torvalds } 19531da177e4SLinus Torvalds 195442c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 19551da177e4SLinus Torvalds { 19561da177e4SLinus Torvalds __u8 auth = opt; 19571da177e4SLinus Torvalds 195842c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 19591da177e4SLinus Torvalds 19601da177e4SLinus Torvalds /* Authentication */ 196142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 19621da177e4SLinus Torvalds } 19631da177e4SLinus Torvalds 196442c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 19651da177e4SLinus Torvalds { 19661da177e4SLinus Torvalds __u8 encrypt = opt; 19671da177e4SLinus Torvalds 196842c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 19691da177e4SLinus Torvalds 1970e4e8e37cSMarcel Holtmann /* Encryption */ 197142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 19721da177e4SLinus Torvalds } 19731da177e4SLinus Torvalds 197442c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1975e4e8e37cSMarcel Holtmann { 1976e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1977e4e8e37cSMarcel Holtmann 197842c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1979e4e8e37cSMarcel Holtmann 1980e4e8e37cSMarcel Holtmann /* Default link policy */ 198142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1982e4e8e37cSMarcel Holtmann } 1983e4e8e37cSMarcel Holtmann 19841da177e4SLinus Torvalds /* Get HCI device by index. 19851da177e4SLinus Torvalds * Device is held on return. */ 19861da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 19871da177e4SLinus Torvalds { 19888035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 19891da177e4SLinus Torvalds 19901da177e4SLinus Torvalds BT_DBG("%d", index); 19911da177e4SLinus Torvalds 19921da177e4SLinus Torvalds if (index < 0) 19931da177e4SLinus Torvalds return NULL; 19941da177e4SLinus Torvalds 19951da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 19968035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 19971da177e4SLinus Torvalds if (d->id == index) { 19981da177e4SLinus Torvalds hdev = hci_dev_hold(d); 19991da177e4SLinus Torvalds break; 20001da177e4SLinus Torvalds } 20011da177e4SLinus Torvalds } 20021da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 20031da177e4SLinus Torvalds return hdev; 20041da177e4SLinus Torvalds } 20051da177e4SLinus Torvalds 20061da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 2007ff9ef578SJohan Hedberg 200830dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 200930dc78e1SJohan Hedberg { 201030dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 201130dc78e1SJohan Hedberg 20126fbe195dSAndre Guedes switch (discov->state) { 2013343f935bSAndre Guedes case DISCOVERY_FINDING: 20146fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 201530dc78e1SJohan Hedberg return true; 201630dc78e1SJohan Hedberg 20176fbe195dSAndre Guedes default: 201830dc78e1SJohan Hedberg return false; 201930dc78e1SJohan Hedberg } 20206fbe195dSAndre Guedes } 202130dc78e1SJohan Hedberg 2022ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 2023ff9ef578SJohan Hedberg { 2024bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 2025bb3e0a33SJohan Hedberg 2026ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 2027ff9ef578SJohan Hedberg 2028bb3e0a33SJohan Hedberg if (old_state == state) 2029ff9ef578SJohan Hedberg return; 2030ff9ef578SJohan Hedberg 2031bb3e0a33SJohan Hedberg hdev->discovery.state = state; 2032bb3e0a33SJohan Hedberg 2033ff9ef578SJohan Hedberg switch (state) { 2034ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 2035c54c3860SAndre Guedes hci_update_background_scan(hdev); 2036c54c3860SAndre Guedes 2037bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 2038ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 2039ff9ef578SJohan Hedberg break; 2040ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 2041ff9ef578SJohan Hedberg break; 2042343f935bSAndre Guedes case DISCOVERY_FINDING: 2043ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 2044ff9ef578SJohan Hedberg break; 204530dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 204630dc78e1SJohan Hedberg break; 2047ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 2048ff9ef578SJohan Hedberg break; 2049ff9ef578SJohan Hedberg } 2050ff9ef578SJohan Hedberg } 2051ff9ef578SJohan Hedberg 20521f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 20531da177e4SLinus Torvalds { 205430883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2055b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 20561da177e4SLinus Torvalds 2057561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 2058561aafbcSJohan Hedberg list_del(&p->all); 2059b57c1a56SJohan Hedberg kfree(p); 20601da177e4SLinus Torvalds } 2061561aafbcSJohan Hedberg 2062561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 2063561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 20641da177e4SLinus Torvalds } 20651da177e4SLinus Torvalds 2066a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 2067a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 20681da177e4SLinus Torvalds { 206930883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 20701da177e4SLinus Torvalds struct inquiry_entry *e; 20711da177e4SLinus Torvalds 20726ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 20731da177e4SLinus Torvalds 2074561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 20751da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 20761da177e4SLinus Torvalds return e; 20771da177e4SLinus Torvalds } 20781da177e4SLinus Torvalds 2079b57c1a56SJohan Hedberg return NULL; 2080b57c1a56SJohan Hedberg } 2081b57c1a56SJohan Hedberg 2082561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 2083561aafbcSJohan Hedberg bdaddr_t *bdaddr) 2084561aafbcSJohan Hedberg { 208530883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2086561aafbcSJohan Hedberg struct inquiry_entry *e; 2087561aafbcSJohan Hedberg 20886ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 2089561aafbcSJohan Hedberg 2090561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 2091561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 2092561aafbcSJohan Hedberg return e; 2093561aafbcSJohan Hedberg } 2094561aafbcSJohan Hedberg 2095561aafbcSJohan Hedberg return NULL; 2096561aafbcSJohan Hedberg } 2097561aafbcSJohan Hedberg 209830dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 209930dc78e1SJohan Hedberg bdaddr_t *bdaddr, 210030dc78e1SJohan Hedberg int state) 210130dc78e1SJohan Hedberg { 210230dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 210330dc78e1SJohan Hedberg struct inquiry_entry *e; 210430dc78e1SJohan Hedberg 21056ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 210630dc78e1SJohan Hedberg 210730dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 210830dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 210930dc78e1SJohan Hedberg return e; 211030dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 211130dc78e1SJohan Hedberg return e; 211230dc78e1SJohan Hedberg } 211330dc78e1SJohan Hedberg 211430dc78e1SJohan Hedberg return NULL; 211530dc78e1SJohan Hedberg } 211630dc78e1SJohan Hedberg 2117a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 2118a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 2119a3d4e20aSJohan Hedberg { 2120a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2121a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 2122a3d4e20aSJohan Hedberg struct inquiry_entry *p; 2123a3d4e20aSJohan Hedberg 2124a3d4e20aSJohan Hedberg list_del(&ie->list); 2125a3d4e20aSJohan Hedberg 2126a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 2127a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 2128a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 2129a3d4e20aSJohan Hedberg break; 2130a3d4e20aSJohan Hedberg pos = &p->list; 2131a3d4e20aSJohan Hedberg } 2132a3d4e20aSJohan Hedberg 2133a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 2134a3d4e20aSJohan Hedberg } 2135a3d4e20aSJohan Hedberg 2136af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 2137af58925cSMarcel Holtmann bool name_known) 21381da177e4SLinus Torvalds { 213930883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 214070f23020SAndrei Emeltchenko struct inquiry_entry *ie; 2141af58925cSMarcel Holtmann u32 flags = 0; 21421da177e4SLinus Torvalds 21436ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 21441da177e4SLinus Torvalds 21452b2fec4dSSzymon Janc hci_remove_remote_oob_data(hdev, &data->bdaddr); 21462b2fec4dSSzymon Janc 2147af58925cSMarcel Holtmann if (!data->ssp_mode) 2148af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 2149388fc8faSJohan Hedberg 215070f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 2151a3d4e20aSJohan Hedberg if (ie) { 2152af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 2153af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 2154388fc8faSJohan Hedberg 2155a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 2156a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 2157a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 2158a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 2159a3d4e20aSJohan Hedberg } 2160a3d4e20aSJohan Hedberg 2161561aafbcSJohan Hedberg goto update; 2162a3d4e20aSJohan Hedberg } 2163561aafbcSJohan Hedberg 21641da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 216527f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 2166af58925cSMarcel Holtmann if (!ie) { 2167af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 2168af58925cSMarcel Holtmann goto done; 2169af58925cSMarcel Holtmann } 217070f23020SAndrei Emeltchenko 2171561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 2172561aafbcSJohan Hedberg 2173561aafbcSJohan Hedberg if (name_known) { 2174561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2175561aafbcSJohan Hedberg } else { 2176561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 2177561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 2178561aafbcSJohan Hedberg } 2179561aafbcSJohan Hedberg 2180561aafbcSJohan Hedberg update: 2181561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 2182561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 2183561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2184561aafbcSJohan Hedberg list_del(&ie->list); 21851da177e4SLinus Torvalds } 21861da177e4SLinus Torvalds 218770f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 218870f23020SAndrei Emeltchenko ie->timestamp = jiffies; 21891da177e4SLinus Torvalds cache->timestamp = jiffies; 21903175405bSJohan Hedberg 21913175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 2192af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 21933175405bSJohan Hedberg 2194af58925cSMarcel Holtmann done: 2195af58925cSMarcel Holtmann return flags; 21961da177e4SLinus Torvalds } 21971da177e4SLinus Torvalds 21981da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 21991da177e4SLinus Torvalds { 220030883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 22011da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 22021da177e4SLinus Torvalds struct inquiry_entry *e; 22031da177e4SLinus Torvalds int copied = 0; 22041da177e4SLinus Torvalds 2205561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 22061da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 2207b57c1a56SJohan Hedberg 2208b57c1a56SJohan Hedberg if (copied >= num) 2209b57c1a56SJohan Hedberg break; 2210b57c1a56SJohan Hedberg 22111da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 22121da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 22131da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 22141da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 22151da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 22161da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 2217b57c1a56SJohan Hedberg 22181da177e4SLinus Torvalds info++; 2219b57c1a56SJohan Hedberg copied++; 22201da177e4SLinus Torvalds } 22211da177e4SLinus Torvalds 22221da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 22231da177e4SLinus Torvalds return copied; 22241da177e4SLinus Torvalds } 22251da177e4SLinus Torvalds 222642c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 22271da177e4SLinus Torvalds { 22281da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 222942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 22301da177e4SLinus Torvalds struct hci_cp_inquiry cp; 22311da177e4SLinus Torvalds 22321da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 22331da177e4SLinus Torvalds 22341da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 22351da177e4SLinus Torvalds return; 22361da177e4SLinus Torvalds 22371da177e4SLinus Torvalds /* Start Inquiry */ 22381da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 22391da177e4SLinus Torvalds cp.length = ir->length; 22401da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 224142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 22421da177e4SLinus Torvalds } 22431da177e4SLinus Torvalds 22441da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 22451da177e4SLinus Torvalds { 22461da177e4SLinus Torvalds __u8 __user *ptr = arg; 22471da177e4SLinus Torvalds struct hci_inquiry_req ir; 22481da177e4SLinus Torvalds struct hci_dev *hdev; 22491da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 22501da177e4SLinus Torvalds long timeo; 22511da177e4SLinus Torvalds __u8 *buf; 22521da177e4SLinus Torvalds 22531da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 22541da177e4SLinus Torvalds return -EFAULT; 22551da177e4SLinus Torvalds 22565a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 22575a08ecceSAndrei Emeltchenko if (!hdev) 22581da177e4SLinus Torvalds return -ENODEV; 22591da177e4SLinus Torvalds 22600736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 22610736cfa8SMarcel Holtmann err = -EBUSY; 22620736cfa8SMarcel Holtmann goto done; 22630736cfa8SMarcel Holtmann } 22640736cfa8SMarcel Holtmann 22654a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2266fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2267fee746b0SMarcel Holtmann goto done; 2268fee746b0SMarcel Holtmann } 2269fee746b0SMarcel Holtmann 22705b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 22715b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 22725b69bef5SMarcel Holtmann goto done; 22735b69bef5SMarcel Holtmann } 22745b69bef5SMarcel Holtmann 227556f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 227656f87901SJohan Hedberg err = -EOPNOTSUPP; 227756f87901SJohan Hedberg goto done; 227856f87901SJohan Hedberg } 227956f87901SJohan Hedberg 228009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 22811da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 2282a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 22831f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 22841da177e4SLinus Torvalds do_inquiry = 1; 22851da177e4SLinus Torvalds } 228609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 22871da177e4SLinus Torvalds 228804837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 228970f23020SAndrei Emeltchenko 229070f23020SAndrei Emeltchenko if (do_inquiry) { 229101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 229201178cd4SJohan Hedberg timeo); 229370f23020SAndrei Emeltchenko if (err < 0) 22941da177e4SLinus Torvalds goto done; 22953e13fa1eSAndre Guedes 22963e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 22973e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 22983e13fa1eSAndre Guedes */ 229974316201SNeilBrown if (wait_on_bit(&hdev->flags, HCI_INQUIRY, 23003e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 23013e13fa1eSAndre Guedes return -EINTR; 230270f23020SAndrei Emeltchenko } 23031da177e4SLinus Torvalds 23048fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 23058fc9ced3SGustavo Padovan * 255 entries 23068fc9ced3SGustavo Padovan */ 23071da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 23081da177e4SLinus Torvalds 23091da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 23101da177e4SLinus Torvalds * copy it to the user space. 23111da177e4SLinus Torvalds */ 231270f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 231370f23020SAndrei Emeltchenko if (!buf) { 23141da177e4SLinus Torvalds err = -ENOMEM; 23151da177e4SLinus Torvalds goto done; 23161da177e4SLinus Torvalds } 23171da177e4SLinus Torvalds 231809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 23191da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 232009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 23211da177e4SLinus Torvalds 23221da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 23231da177e4SLinus Torvalds 23241da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 23251da177e4SLinus Torvalds ptr += sizeof(ir); 23261da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 23271da177e4SLinus Torvalds ir.num_rsp)) 23281da177e4SLinus Torvalds err = -EFAULT; 23291da177e4SLinus Torvalds } else 23301da177e4SLinus Torvalds err = -EFAULT; 23311da177e4SLinus Torvalds 23321da177e4SLinus Torvalds kfree(buf); 23331da177e4SLinus Torvalds 23341da177e4SLinus Torvalds done: 23351da177e4SLinus Torvalds hci_dev_put(hdev); 23361da177e4SLinus Torvalds return err; 23371da177e4SLinus Torvalds } 23381da177e4SLinus Torvalds 2339cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 23401da177e4SLinus Torvalds { 23411da177e4SLinus Torvalds int ret = 0; 23421da177e4SLinus Torvalds 23431da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 23441da177e4SLinus Torvalds 23451da177e4SLinus Torvalds hci_req_lock(hdev); 23461da177e4SLinus Torvalds 234794324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 234894324962SJohan Hovold ret = -ENODEV; 234994324962SJohan Hovold goto done; 235094324962SJohan Hovold } 235194324962SJohan Hovold 2352d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2353d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 2354a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 2355a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 2356bf543036SJohan Hedberg */ 2357a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 2358611b30f7SMarcel Holtmann ret = -ERFKILL; 2359611b30f7SMarcel Holtmann goto done; 2360611b30f7SMarcel Holtmann } 2361611b30f7SMarcel Holtmann 2362a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 2363a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 2364a5c8f270SMarcel Holtmann * be able to determine if there is a public address 2365a5c8f270SMarcel Holtmann * or not. 2366a5c8f270SMarcel Holtmann * 2367c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 2368c6beca0eSMarcel Holtmann * if a public address or static random address is 2369c6beca0eSMarcel Holtmann * available. 2370c6beca0eSMarcel Holtmann * 2371a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 2372a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 2373a5c8f270SMarcel Holtmann */ 2374c6beca0eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 2375c6beca0eSMarcel Holtmann hdev->dev_type == HCI_BREDR && 2376a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2377a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 2378a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 2379a5c8f270SMarcel Holtmann goto done; 2380a5c8f270SMarcel Holtmann } 2381a5c8f270SMarcel Holtmann } 2382a5c8f270SMarcel Holtmann 23831da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 23841da177e4SLinus Torvalds ret = -EALREADY; 23851da177e4SLinus Torvalds goto done; 23861da177e4SLinus Torvalds } 23871da177e4SLinus Torvalds 23881da177e4SLinus Torvalds if (hdev->open(hdev)) { 23891da177e4SLinus Torvalds ret = -EIO; 23901da177e4SLinus Torvalds goto done; 23911da177e4SLinus Torvalds } 23921da177e4SLinus Torvalds 23931da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 23941da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 2395f41c70c4SMarcel Holtmann 2396af202f84SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 2397af202f84SMarcel Holtmann if (hdev->setup) 2398f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 2399f41c70c4SMarcel Holtmann 2400af202f84SMarcel Holtmann /* The transport driver can set these quirks before 2401af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 2402af202f84SMarcel Holtmann * 2403af202f84SMarcel Holtmann * In case any of them is set, the controller has to 2404af202f84SMarcel Holtmann * start up as unconfigured. 2405af202f84SMarcel Holtmann */ 2406eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 2407eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 240889bc22d2SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 2409f41c70c4SMarcel Holtmann 24100ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 24110ebca7d6SMarcel Holtmann * read at least the version information provided by 24120ebca7d6SMarcel Holtmann * the Read Local Version Information command. 24130ebca7d6SMarcel Holtmann * 24140ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 24150ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 24160ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 24170ebca7d6SMarcel Holtmann */ 24180ebca7d6SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 24190ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 242089bc22d2SMarcel Holtmann } 242189bc22d2SMarcel Holtmann 24229713c17bSMarcel Holtmann if (test_bit(HCI_CONFIG, &hdev->dev_flags)) { 24239713c17bSMarcel Holtmann /* If public address change is configured, ensure that 24249713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 24259713c17bSMarcel Holtmann * support changing the public address, fail the power 24269713c17bSMarcel Holtmann * on procedure. 242724c457e2SMarcel Holtmann */ 24289713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 24299713c17bSMarcel Holtmann hdev->set_bdaddr) 243024c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 243124c457e2SMarcel Holtmann else 243224c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 243324c457e2SMarcel Holtmann } 243424c457e2SMarcel Holtmann 2435f41c70c4SMarcel Holtmann if (!ret) { 24364a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 24370736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 24382177bab5SJohan Hedberg ret = __hci_init(hdev); 24391da177e4SLinus Torvalds } 24401da177e4SLinus Torvalds 2441f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 2442f41c70c4SMarcel Holtmann 24431da177e4SLinus Torvalds if (!ret) { 24441da177e4SLinus Torvalds hci_dev_hold(hdev); 2445d6bfd59cSJohan Hedberg set_bit(HCI_RPA_EXPIRED, &hdev->dev_flags); 24461da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 24471da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 2448bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2449d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags) && 24504a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 24510736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 24521514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 245309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2454744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 245509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 245656e5cb86SJohan Hedberg } 24571da177e4SLinus Torvalds } else { 24581da177e4SLinus Torvalds /* Init failed, cleanup */ 24593eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2460c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 2461b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 24621da177e4SLinus Torvalds 24631da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 24641da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 24651da177e4SLinus Torvalds 24661da177e4SLinus Torvalds if (hdev->flush) 24671da177e4SLinus Torvalds hdev->flush(hdev); 24681da177e4SLinus Torvalds 24691da177e4SLinus Torvalds if (hdev->sent_cmd) { 24701da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 24711da177e4SLinus Torvalds hdev->sent_cmd = NULL; 24721da177e4SLinus Torvalds } 24731da177e4SLinus Torvalds 24741da177e4SLinus Torvalds hdev->close(hdev); 2475fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 24761da177e4SLinus Torvalds } 24771da177e4SLinus Torvalds 24781da177e4SLinus Torvalds done: 24791da177e4SLinus Torvalds hci_req_unlock(hdev); 24801da177e4SLinus Torvalds return ret; 24811da177e4SLinus Torvalds } 24821da177e4SLinus Torvalds 2483cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 2484cbed0ca1SJohan Hedberg 2485cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 2486cbed0ca1SJohan Hedberg { 2487cbed0ca1SJohan Hedberg struct hci_dev *hdev; 2488cbed0ca1SJohan Hedberg int err; 2489cbed0ca1SJohan Hedberg 2490cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 2491cbed0ca1SJohan Hedberg if (!hdev) 2492cbed0ca1SJohan Hedberg return -ENODEV; 2493cbed0ca1SJohan Hedberg 24944a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 2495fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 2496fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 2497fee746b0SMarcel Holtmann * possible. 2498fee746b0SMarcel Holtmann * 2499fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 2500fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 2501fee746b0SMarcel Holtmann * open the device. 2502fee746b0SMarcel Holtmann */ 25034a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 2504fee746b0SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 2505fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2506fee746b0SMarcel Holtmann goto done; 2507fee746b0SMarcel Holtmann } 2508fee746b0SMarcel Holtmann 2509e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 2510e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 2511e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 2512e1d08f40SJohan Hedberg * completed. 2513e1d08f40SJohan Hedberg */ 2514e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 2515e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 2516e1d08f40SJohan Hedberg 2517a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 2518a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 2519a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 2520a5c8f270SMarcel Holtmann */ 2521e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 2522e1d08f40SJohan Hedberg 252312aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 2524b6ae8457SJohan Hedberg * are brought up using legacy ioctl, set the HCI_BONDABLE bit 252512aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 252612aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 252712aa4f0aSMarcel Holtmann * to explicitly enable it. 252812aa4f0aSMarcel Holtmann */ 252912aa4f0aSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 253012aa4f0aSMarcel Holtmann !test_bit(HCI_MGMT, &hdev->dev_flags)) 2531b6ae8457SJohan Hedberg set_bit(HCI_BONDABLE, &hdev->dev_flags); 253212aa4f0aSMarcel Holtmann 2533cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 2534cbed0ca1SJohan Hedberg 2535fee746b0SMarcel Holtmann done: 2536cbed0ca1SJohan Hedberg hci_dev_put(hdev); 2537cbed0ca1SJohan Hedberg return err; 2538cbed0ca1SJohan Hedberg } 2539cbed0ca1SJohan Hedberg 2540d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 2541d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 2542d7347f3cSJohan Hedberg { 2543d7347f3cSJohan Hedberg struct hci_conn_params *p; 2544d7347f3cSJohan Hedberg 2545f161dd41SJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) { 2546f161dd41SJohan Hedberg if (p->conn) { 2547f161dd41SJohan Hedberg hci_conn_drop(p->conn); 2548f8aaf9b6SJohan Hedberg hci_conn_put(p->conn); 2549f161dd41SJohan Hedberg p->conn = NULL; 2550f161dd41SJohan Hedberg } 2551d7347f3cSJohan Hedberg list_del_init(&p->action); 2552f161dd41SJohan Hedberg } 2553d7347f3cSJohan Hedberg 2554d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 2555d7347f3cSJohan Hedberg } 2556d7347f3cSJohan Hedberg 25571da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 25581da177e4SLinus Torvalds { 25591da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 25601da177e4SLinus Torvalds 256178c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 256278c04c0bSVinicius Costa Gomes 25631da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 25641da177e4SLinus Torvalds hci_req_lock(hdev); 25651da177e4SLinus Torvalds 25661da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 256765cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 25681da177e4SLinus Torvalds hci_req_unlock(hdev); 25691da177e4SLinus Torvalds return 0; 25701da177e4SLinus Torvalds } 25711da177e4SLinus Torvalds 25723eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 25733eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2574b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 25751da177e4SLinus Torvalds 257616ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 2577e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 257816ab91abSJohan Hedberg hdev->discov_timeout = 0; 25795e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 2580310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 258116ab91abSJohan Hedberg } 258216ab91abSJohan Hedberg 2583a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 25847d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 25857d78525dSJohan Hedberg 25867ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 25874518bb0fSJohan Hedberg 25884518bb0fSJohan Hedberg if (test_bit(HCI_MGMT, &hdev->dev_flags)) 2589d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 25907ba8b4beSAndre Guedes 259109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 25921f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 2593d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 2594f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 259509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 25961da177e4SLinus Torvalds 25971da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 25981da177e4SLinus Torvalds 25991da177e4SLinus Torvalds if (hdev->flush) 26001da177e4SLinus Torvalds hdev->flush(hdev); 26011da177e4SLinus Torvalds 26021da177e4SLinus Torvalds /* Reset device */ 26031da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 26041da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 26054a964404SMarcel Holtmann if (!test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 26064a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 2607a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 26081da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 260901178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 26101da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 26111da177e4SLinus Torvalds } 26121da177e4SLinus Torvalds 2613c347b765SGustavo F. Padovan /* flush cmd work */ 2614c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 26151da177e4SLinus Torvalds 26161da177e4SLinus Torvalds /* Drop queues */ 26171da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 26181da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 26191da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 26201da177e4SLinus Torvalds 26211da177e4SLinus Torvalds /* Drop last sent command */ 26221da177e4SLinus Torvalds if (hdev->sent_cmd) { 262365cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 26241da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 26251da177e4SLinus Torvalds hdev->sent_cmd = NULL; 26261da177e4SLinus Torvalds } 26271da177e4SLinus Torvalds 2628b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 2629b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 2630b6ddb638SJohan Hedberg 26311da177e4SLinus Torvalds /* After this point our queues are empty 26321da177e4SLinus Torvalds * and no tasks are scheduled. */ 26331da177e4SLinus Torvalds hdev->close(hdev); 26341da177e4SLinus Torvalds 263535b973c9SJohan Hedberg /* Clear flags */ 2636fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 263735b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 263835b973c9SJohan Hedberg 263993c311a0SMarcel Holtmann if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 264093c311a0SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 264109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2642744cf19eSJohan Hedberg mgmt_powered(hdev, 0); 264309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 26448ee56540SMarcel Holtmann } 264593c311a0SMarcel Holtmann } 26465add6af8SJohan Hedberg 2647ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 2648536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 2649ced5c338SAndrei Emeltchenko 2650e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 265109b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 26527a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 2653e59fda8dSJohan Hedberg 26541da177e4SLinus Torvalds hci_req_unlock(hdev); 26551da177e4SLinus Torvalds 26561da177e4SLinus Torvalds hci_dev_put(hdev); 26571da177e4SLinus Torvalds return 0; 26581da177e4SLinus Torvalds } 26591da177e4SLinus Torvalds 26601da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 26611da177e4SLinus Torvalds { 26621da177e4SLinus Torvalds struct hci_dev *hdev; 26631da177e4SLinus Torvalds int err; 26641da177e4SLinus Torvalds 266570f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 266670f23020SAndrei Emeltchenko if (!hdev) 26671da177e4SLinus Torvalds return -ENODEV; 26688ee56540SMarcel Holtmann 26690736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 26700736cfa8SMarcel Holtmann err = -EBUSY; 26710736cfa8SMarcel Holtmann goto done; 26720736cfa8SMarcel Holtmann } 26730736cfa8SMarcel Holtmann 26748ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 26758ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 26768ee56540SMarcel Holtmann 26771da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 26788ee56540SMarcel Holtmann 26790736cfa8SMarcel Holtmann done: 26801da177e4SLinus Torvalds hci_dev_put(hdev); 26811da177e4SLinus Torvalds return err; 26821da177e4SLinus Torvalds } 26831da177e4SLinus Torvalds 26841da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 26851da177e4SLinus Torvalds { 26861da177e4SLinus Torvalds struct hci_dev *hdev; 26871da177e4SLinus Torvalds int ret = 0; 26881da177e4SLinus Torvalds 268970f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 269070f23020SAndrei Emeltchenko if (!hdev) 26911da177e4SLinus Torvalds return -ENODEV; 26921da177e4SLinus Torvalds 26931da177e4SLinus Torvalds hci_req_lock(hdev); 26941da177e4SLinus Torvalds 2695808a049eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 2696808a049eSMarcel Holtmann ret = -ENETDOWN; 26971da177e4SLinus Torvalds goto done; 2698808a049eSMarcel Holtmann } 26991da177e4SLinus Torvalds 27000736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 27010736cfa8SMarcel Holtmann ret = -EBUSY; 27020736cfa8SMarcel Holtmann goto done; 27030736cfa8SMarcel Holtmann } 27040736cfa8SMarcel Holtmann 27054a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2706fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2707fee746b0SMarcel Holtmann goto done; 2708fee746b0SMarcel Holtmann } 2709fee746b0SMarcel Holtmann 27101da177e4SLinus Torvalds /* Drop queues */ 27111da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 27121da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 27131da177e4SLinus Torvalds 271409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 27151f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 27161da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 271709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 27181da177e4SLinus Torvalds 27191da177e4SLinus Torvalds if (hdev->flush) 27201da177e4SLinus Torvalds hdev->flush(hdev); 27211da177e4SLinus Torvalds 27221da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 27236ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 27241da177e4SLinus Torvalds 272501178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 27261da177e4SLinus Torvalds 27271da177e4SLinus Torvalds done: 27281da177e4SLinus Torvalds hci_req_unlock(hdev); 27291da177e4SLinus Torvalds hci_dev_put(hdev); 27301da177e4SLinus Torvalds return ret; 27311da177e4SLinus Torvalds } 27321da177e4SLinus Torvalds 27331da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 27341da177e4SLinus Torvalds { 27351da177e4SLinus Torvalds struct hci_dev *hdev; 27361da177e4SLinus Torvalds int ret = 0; 27371da177e4SLinus Torvalds 273870f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 273970f23020SAndrei Emeltchenko if (!hdev) 27401da177e4SLinus Torvalds return -ENODEV; 27411da177e4SLinus Torvalds 27420736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 27430736cfa8SMarcel Holtmann ret = -EBUSY; 27440736cfa8SMarcel Holtmann goto done; 27450736cfa8SMarcel Holtmann } 27460736cfa8SMarcel Holtmann 27474a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2748fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2749fee746b0SMarcel Holtmann goto done; 2750fee746b0SMarcel Holtmann } 2751fee746b0SMarcel Holtmann 27521da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 27531da177e4SLinus Torvalds 27540736cfa8SMarcel Holtmann done: 27551da177e4SLinus Torvalds hci_dev_put(hdev); 27561da177e4SLinus Torvalds return ret; 27571da177e4SLinus Torvalds } 27581da177e4SLinus Torvalds 2759123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 2760123abc08SJohan Hedberg { 2761bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 2762123abc08SJohan Hedberg 2763123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 2764123abc08SJohan Hedberg 2765123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 2766123abc08SJohan Hedberg conn_changed = !test_and_set_bit(HCI_CONNECTABLE, 2767123abc08SJohan Hedberg &hdev->dev_flags); 2768123abc08SJohan Hedberg else 2769123abc08SJohan Hedberg conn_changed = test_and_clear_bit(HCI_CONNECTABLE, 2770123abc08SJohan Hedberg &hdev->dev_flags); 2771123abc08SJohan Hedberg 2772bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 2773bc6d2d04SJohan Hedberg discov_changed = !test_and_set_bit(HCI_DISCOVERABLE, 2774bc6d2d04SJohan Hedberg &hdev->dev_flags); 2775bc6d2d04SJohan Hedberg } else { 2776bc6d2d04SJohan Hedberg clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 2777bc6d2d04SJohan Hedberg discov_changed = test_and_clear_bit(HCI_DISCOVERABLE, 2778bc6d2d04SJohan Hedberg &hdev->dev_flags); 2779bc6d2d04SJohan Hedberg } 2780bc6d2d04SJohan Hedberg 2781123abc08SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 2782123abc08SJohan Hedberg return; 2783123abc08SJohan Hedberg 2784bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 2785bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 2786bc6d2d04SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 2787bc6d2d04SJohan Hedberg 2788bc6d2d04SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 2789bc6d2d04SJohan Hedberg mgmt_update_adv_data(hdev); 2790bc6d2d04SJohan Hedberg 2791123abc08SJohan Hedberg mgmt_new_settings(hdev); 2792123abc08SJohan Hedberg } 2793bc6d2d04SJohan Hedberg } 2794123abc08SJohan Hedberg 27951da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 27961da177e4SLinus Torvalds { 27971da177e4SLinus Torvalds struct hci_dev *hdev; 27981da177e4SLinus Torvalds struct hci_dev_req dr; 27991da177e4SLinus Torvalds int err = 0; 28001da177e4SLinus Torvalds 28011da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 28021da177e4SLinus Torvalds return -EFAULT; 28031da177e4SLinus Torvalds 280470f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 280570f23020SAndrei Emeltchenko if (!hdev) 28061da177e4SLinus Torvalds return -ENODEV; 28071da177e4SLinus Torvalds 28080736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 28090736cfa8SMarcel Holtmann err = -EBUSY; 28100736cfa8SMarcel Holtmann goto done; 28110736cfa8SMarcel Holtmann } 28120736cfa8SMarcel Holtmann 28134a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2814fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2815fee746b0SMarcel Holtmann goto done; 2816fee746b0SMarcel Holtmann } 2817fee746b0SMarcel Holtmann 28185b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 28195b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 28205b69bef5SMarcel Holtmann goto done; 28215b69bef5SMarcel Holtmann } 28225b69bef5SMarcel Holtmann 282356f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 282456f87901SJohan Hedberg err = -EOPNOTSUPP; 282556f87901SJohan Hedberg goto done; 282656f87901SJohan Hedberg } 282756f87901SJohan Hedberg 28281da177e4SLinus Torvalds switch (cmd) { 28291da177e4SLinus Torvalds case HCISETAUTH: 283001178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 28315f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 28321da177e4SLinus Torvalds break; 28331da177e4SLinus Torvalds 28341da177e4SLinus Torvalds case HCISETENCRYPT: 28351da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 28361da177e4SLinus Torvalds err = -EOPNOTSUPP; 28371da177e4SLinus Torvalds break; 28381da177e4SLinus Torvalds } 28391da177e4SLinus Torvalds 28401da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 28411da177e4SLinus Torvalds /* Auth must be enabled first */ 284201178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 28435f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 28441da177e4SLinus Torvalds if (err) 28451da177e4SLinus Torvalds break; 28461da177e4SLinus Torvalds } 28471da177e4SLinus Torvalds 284801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 28495f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 28501da177e4SLinus Torvalds break; 28511da177e4SLinus Torvalds 28521da177e4SLinus Torvalds case HCISETSCAN: 285301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 28545f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 285591a668b0SJohan Hedberg 2856bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 2857bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 285891a668b0SJohan Hedberg */ 2859123abc08SJohan Hedberg if (!err) 2860123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 28611da177e4SLinus Torvalds break; 28621da177e4SLinus Torvalds 28631da177e4SLinus Torvalds case HCISETLINKPOL: 286401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 28655f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 28661da177e4SLinus Torvalds break; 28671da177e4SLinus Torvalds 28681da177e4SLinus Torvalds case HCISETLINKMODE: 2869e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 2870e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 2871e4e8e37cSMarcel Holtmann break; 2872e4e8e37cSMarcel Holtmann 2873e4e8e37cSMarcel Holtmann case HCISETPTYPE: 2874e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 28751da177e4SLinus Torvalds break; 28761da177e4SLinus Torvalds 28771da177e4SLinus Torvalds case HCISETACLMTU: 28781da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 28791da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 28801da177e4SLinus Torvalds break; 28811da177e4SLinus Torvalds 28821da177e4SLinus Torvalds case HCISETSCOMTU: 28831da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 28841da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 28851da177e4SLinus Torvalds break; 28861da177e4SLinus Torvalds 28871da177e4SLinus Torvalds default: 28881da177e4SLinus Torvalds err = -EINVAL; 28891da177e4SLinus Torvalds break; 28901da177e4SLinus Torvalds } 2891e4e8e37cSMarcel Holtmann 28920736cfa8SMarcel Holtmann done: 28931da177e4SLinus Torvalds hci_dev_put(hdev); 28941da177e4SLinus Torvalds return err; 28951da177e4SLinus Torvalds } 28961da177e4SLinus Torvalds 28971da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 28981da177e4SLinus Torvalds { 28998035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 29001da177e4SLinus Torvalds struct hci_dev_list_req *dl; 29011da177e4SLinus Torvalds struct hci_dev_req *dr; 29021da177e4SLinus Torvalds int n = 0, size, err; 29031da177e4SLinus Torvalds __u16 dev_num; 29041da177e4SLinus Torvalds 29051da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 29061da177e4SLinus Torvalds return -EFAULT; 29071da177e4SLinus Torvalds 29081da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 29091da177e4SLinus Torvalds return -EINVAL; 29101da177e4SLinus Torvalds 29111da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 29121da177e4SLinus Torvalds 291370f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 291470f23020SAndrei Emeltchenko if (!dl) 29151da177e4SLinus Torvalds return -ENOMEM; 29161da177e4SLinus Torvalds 29171da177e4SLinus Torvalds dr = dl->dev_req; 29181da177e4SLinus Torvalds 2919f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 29208035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 29212e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 2922c542a06cSJohan Hedberg 29232e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 29242e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 29252e84d8dbSMarcel Holtmann * device is actually down. 29262e84d8dbSMarcel Holtmann */ 29272e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 29282e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 2929c542a06cSJohan Hedberg 29301da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 29312e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 2932c542a06cSJohan Hedberg 29331da177e4SLinus Torvalds if (++n >= dev_num) 29341da177e4SLinus Torvalds break; 29351da177e4SLinus Torvalds } 2936f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 29371da177e4SLinus Torvalds 29381da177e4SLinus Torvalds dl->dev_num = n; 29391da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 29401da177e4SLinus Torvalds 29411da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 29421da177e4SLinus Torvalds kfree(dl); 29431da177e4SLinus Torvalds 29441da177e4SLinus Torvalds return err ? -EFAULT : 0; 29451da177e4SLinus Torvalds } 29461da177e4SLinus Torvalds 29471da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 29481da177e4SLinus Torvalds { 29491da177e4SLinus Torvalds struct hci_dev *hdev; 29501da177e4SLinus Torvalds struct hci_dev_info di; 29512e84d8dbSMarcel Holtmann unsigned long flags; 29521da177e4SLinus Torvalds int err = 0; 29531da177e4SLinus Torvalds 29541da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 29551da177e4SLinus Torvalds return -EFAULT; 29561da177e4SLinus Torvalds 295770f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 295870f23020SAndrei Emeltchenko if (!hdev) 29591da177e4SLinus Torvalds return -ENODEV; 29601da177e4SLinus Torvalds 29612e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 29622e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 29632e84d8dbSMarcel Holtmann * device is actually down. 29642e84d8dbSMarcel Holtmann */ 29652e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 29662e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 29672e84d8dbSMarcel Holtmann else 29682e84d8dbSMarcel Holtmann flags = hdev->flags; 2969c542a06cSJohan Hedberg 29701da177e4SLinus Torvalds strcpy(di.name, hdev->name); 29711da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 297260f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 29732e84d8dbSMarcel Holtmann di.flags = flags; 29741da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2975572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 29761da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 29771da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 29781da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 29791da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2980572c7f84SJohan Hedberg } else { 2981572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2982572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2983572c7f84SJohan Hedberg di.sco_mtu = 0; 2984572c7f84SJohan Hedberg di.sco_pkts = 0; 2985572c7f84SJohan Hedberg } 29861da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 29871da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 29881da177e4SLinus Torvalds 29891da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 29901da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 29911da177e4SLinus Torvalds 29921da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 29931da177e4SLinus Torvalds err = -EFAULT; 29941da177e4SLinus Torvalds 29951da177e4SLinus Torvalds hci_dev_put(hdev); 29961da177e4SLinus Torvalds 29971da177e4SLinus Torvalds return err; 29981da177e4SLinus Torvalds } 29991da177e4SLinus Torvalds 30001da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 30011da177e4SLinus Torvalds 3002611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 3003611b30f7SMarcel Holtmann { 3004611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 3005611b30f7SMarcel Holtmann 3006611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 3007611b30f7SMarcel Holtmann 30080736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 30090736cfa8SMarcel Holtmann return -EBUSY; 30100736cfa8SMarcel Holtmann 30115e130367SJohan Hedberg if (blocked) { 30125e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 3013d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 3014d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) 3015611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 30165e130367SJohan Hedberg } else { 30175e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 30185e130367SJohan Hedberg } 3019611b30f7SMarcel Holtmann 3020611b30f7SMarcel Holtmann return 0; 3021611b30f7SMarcel Holtmann } 3022611b30f7SMarcel Holtmann 3023611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 3024611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 3025611b30f7SMarcel Holtmann }; 3026611b30f7SMarcel Holtmann 3027ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 3028ab81cbf9SJohan Hedberg { 3029ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 303096570ffcSJohan Hedberg int err; 3031ab81cbf9SJohan Hedberg 3032ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 3033ab81cbf9SJohan Hedberg 3034cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 303596570ffcSJohan Hedberg if (err < 0) { 303696570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 3037ab81cbf9SJohan Hedberg return; 303896570ffcSJohan Hedberg } 3039ab81cbf9SJohan Hedberg 3040a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 3041a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 3042a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 3043a5c8f270SMarcel Holtmann */ 3044a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 30454a964404SMarcel Holtmann test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) || 3046a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 3047a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 3048a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 3049bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 3050bf543036SJohan Hedberg hci_dev_do_close(hdev); 3051bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 305219202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 305319202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 3054bf543036SJohan Hedberg } 3055ab81cbf9SJohan Hedberg 3056fee746b0SMarcel Holtmann if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) { 30574a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 30584a964404SMarcel Holtmann * so that userspace can easily identify them. 30594a964404SMarcel Holtmann */ 30604a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 30614a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 30620602a8adSMarcel Holtmann 30630602a8adSMarcel Holtmann /* For fully configured devices, this will send 30640602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 30650602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 30660602a8adSMarcel Holtmann * 30670602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 30680602a8adSMarcel Holtmann * and no event will be send. 30690602a8adSMarcel Holtmann */ 3070744cf19eSJohan Hedberg mgmt_index_added(hdev); 3071d603b76bSMarcel Holtmann } else if (test_and_clear_bit(HCI_CONFIG, &hdev->dev_flags)) { 30725ea234d3SMarcel Holtmann /* When the controller is now configured, then it 30735ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 30745ea234d3SMarcel Holtmann */ 30755ea234d3SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 30765ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 30775ea234d3SMarcel Holtmann 3078d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 3079d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 3080d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 3081d603b76bSMarcel Holtmann */ 3082d603b76bSMarcel Holtmann mgmt_index_added(hdev); 3083ab81cbf9SJohan Hedberg } 3084ab81cbf9SJohan Hedberg } 3085ab81cbf9SJohan Hedberg 3086ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 3087ab81cbf9SJohan Hedberg { 30883243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 30893243553fSJohan Hedberg power_off.work); 3090ab81cbf9SJohan Hedberg 3091ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 3092ab81cbf9SJohan Hedberg 30938ee56540SMarcel Holtmann hci_dev_do_close(hdev); 3094ab81cbf9SJohan Hedberg } 3095ab81cbf9SJohan Hedberg 309616ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 309716ab91abSJohan Hedberg { 309816ab91abSJohan Hedberg struct hci_dev *hdev; 309916ab91abSJohan Hedberg 310016ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 310116ab91abSJohan Hedberg 310216ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 310316ab91abSJohan Hedberg 3104d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 310516ab91abSJohan Hedberg } 310616ab91abSJohan Hedberg 310735f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 31082aeb9a1aSJohan Hedberg { 31094821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 31102aeb9a1aSJohan Hedberg 31114821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 31124821002cSJohan Hedberg list_del(&uuid->list); 31132aeb9a1aSJohan Hedberg kfree(uuid); 31142aeb9a1aSJohan Hedberg } 31152aeb9a1aSJohan Hedberg } 31162aeb9a1aSJohan Hedberg 311735f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 311855ed8ca1SJohan Hedberg { 311955ed8ca1SJohan Hedberg struct list_head *p, *n; 312055ed8ca1SJohan Hedberg 312155ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 312255ed8ca1SJohan Hedberg struct link_key *key; 312355ed8ca1SJohan Hedberg 312455ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 312555ed8ca1SJohan Hedberg 312655ed8ca1SJohan Hedberg list_del(p); 312755ed8ca1SJohan Hedberg kfree(key); 312855ed8ca1SJohan Hedberg } 312955ed8ca1SJohan Hedberg } 313055ed8ca1SJohan Hedberg 313135f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 3132b899efafSVinicius Costa Gomes { 3133b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 3134b899efafSVinicius Costa Gomes 3135b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 3136b899efafSVinicius Costa Gomes list_del(&k->list); 3137b899efafSVinicius Costa Gomes kfree(k); 3138b899efafSVinicius Costa Gomes } 3139b899efafSVinicius Costa Gomes } 3140b899efafSVinicius Costa Gomes 3141970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 3142970c4e46SJohan Hedberg { 3143970c4e46SJohan Hedberg struct smp_irk *k, *tmp; 3144970c4e46SJohan Hedberg 3145970c4e46SJohan Hedberg list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) { 3146970c4e46SJohan Hedberg list_del(&k->list); 3147970c4e46SJohan Hedberg kfree(k); 3148970c4e46SJohan Hedberg } 3149970c4e46SJohan Hedberg } 3150970c4e46SJohan Hedberg 315155ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 315255ed8ca1SJohan Hedberg { 315355ed8ca1SJohan Hedberg struct link_key *k; 315455ed8ca1SJohan Hedberg 31558035ded4SLuiz Augusto von Dentz list_for_each_entry(k, &hdev->link_keys, list) 315655ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 315755ed8ca1SJohan Hedberg return k; 315855ed8ca1SJohan Hedberg 315955ed8ca1SJohan Hedberg return NULL; 316055ed8ca1SJohan Hedberg } 316155ed8ca1SJohan Hedberg 3162745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 3163d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 3164d25e28abSJohan Hedberg { 3165d25e28abSJohan Hedberg /* Legacy key */ 3166d25e28abSJohan Hedberg if (key_type < 0x03) 3167745c0ce3SVishal Agarwal return true; 3168d25e28abSJohan Hedberg 3169d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 3170d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 3171745c0ce3SVishal Agarwal return false; 3172d25e28abSJohan Hedberg 3173d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 3174d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 3175745c0ce3SVishal Agarwal return false; 3176d25e28abSJohan Hedberg 3177d25e28abSJohan Hedberg /* Security mode 3 case */ 3178d25e28abSJohan Hedberg if (!conn) 3179745c0ce3SVishal Agarwal return true; 3180d25e28abSJohan Hedberg 3181d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 3182d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 3183745c0ce3SVishal Agarwal return true; 3184d25e28abSJohan Hedberg 3185d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 3186d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 3187745c0ce3SVishal Agarwal return true; 3188d25e28abSJohan Hedberg 3189d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 3190d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 3191745c0ce3SVishal Agarwal return true; 3192d25e28abSJohan Hedberg 3193d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 3194d25e28abSJohan Hedberg * persistently */ 3195745c0ce3SVishal Agarwal return false; 3196d25e28abSJohan Hedberg } 3197d25e28abSJohan Hedberg 3198e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 319998a0b845SJohan Hedberg { 3200e804d25dSJohan Hedberg if (type == SMP_LTK) 3201e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 320298a0b845SJohan Hedberg 3203e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 320498a0b845SJohan Hedberg } 320598a0b845SJohan Hedberg 3206fe39c7b2SMarcel Holtmann struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, __le64 rand, 3207e804d25dSJohan Hedberg u8 role) 320875d262c2SVinicius Costa Gomes { 3209c9839a11SVinicius Costa Gomes struct smp_ltk *k; 321075d262c2SVinicius Costa Gomes 3211c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) { 3212fe39c7b2SMarcel Holtmann if (k->ediv != ediv || k->rand != rand) 321375d262c2SVinicius Costa Gomes continue; 321475d262c2SVinicius Costa Gomes 3215e804d25dSJohan Hedberg if (ltk_role(k->type) != role) 321698a0b845SJohan Hedberg continue; 321798a0b845SJohan Hedberg 321875d262c2SVinicius Costa Gomes return k; 321975d262c2SVinicius Costa Gomes } 322075d262c2SVinicius Costa Gomes 322175d262c2SVinicius Costa Gomes return NULL; 322275d262c2SVinicius Costa Gomes } 322375d262c2SVinicius Costa Gomes 3224c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 3225e804d25dSJohan Hedberg u8 addr_type, u8 role) 322675d262c2SVinicius Costa Gomes { 3227c9839a11SVinicius Costa Gomes struct smp_ltk *k; 322875d262c2SVinicius Costa Gomes 3229c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) 3230c9839a11SVinicius Costa Gomes if (addr_type == k->bdaddr_type && 323198a0b845SJohan Hedberg bacmp(bdaddr, &k->bdaddr) == 0 && 3232e804d25dSJohan Hedberg ltk_role(k->type) == role) 323375d262c2SVinicius Costa Gomes return k; 323475d262c2SVinicius Costa Gomes 323575d262c2SVinicius Costa Gomes return NULL; 323675d262c2SVinicius Costa Gomes } 323775d262c2SVinicius Costa Gomes 3238970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 3239970c4e46SJohan Hedberg { 3240970c4e46SJohan Hedberg struct smp_irk *irk; 3241970c4e46SJohan Hedberg 3242970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3243970c4e46SJohan Hedberg if (!bacmp(&irk->rpa, rpa)) 3244970c4e46SJohan Hedberg return irk; 3245970c4e46SJohan Hedberg } 3246970c4e46SJohan Hedberg 3247970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3248defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 3249970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 3250970c4e46SJohan Hedberg return irk; 3251970c4e46SJohan Hedberg } 3252970c4e46SJohan Hedberg } 3253970c4e46SJohan Hedberg 3254970c4e46SJohan Hedberg return NULL; 3255970c4e46SJohan Hedberg } 3256970c4e46SJohan Hedberg 3257970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 3258970c4e46SJohan Hedberg u8 addr_type) 3259970c4e46SJohan Hedberg { 3260970c4e46SJohan Hedberg struct smp_irk *irk; 3261970c4e46SJohan Hedberg 32626cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 32636cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 32646cfc9988SJohan Hedberg return NULL; 32656cfc9988SJohan Hedberg 3266970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3267970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 3268970c4e46SJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) 3269970c4e46SJohan Hedberg return irk; 3270970c4e46SJohan Hedberg } 3271970c4e46SJohan Hedberg 3272970c4e46SJohan Hedberg return NULL; 3273970c4e46SJohan Hedberg } 3274970c4e46SJohan Hedberg 3275567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 32767652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 32777652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 327855ed8ca1SJohan Hedberg { 327955ed8ca1SJohan Hedberg struct link_key *key, *old_key; 3280745c0ce3SVishal Agarwal u8 old_key_type; 328155ed8ca1SJohan Hedberg 328255ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 328355ed8ca1SJohan Hedberg if (old_key) { 328455ed8ca1SJohan Hedberg old_key_type = old_key->type; 328555ed8ca1SJohan Hedberg key = old_key; 328655ed8ca1SJohan Hedberg } else { 328712adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 32880a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 328955ed8ca1SJohan Hedberg if (!key) 3290567fa2aaSJohan Hedberg return NULL; 329155ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 329255ed8ca1SJohan Hedberg } 329355ed8ca1SJohan Hedberg 32946ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 329555ed8ca1SJohan Hedberg 3296d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 3297d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 3298d25e28abSJohan Hedberg * previous key */ 3299d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 3300a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 3301d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 3302655fe6ecSJohan Hedberg if (conn) 3303655fe6ecSJohan Hedberg conn->key_type = type; 3304655fe6ecSJohan Hedberg } 3305d25e28abSJohan Hedberg 330655ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 33079b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 330855ed8ca1SJohan Hedberg key->pin_len = pin_len; 330955ed8ca1SJohan Hedberg 3310b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 331155ed8ca1SJohan Hedberg key->type = old_key_type; 33124748fed2SJohan Hedberg else 33134748fed2SJohan Hedberg key->type = type; 33144748fed2SJohan Hedberg 33157652ff6aSJohan Hedberg if (persistent) 33167652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 33177652ff6aSJohan Hedberg old_key_type); 33184df378a1SJohan Hedberg 3319567fa2aaSJohan Hedberg return key; 332055ed8ca1SJohan Hedberg } 332155ed8ca1SJohan Hedberg 3322ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 332335d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 3324fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 332575d262c2SVinicius Costa Gomes { 3326c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 3327e804d25dSJohan Hedberg u8 role = ltk_role(type); 332875d262c2SVinicius Costa Gomes 3329e804d25dSJohan Hedberg old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type, role); 3330c9839a11SVinicius Costa Gomes if (old_key) 333175d262c2SVinicius Costa Gomes key = old_key; 3332c9839a11SVinicius Costa Gomes else { 33330a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 333475d262c2SVinicius Costa Gomes if (!key) 3335ca9142b8SJohan Hedberg return NULL; 3336c9839a11SVinicius Costa Gomes list_add(&key->list, &hdev->long_term_keys); 333775d262c2SVinicius Costa Gomes } 333875d262c2SVinicius Costa Gomes 333975d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 3340c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 3341c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 3342c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 3343c9839a11SVinicius Costa Gomes key->ediv = ediv; 3344fe39c7b2SMarcel Holtmann key->rand = rand; 3345c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 3346c9839a11SVinicius Costa Gomes key->type = type; 334775d262c2SVinicius Costa Gomes 3348ca9142b8SJohan Hedberg return key; 334975d262c2SVinicius Costa Gomes } 335075d262c2SVinicius Costa Gomes 3351ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 3352ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 3353970c4e46SJohan Hedberg { 3354970c4e46SJohan Hedberg struct smp_irk *irk; 3355970c4e46SJohan Hedberg 3356970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 3357970c4e46SJohan Hedberg if (!irk) { 3358970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 3359970c4e46SJohan Hedberg if (!irk) 3360ca9142b8SJohan Hedberg return NULL; 3361970c4e46SJohan Hedberg 3362970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 3363970c4e46SJohan Hedberg irk->addr_type = addr_type; 3364970c4e46SJohan Hedberg 3365970c4e46SJohan Hedberg list_add(&irk->list, &hdev->identity_resolving_keys); 3366970c4e46SJohan Hedberg } 3367970c4e46SJohan Hedberg 3368970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 3369970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 3370970c4e46SJohan Hedberg 3371ca9142b8SJohan Hedberg return irk; 3372970c4e46SJohan Hedberg } 3373970c4e46SJohan Hedberg 337455ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 337555ed8ca1SJohan Hedberg { 337655ed8ca1SJohan Hedberg struct link_key *key; 337755ed8ca1SJohan Hedberg 337855ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 337955ed8ca1SJohan Hedberg if (!key) 338055ed8ca1SJohan Hedberg return -ENOENT; 338155ed8ca1SJohan Hedberg 33826ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 338355ed8ca1SJohan Hedberg 338455ed8ca1SJohan Hedberg list_del(&key->list); 338555ed8ca1SJohan Hedberg kfree(key); 338655ed8ca1SJohan Hedberg 338755ed8ca1SJohan Hedberg return 0; 338855ed8ca1SJohan Hedberg } 338955ed8ca1SJohan Hedberg 3390e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 3391b899efafSVinicius Costa Gomes { 3392b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 3393c51ffa0bSJohan Hedberg int removed = 0; 3394b899efafSVinicius Costa Gomes 3395b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 3396e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 3397b899efafSVinicius Costa Gomes continue; 3398b899efafSVinicius Costa Gomes 33996ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3400b899efafSVinicius Costa Gomes 3401b899efafSVinicius Costa Gomes list_del(&k->list); 3402b899efafSVinicius Costa Gomes kfree(k); 3403c51ffa0bSJohan Hedberg removed++; 3404b899efafSVinicius Costa Gomes } 3405b899efafSVinicius Costa Gomes 3406c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 3407b899efafSVinicius Costa Gomes } 3408b899efafSVinicius Costa Gomes 3409a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 3410a7ec7338SJohan Hedberg { 3411a7ec7338SJohan Hedberg struct smp_irk *k, *tmp; 3412a7ec7338SJohan Hedberg 3413668b7b19SJohan Hedberg list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) { 3414a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 3415a7ec7338SJohan Hedberg continue; 3416a7ec7338SJohan Hedberg 3417a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3418a7ec7338SJohan Hedberg 3419a7ec7338SJohan Hedberg list_del(&k->list); 3420a7ec7338SJohan Hedberg kfree(k); 3421a7ec7338SJohan Hedberg } 3422a7ec7338SJohan Hedberg } 3423a7ec7338SJohan Hedberg 34246bd32326SVille Tervo /* HCI command timer function */ 342565cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 34266bd32326SVille Tervo { 342765cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 342865cc2b49SMarcel Holtmann cmd_timer.work); 34296bd32326SVille Tervo 3430bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 3431bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 3432bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 3433bda4f23aSAndrei Emeltchenko 3434bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 3435bda4f23aSAndrei Emeltchenko } else { 34366bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 3437bda4f23aSAndrei Emeltchenko } 3438bda4f23aSAndrei Emeltchenko 34396bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 3440c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 34416bd32326SVille Tervo } 34426bd32326SVille Tervo 34432763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 34442763eda6SSzymon Janc bdaddr_t *bdaddr) 34452763eda6SSzymon Janc { 34462763eda6SSzymon Janc struct oob_data *data; 34472763eda6SSzymon Janc 34482763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 34492763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 34502763eda6SSzymon Janc return data; 34512763eda6SSzymon Janc 34522763eda6SSzymon Janc return NULL; 34532763eda6SSzymon Janc } 34542763eda6SSzymon Janc 34552763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 34562763eda6SSzymon Janc { 34572763eda6SSzymon Janc struct oob_data *data; 34582763eda6SSzymon Janc 34592763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 34602763eda6SSzymon Janc if (!data) 34612763eda6SSzymon Janc return -ENOENT; 34622763eda6SSzymon Janc 34636ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 34642763eda6SSzymon Janc 34652763eda6SSzymon Janc list_del(&data->list); 34662763eda6SSzymon Janc kfree(data); 34672763eda6SSzymon Janc 34682763eda6SSzymon Janc return 0; 34692763eda6SSzymon Janc } 34702763eda6SSzymon Janc 347135f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 34722763eda6SSzymon Janc { 34732763eda6SSzymon Janc struct oob_data *data, *n; 34742763eda6SSzymon Janc 34752763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 34762763eda6SSzymon Janc list_del(&data->list); 34772763eda6SSzymon Janc kfree(data); 34782763eda6SSzymon Janc } 34792763eda6SSzymon Janc } 34802763eda6SSzymon Janc 34810798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 34820798872eSMarcel Holtmann u8 *hash, u8 *randomizer) 34832763eda6SSzymon Janc { 34842763eda6SSzymon Janc struct oob_data *data; 34852763eda6SSzymon Janc 34862763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 34872763eda6SSzymon Janc if (!data) { 34880a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 34892763eda6SSzymon Janc if (!data) 34902763eda6SSzymon Janc return -ENOMEM; 34912763eda6SSzymon Janc 34922763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 34932763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 34942763eda6SSzymon Janc } 34952763eda6SSzymon Janc 3496519ca9d0SMarcel Holtmann memcpy(data->hash192, hash, sizeof(data->hash192)); 3497519ca9d0SMarcel Holtmann memcpy(data->randomizer192, randomizer, sizeof(data->randomizer192)); 34982763eda6SSzymon Janc 34990798872eSMarcel Holtmann memset(data->hash256, 0, sizeof(data->hash256)); 35000798872eSMarcel Holtmann memset(data->randomizer256, 0, sizeof(data->randomizer256)); 35010798872eSMarcel Holtmann 35020798872eSMarcel Holtmann BT_DBG("%s for %pMR", hdev->name, bdaddr); 35030798872eSMarcel Holtmann 35040798872eSMarcel Holtmann return 0; 35050798872eSMarcel Holtmann } 35060798872eSMarcel Holtmann 35070798872eSMarcel Holtmann int hci_add_remote_oob_ext_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 35080798872eSMarcel Holtmann u8 *hash192, u8 *randomizer192, 35090798872eSMarcel Holtmann u8 *hash256, u8 *randomizer256) 35100798872eSMarcel Holtmann { 35110798872eSMarcel Holtmann struct oob_data *data; 35120798872eSMarcel Holtmann 35130798872eSMarcel Holtmann data = hci_find_remote_oob_data(hdev, bdaddr); 35140798872eSMarcel Holtmann if (!data) { 35150a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 35160798872eSMarcel Holtmann if (!data) 35170798872eSMarcel Holtmann return -ENOMEM; 35180798872eSMarcel Holtmann 35190798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 35200798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 35210798872eSMarcel Holtmann } 35220798872eSMarcel Holtmann 35230798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 35240798872eSMarcel Holtmann memcpy(data->randomizer192, randomizer192, sizeof(data->randomizer192)); 35250798872eSMarcel Holtmann 35260798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 35270798872eSMarcel Holtmann memcpy(data->randomizer256, randomizer256, sizeof(data->randomizer256)); 35280798872eSMarcel Holtmann 35296ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 35302763eda6SSzymon Janc 35312763eda6SSzymon Janc return 0; 35322763eda6SSzymon Janc } 35332763eda6SSzymon Janc 3534dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 3535b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 3536b2a66aadSAntti Julku { 3537b2a66aadSAntti Julku struct bdaddr_list *b; 3538b2a66aadSAntti Julku 3539dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 3540b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 3541b2a66aadSAntti Julku return b; 3542b9ee0a78SMarcel Holtmann } 3543b2a66aadSAntti Julku 3544b2a66aadSAntti Julku return NULL; 3545b2a66aadSAntti Julku } 3546b2a66aadSAntti Julku 3547dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 3548b2a66aadSAntti Julku { 3549b2a66aadSAntti Julku struct list_head *p, *n; 3550b2a66aadSAntti Julku 3551dcc36c16SJohan Hedberg list_for_each_safe(p, n, bdaddr_list) { 3552b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 3553b2a66aadSAntti Julku 3554b2a66aadSAntti Julku list_del(p); 3555b2a66aadSAntti Julku kfree(b); 3556b2a66aadSAntti Julku } 3557b2a66aadSAntti Julku } 3558b2a66aadSAntti Julku 3559dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3560b2a66aadSAntti Julku { 3561b2a66aadSAntti Julku struct bdaddr_list *entry; 3562b2a66aadSAntti Julku 3563b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 3564b2a66aadSAntti Julku return -EBADF; 3565b2a66aadSAntti Julku 3566dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 35675e762444SAntti Julku return -EEXIST; 3568b2a66aadSAntti Julku 356927f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 35705e762444SAntti Julku if (!entry) 35715e762444SAntti Julku return -ENOMEM; 3572b2a66aadSAntti Julku 3573b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 3574b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 3575b2a66aadSAntti Julku 3576dcc36c16SJohan Hedberg list_add(&entry->list, list); 3577b2a66aadSAntti Julku 35782a8357f2SJohan Hedberg return 0; 3579b2a66aadSAntti Julku } 3580b2a66aadSAntti Julku 3581dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3582b2a66aadSAntti Julku { 3583b2a66aadSAntti Julku struct bdaddr_list *entry; 3584b2a66aadSAntti Julku 358535f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 3586dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 358735f7498aSJohan Hedberg return 0; 358835f7498aSJohan Hedberg } 3589b2a66aadSAntti Julku 3590dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 3591d2ab0ac1SMarcel Holtmann if (!entry) 3592d2ab0ac1SMarcel Holtmann return -ENOENT; 3593d2ab0ac1SMarcel Holtmann 3594d2ab0ac1SMarcel Holtmann list_del(&entry->list); 3595d2ab0ac1SMarcel Holtmann kfree(entry); 3596d2ab0ac1SMarcel Holtmann 3597d2ab0ac1SMarcel Holtmann return 0; 3598d2ab0ac1SMarcel Holtmann } 3599d2ab0ac1SMarcel Holtmann 360015819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 360115819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 360215819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 360315819a70SAndre Guedes { 360415819a70SAndre Guedes struct hci_conn_params *params; 360515819a70SAndre Guedes 3606738f6185SJohan Hedberg /* The conn params list only contains identity addresses */ 3607738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 3608738f6185SJohan Hedberg return NULL; 3609738f6185SJohan Hedberg 361015819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 361115819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 361215819a70SAndre Guedes params->addr_type == addr_type) { 361315819a70SAndre Guedes return params; 361415819a70SAndre Guedes } 361515819a70SAndre Guedes } 361615819a70SAndre Guedes 361715819a70SAndre Guedes return NULL; 361815819a70SAndre Guedes } 361915819a70SAndre Guedes 3620cef952ceSAndre Guedes static bool is_connected(struct hci_dev *hdev, bdaddr_t *addr, u8 type) 3621cef952ceSAndre Guedes { 3622cef952ceSAndre Guedes struct hci_conn *conn; 3623cef952ceSAndre Guedes 3624cef952ceSAndre Guedes conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, addr); 3625cef952ceSAndre Guedes if (!conn) 3626cef952ceSAndre Guedes return false; 3627cef952ceSAndre Guedes 3628cef952ceSAndre Guedes if (conn->dst_type != type) 3629cef952ceSAndre Guedes return false; 3630cef952ceSAndre Guedes 3631cef952ceSAndre Guedes if (conn->state != BT_CONNECTED) 3632cef952ceSAndre Guedes return false; 3633cef952ceSAndre Guedes 3634cef952ceSAndre Guedes return true; 3635cef952ceSAndre Guedes } 3636cef952ceSAndre Guedes 363715819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 3638501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 36394b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 364015819a70SAndre Guedes { 3641912b42efSJohan Hedberg struct hci_conn_params *param; 364215819a70SAndre Guedes 3643738f6185SJohan Hedberg /* The list only contains identity addresses */ 3644738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 3645738f6185SJohan Hedberg return NULL; 364615819a70SAndre Guedes 3647501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 3648912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 3649912b42efSJohan Hedberg param->addr_type == addr_type) 3650912b42efSJohan Hedberg return param; 36514b10966fSMarcel Holtmann } 36524b10966fSMarcel Holtmann 36534b10966fSMarcel Holtmann return NULL; 365415819a70SAndre Guedes } 365515819a70SAndre Guedes 365615819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 365751d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 365851d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 365915819a70SAndre Guedes { 366015819a70SAndre Guedes struct hci_conn_params *params; 366115819a70SAndre Guedes 3662c46245b3SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 366351d167c0SMarcel Holtmann return NULL; 3664a9b0a04cSAndre Guedes 366515819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 3666cef952ceSAndre Guedes if (params) 366751d167c0SMarcel Holtmann return params; 366815819a70SAndre Guedes 366915819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 367015819a70SAndre Guedes if (!params) { 367115819a70SAndre Guedes BT_ERR("Out of memory"); 367251d167c0SMarcel Holtmann return NULL; 367315819a70SAndre Guedes } 367415819a70SAndre Guedes 367515819a70SAndre Guedes bacpy(¶ms->addr, addr); 367615819a70SAndre Guedes params->addr_type = addr_type; 3677cef952ceSAndre Guedes 3678cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 367993450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 3680cef952ceSAndre Guedes 3681bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 3682bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 3683bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 3684bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 3685bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 3686bf5b3c8bSMarcel Holtmann 3687bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 3688bf5b3c8bSMarcel Holtmann 368951d167c0SMarcel Holtmann return params; 3690bf5b3c8bSMarcel Holtmann } 3691bf5b3c8bSMarcel Holtmann 3692bf5b3c8bSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 3693bf5b3c8bSMarcel Holtmann int hci_conn_params_set(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type, 3694d06b50ceSMarcel Holtmann u8 auto_connect) 369515819a70SAndre Guedes { 369615819a70SAndre Guedes struct hci_conn_params *params; 369715819a70SAndre Guedes 36988c87aae1SMarcel Holtmann params = hci_conn_params_add(hdev, addr, addr_type); 36998c87aae1SMarcel Holtmann if (!params) 37008c87aae1SMarcel Holtmann return -EIO; 370115819a70SAndre Guedes 370242ce26deSJohan Hedberg if (params->auto_connect == auto_connect) 370342ce26deSJohan Hedberg return 0; 370442ce26deSJohan Hedberg 370566f8455aSJohan Hedberg list_del_init(¶ms->action); 370615819a70SAndre Guedes 3707cef952ceSAndre Guedes switch (auto_connect) { 3708cef952ceSAndre Guedes case HCI_AUTO_CONN_DISABLED: 3709cef952ceSAndre Guedes case HCI_AUTO_CONN_LINK_LOSS: 371095305baaSJohan Hedberg hci_update_background_scan(hdev); 3711cef952ceSAndre Guedes break; 3712851efca8SJohan Hedberg case HCI_AUTO_CONN_REPORT: 371395305baaSJohan Hedberg list_add(¶ms->action, &hdev->pend_le_reports); 371495305baaSJohan Hedberg hci_update_background_scan(hdev); 3715851efca8SJohan Hedberg break; 37164b9e7e75SMarcel Holtmann case HCI_AUTO_CONN_DIRECT: 3717cef952ceSAndre Guedes case HCI_AUTO_CONN_ALWAYS: 371895305baaSJohan Hedberg if (!is_connected(hdev, addr, addr_type)) { 371995305baaSJohan Hedberg list_add(¶ms->action, &hdev->pend_le_conns); 372095305baaSJohan Hedberg hci_update_background_scan(hdev); 372195305baaSJohan Hedberg } 3722cef952ceSAndre Guedes break; 3723cef952ceSAndre Guedes } 372415819a70SAndre Guedes 3725851efca8SJohan Hedberg params->auto_connect = auto_connect; 3726851efca8SJohan Hedberg 3727d06b50ceSMarcel Holtmann BT_DBG("addr %pMR (type %u) auto_connect %u", addr, addr_type, 3728d06b50ceSMarcel Holtmann auto_connect); 3729a9b0a04cSAndre Guedes 3730a9b0a04cSAndre Guedes return 0; 373115819a70SAndre Guedes } 373215819a70SAndre Guedes 3733f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 3734f6c63249SJohan Hedberg { 3735f6c63249SJohan Hedberg if (params->conn) { 3736f6c63249SJohan Hedberg hci_conn_drop(params->conn); 3737f6c63249SJohan Hedberg hci_conn_put(params->conn); 3738f6c63249SJohan Hedberg } 3739f6c63249SJohan Hedberg 3740f6c63249SJohan Hedberg list_del(¶ms->action); 3741f6c63249SJohan Hedberg list_del(¶ms->list); 3742f6c63249SJohan Hedberg kfree(params); 3743f6c63249SJohan Hedberg } 3744f6c63249SJohan Hedberg 374515819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 374615819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 374715819a70SAndre Guedes { 374815819a70SAndre Guedes struct hci_conn_params *params; 374915819a70SAndre Guedes 375015819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 375115819a70SAndre Guedes if (!params) 375215819a70SAndre Guedes return; 375315819a70SAndre Guedes 3754f6c63249SJohan Hedberg hci_conn_params_free(params); 375515819a70SAndre Guedes 375695305baaSJohan Hedberg hci_update_background_scan(hdev); 375795305baaSJohan Hedberg 375815819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 375915819a70SAndre Guedes } 376015819a70SAndre Guedes 376115819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 376255af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 376315819a70SAndre Guedes { 376415819a70SAndre Guedes struct hci_conn_params *params, *tmp; 376515819a70SAndre Guedes 376615819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 376755af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 376855af49a8SJohan Hedberg continue; 376915819a70SAndre Guedes list_del(¶ms->list); 377015819a70SAndre Guedes kfree(params); 377115819a70SAndre Guedes } 377215819a70SAndre Guedes 377355af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 377455af49a8SJohan Hedberg } 377555af49a8SJohan Hedberg 377655af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 3777373110c5SJohan Hedberg void hci_conn_params_clear_all(struct hci_dev *hdev) 377815819a70SAndre Guedes { 377915819a70SAndre Guedes struct hci_conn_params *params, *tmp; 378015819a70SAndre Guedes 3781f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 3782f6c63249SJohan Hedberg hci_conn_params_free(params); 378315819a70SAndre Guedes 3784a2f41a8fSJohan Hedberg hci_update_background_scan(hdev); 37851089b67dSMarcel Holtmann 378615819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 378715819a70SAndre Guedes } 378815819a70SAndre Guedes 37894c87eaabSAndre Guedes static void inquiry_complete(struct hci_dev *hdev, u8 status) 37907ba8b4beSAndre Guedes { 37914c87eaabSAndre Guedes if (status) { 37924c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 37937ba8b4beSAndre Guedes 37944c87eaabSAndre Guedes hci_dev_lock(hdev); 37954c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37964c87eaabSAndre Guedes hci_dev_unlock(hdev); 37974c87eaabSAndre Guedes return; 37984c87eaabSAndre Guedes } 37997ba8b4beSAndre Guedes } 38007ba8b4beSAndre Guedes 38014c87eaabSAndre Guedes static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status) 38027ba8b4beSAndre Guedes { 38034c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 38044c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 38054c87eaabSAndre Guedes struct hci_request req; 38064c87eaabSAndre Guedes struct hci_cp_inquiry cp; 38077ba8b4beSAndre Guedes int err; 38087ba8b4beSAndre Guedes 38094c87eaabSAndre Guedes if (status) { 38104c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 38114c87eaabSAndre Guedes return; 38127ba8b4beSAndre Guedes } 38137ba8b4beSAndre Guedes 38144c87eaabSAndre Guedes switch (hdev->discovery.type) { 38154c87eaabSAndre Guedes case DISCOV_TYPE_LE: 38164c87eaabSAndre Guedes hci_dev_lock(hdev); 38174c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 38184c87eaabSAndre Guedes hci_dev_unlock(hdev); 38194c87eaabSAndre Guedes break; 38207dbfac1dSAndre Guedes 38214c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 38224c87eaabSAndre Guedes hci_req_init(&req, hdev); 38237dbfac1dSAndre Guedes 38247dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 38254c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 38264c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 38274c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 38284c87eaabSAndre Guedes 38294c87eaabSAndre Guedes hci_dev_lock(hdev); 38304c87eaabSAndre Guedes 38314c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 38324c87eaabSAndre Guedes 38334c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 38344c87eaabSAndre Guedes if (err) { 38354c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 38364c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 38377dbfac1dSAndre Guedes } 38387dbfac1dSAndre Guedes 38394c87eaabSAndre Guedes hci_dev_unlock(hdev); 38404c87eaabSAndre Guedes break; 38414c87eaabSAndre Guedes } 38427dbfac1dSAndre Guedes } 38437dbfac1dSAndre Guedes 38447ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 38457ba8b4beSAndre Guedes { 38467ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 38477ba8b4beSAndre Guedes le_scan_disable.work); 38484c87eaabSAndre Guedes struct hci_request req; 38494c87eaabSAndre Guedes int err; 38507ba8b4beSAndre Guedes 38517ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 38527ba8b4beSAndre Guedes 38534c87eaabSAndre Guedes hci_req_init(&req, hdev); 38547ba8b4beSAndre Guedes 3855b1efcc28SAndre Guedes hci_req_add_le_scan_disable(&req); 38567ba8b4beSAndre Guedes 38574c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 38584c87eaabSAndre Guedes if (err) 38594c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 386028b75a89SAndre Guedes } 386128b75a89SAndre Guedes 38628d97250eSJohan Hedberg static void set_random_addr(struct hci_request *req, bdaddr_t *rpa) 38638d97250eSJohan Hedberg { 38648d97250eSJohan Hedberg struct hci_dev *hdev = req->hdev; 38658d97250eSJohan Hedberg 38668d97250eSJohan Hedberg /* If we're advertising or initiating an LE connection we can't 38678d97250eSJohan Hedberg * go ahead and change the random address at this time. This is 38688d97250eSJohan Hedberg * because the eventual initiator address used for the 38698d97250eSJohan Hedberg * subsequently created connection will be undefined (some 38708d97250eSJohan Hedberg * controllers use the new address and others the one we had 38718d97250eSJohan Hedberg * when the operation started). 38728d97250eSJohan Hedberg * 38738d97250eSJohan Hedberg * In this kind of scenario skip the update and let the random 38748d97250eSJohan Hedberg * address be updated at the next cycle. 38758d97250eSJohan Hedberg */ 38765ce194c4SJohan Hedberg if (test_bit(HCI_LE_ADV, &hdev->dev_flags) || 38778d97250eSJohan Hedberg hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT)) { 38788d97250eSJohan Hedberg BT_DBG("Deferring random address update"); 38799a783a13SJohan Hedberg set_bit(HCI_RPA_EXPIRED, &hdev->dev_flags); 38808d97250eSJohan Hedberg return; 38818d97250eSJohan Hedberg } 38828d97250eSJohan Hedberg 38838d97250eSJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, rpa); 38848d97250eSJohan Hedberg } 38858d97250eSJohan Hedberg 388694b1fc92SMarcel Holtmann int hci_update_random_address(struct hci_request *req, bool require_privacy, 388794b1fc92SMarcel Holtmann u8 *own_addr_type) 3888ebd3a747SJohan Hedberg { 3889ebd3a747SJohan Hedberg struct hci_dev *hdev = req->hdev; 3890ebd3a747SJohan Hedberg int err; 3891ebd3a747SJohan Hedberg 3892ebd3a747SJohan Hedberg /* If privacy is enabled use a resolvable private address. If 38932b5224dcSMarcel Holtmann * current RPA has expired or there is something else than 38942b5224dcSMarcel Holtmann * the current RPA in use, then generate a new one. 3895ebd3a747SJohan Hedberg */ 3896ebd3a747SJohan Hedberg if (test_bit(HCI_PRIVACY, &hdev->dev_flags)) { 3897ebd3a747SJohan Hedberg int to; 3898ebd3a747SJohan Hedberg 3899ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3900ebd3a747SJohan Hedberg 3901ebd3a747SJohan Hedberg if (!test_and_clear_bit(HCI_RPA_EXPIRED, &hdev->dev_flags) && 39022b5224dcSMarcel Holtmann !bacmp(&hdev->random_addr, &hdev->rpa)) 3903ebd3a747SJohan Hedberg return 0; 3904ebd3a747SJohan Hedberg 3905defce9e8SJohan Hedberg err = smp_generate_rpa(hdev, hdev->irk, &hdev->rpa); 3906ebd3a747SJohan Hedberg if (err < 0) { 3907ebd3a747SJohan Hedberg BT_ERR("%s failed to generate new RPA", hdev->name); 3908ebd3a747SJohan Hedberg return err; 3909ebd3a747SJohan Hedberg } 3910ebd3a747SJohan Hedberg 39118d97250eSJohan Hedberg set_random_addr(req, &hdev->rpa); 3912ebd3a747SJohan Hedberg 3913ebd3a747SJohan Hedberg to = msecs_to_jiffies(hdev->rpa_timeout * 1000); 3914ebd3a747SJohan Hedberg queue_delayed_work(hdev->workqueue, &hdev->rpa_expired, to); 3915ebd3a747SJohan Hedberg 3916ebd3a747SJohan Hedberg return 0; 3917ebd3a747SJohan Hedberg } 3918ebd3a747SJohan Hedberg 391994b1fc92SMarcel Holtmann /* In case of required privacy without resolvable private address, 392094b1fc92SMarcel Holtmann * use an unresolvable private address. This is useful for active 392194b1fc92SMarcel Holtmann * scanning and non-connectable advertising. 392294b1fc92SMarcel Holtmann */ 392394b1fc92SMarcel Holtmann if (require_privacy) { 392494b1fc92SMarcel Holtmann bdaddr_t urpa; 392594b1fc92SMarcel Holtmann 392694b1fc92SMarcel Holtmann get_random_bytes(&urpa, 6); 392794b1fc92SMarcel Holtmann urpa.b[5] &= 0x3f; /* Clear two most significant bits */ 392894b1fc92SMarcel Holtmann 392994b1fc92SMarcel Holtmann *own_addr_type = ADDR_LE_DEV_RANDOM; 39308d97250eSJohan Hedberg set_random_addr(req, &urpa); 393194b1fc92SMarcel Holtmann return 0; 393294b1fc92SMarcel Holtmann } 393394b1fc92SMarcel Holtmann 3934ebd3a747SJohan Hedberg /* If forcing static address is in use or there is no public 3935ebd3a747SJohan Hedberg * address use the static address as random address (but skip 3936ebd3a747SJohan Hedberg * the HCI command if the current random address is already the 3937ebd3a747SJohan Hedberg * static one. 3938ebd3a747SJohan Hedberg */ 3939111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3940ebd3a747SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3941ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3942ebd3a747SJohan Hedberg if (bacmp(&hdev->static_addr, &hdev->random_addr)) 3943ebd3a747SJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, 3944ebd3a747SJohan Hedberg &hdev->static_addr); 3945ebd3a747SJohan Hedberg return 0; 3946ebd3a747SJohan Hedberg } 3947ebd3a747SJohan Hedberg 3948ebd3a747SJohan Hedberg /* Neither privacy nor static address is being used so use a 3949ebd3a747SJohan Hedberg * public address. 3950ebd3a747SJohan Hedberg */ 3951ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_PUBLIC; 3952ebd3a747SJohan Hedberg 3953ebd3a747SJohan Hedberg return 0; 3954ebd3a747SJohan Hedberg } 3955ebd3a747SJohan Hedberg 3956a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 3957a1f4c318SJohan Hedberg * 3958a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 3959a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 3960a1f4c318SJohan Hedberg * the static random address. 3961a1f4c318SJohan Hedberg * 3962a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 3963a1f4c318SJohan Hedberg * public address to use the static random address instead. 3964a1f4c318SJohan Hedberg */ 3965a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 3966a1f4c318SJohan Hedberg u8 *bdaddr_type) 3967a1f4c318SJohan Hedberg { 3968111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3969a1f4c318SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3970a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3971a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3972a1f4c318SJohan Hedberg } else { 3973a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3974a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3975a1f4c318SJohan Hedberg } 3976a1f4c318SJohan Hedberg } 3977a1f4c318SJohan Hedberg 39789be0dab7SDavid Herrmann /* Alloc HCI device */ 39799be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 39809be0dab7SDavid Herrmann { 39819be0dab7SDavid Herrmann struct hci_dev *hdev; 39829be0dab7SDavid Herrmann 398327f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 39849be0dab7SDavid Herrmann if (!hdev) 39859be0dab7SDavid Herrmann return NULL; 39869be0dab7SDavid Herrmann 3987b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3988b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3989b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3990b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3991b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 399296c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3993bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3994bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3995b1b813d4SDavid Herrmann 3996b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3997b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3998b1b813d4SDavid Herrmann 39993f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 4000628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 4001628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 4002bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 4003bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 40044e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 40054e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 400604fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 400704fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 4008bef64738SMarcel Holtmann 4009d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 4010b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 401131ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 401231ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 4013d6bfd59cSJohan Hedberg 4014b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 4015b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 4016b1b813d4SDavid Herrmann 4017b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 4018b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 40196659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 4020b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 4021b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 4022b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 4023970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 4024b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 4025d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 402615819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 402777a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 402866f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 40296b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 4030b1b813d4SDavid Herrmann 4031b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 4032b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 4033b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 4034b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 4035b1b813d4SDavid Herrmann 4036b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 4037b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 4038b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 4039b1b813d4SDavid Herrmann 4040b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 4041b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 4042b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 4043b1b813d4SDavid Herrmann 4044b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 4045b1b813d4SDavid Herrmann 404665cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 4047b1b813d4SDavid Herrmann 4048b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 4049b1b813d4SDavid Herrmann discovery_init(hdev); 40509be0dab7SDavid Herrmann 40519be0dab7SDavid Herrmann return hdev; 40529be0dab7SDavid Herrmann } 40539be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 40549be0dab7SDavid Herrmann 40559be0dab7SDavid Herrmann /* Free HCI device */ 40569be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 40579be0dab7SDavid Herrmann { 40589be0dab7SDavid Herrmann /* will free via device release */ 40599be0dab7SDavid Herrmann put_device(&hdev->dev); 40609be0dab7SDavid Herrmann } 40619be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 40629be0dab7SDavid Herrmann 40631da177e4SLinus Torvalds /* Register HCI device */ 40641da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 40651da177e4SLinus Torvalds { 4066b1b813d4SDavid Herrmann int id, error; 40671da177e4SLinus Torvalds 406874292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 40691da177e4SLinus Torvalds return -EINVAL; 40701da177e4SLinus Torvalds 407108add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 407208add513SMat Martineau * so the index can be used as the AMP controller ID. 407308add513SMat Martineau */ 40743df92b31SSasha Levin switch (hdev->dev_type) { 40753df92b31SSasha Levin case HCI_BREDR: 40763df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 40771da177e4SLinus Torvalds break; 40783df92b31SSasha Levin case HCI_AMP: 40793df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 40803df92b31SSasha Levin break; 40813df92b31SSasha Levin default: 40823df92b31SSasha Levin return -EINVAL; 40831da177e4SLinus Torvalds } 40841da177e4SLinus Torvalds 40853df92b31SSasha Levin if (id < 0) 40863df92b31SSasha Levin return id; 40873df92b31SSasha Levin 40881da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 40891da177e4SLinus Torvalds hdev->id = id; 40902d8b3a11SAndrei Emeltchenko 40912d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 40922d8b3a11SAndrei Emeltchenko 4093d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 4094d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 409533ca954dSDavid Herrmann if (!hdev->workqueue) { 409633ca954dSDavid Herrmann error = -ENOMEM; 409733ca954dSDavid Herrmann goto err; 409833ca954dSDavid Herrmann } 4099f48fd9c8SMarcel Holtmann 4100d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 4101d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 41026ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 41036ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 41046ead1bbcSJohan Hedberg error = -ENOMEM; 41056ead1bbcSJohan Hedberg goto err; 41066ead1bbcSJohan Hedberg } 41076ead1bbcSJohan Hedberg 41080153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 41090153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 41100153e2ecSMarcel Holtmann 4111bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 4112bdc3e0f1SMarcel Holtmann 4113bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 411433ca954dSDavid Herrmann if (error < 0) 411554506918SJohan Hedberg goto err_wqueue; 41161da177e4SLinus Torvalds 4117611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 4118a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 4119a8c5fb1aSGustavo Padovan hdev); 4120611b30f7SMarcel Holtmann if (hdev->rfkill) { 4121611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 4122611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 4123611b30f7SMarcel Holtmann hdev->rfkill = NULL; 4124611b30f7SMarcel Holtmann } 4125611b30f7SMarcel Holtmann } 4126611b30f7SMarcel Holtmann 41275e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 41285e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 41295e130367SJohan Hedberg 4130a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 4131004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 4132ce2be9acSAndrei Emeltchenko 413301cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 413456f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 413556f87901SJohan Hedberg * through reading supported features during init. 413656f87901SJohan Hedberg */ 413756f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 413856f87901SJohan Hedberg } 4139ce2be9acSAndrei Emeltchenko 4140fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 4141fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 4142fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 4143fcee3377SGustavo Padovan 41444a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 41454a964404SMarcel Holtmann * and should not be included in normal operation. 4146fee746b0SMarcel Holtmann */ 4147fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 41484a964404SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 4149fee746b0SMarcel Holtmann 41501da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 4151dc946bd8SDavid Herrmann hci_dev_hold(hdev); 41521da177e4SLinus Torvalds 415319202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 4154fbe96d6fSMarcel Holtmann 41551da177e4SLinus Torvalds return id; 4156f48fd9c8SMarcel Holtmann 415733ca954dSDavid Herrmann err_wqueue: 415833ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 41596ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 416033ca954dSDavid Herrmann err: 41613df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 4162f48fd9c8SMarcel Holtmann 416333ca954dSDavid Herrmann return error; 41641da177e4SLinus Torvalds } 41651da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 41661da177e4SLinus Torvalds 41671da177e4SLinus Torvalds /* Unregister HCI device */ 416859735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 41691da177e4SLinus Torvalds { 41703df92b31SSasha Levin int i, id; 4171ef222013SMarcel Holtmann 4172c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 41731da177e4SLinus Torvalds 417494324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 417594324962SJohan Hovold 41763df92b31SSasha Levin id = hdev->id; 41773df92b31SSasha Levin 4178f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 41791da177e4SLinus Torvalds list_del(&hdev->list); 4180f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 41811da177e4SLinus Torvalds 41821da177e4SLinus Torvalds hci_dev_do_close(hdev); 41831da177e4SLinus Torvalds 4184cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 4185ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 4186ef222013SMarcel Holtmann 4187b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 4188b9b5ef18SGustavo Padovan 4189ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 4190d603b76bSMarcel Holtmann !test_bit(HCI_SETUP, &hdev->dev_flags) && 4191d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 419209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 4193744cf19eSJohan Hedberg mgmt_index_removed(hdev); 419409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 419556e5cb86SJohan Hedberg } 4196ab81cbf9SJohan Hedberg 41972e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 41982e58ef3eSJohan Hedberg * pending list */ 41992e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 42002e58ef3eSJohan Hedberg 42011da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 42021da177e4SLinus Torvalds 4203611b30f7SMarcel Holtmann if (hdev->rfkill) { 4204611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 4205611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 4206611b30f7SMarcel Holtmann } 4207611b30f7SMarcel Holtmann 4208711eafe3SJohan Hedberg smp_unregister(hdev); 420999780a7bSJohan Hedberg 4210bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 4211147e2d59SDave Young 42120153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 42130153e2ecSMarcel Holtmann 4214f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 42156ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 4216f48fd9c8SMarcel Holtmann 421709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 4218dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 42196659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 42202aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 422155ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 4222b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 4223970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 42242763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 4225dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 4226373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 422709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 4228e2e0cacbSJohan Hedberg 4229dc946bd8SDavid Herrmann hci_dev_put(hdev); 42303df92b31SSasha Levin 42313df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 42321da177e4SLinus Torvalds } 42331da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 42341da177e4SLinus Torvalds 42351da177e4SLinus Torvalds /* Suspend HCI device */ 42361da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 42371da177e4SLinus Torvalds { 42381da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 42391da177e4SLinus Torvalds return 0; 42401da177e4SLinus Torvalds } 42411da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 42421da177e4SLinus Torvalds 42431da177e4SLinus Torvalds /* Resume HCI device */ 42441da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 42451da177e4SLinus Torvalds { 42461da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 42471da177e4SLinus Torvalds return 0; 42481da177e4SLinus Torvalds } 42491da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 42501da177e4SLinus Torvalds 425175e0569fSMarcel Holtmann /* Reset HCI device */ 425275e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 425375e0569fSMarcel Holtmann { 425475e0569fSMarcel Holtmann const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 425575e0569fSMarcel Holtmann struct sk_buff *skb; 425675e0569fSMarcel Holtmann 425775e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 425875e0569fSMarcel Holtmann if (!skb) 425975e0569fSMarcel Holtmann return -ENOMEM; 426075e0569fSMarcel Holtmann 426175e0569fSMarcel Holtmann bt_cb(skb)->pkt_type = HCI_EVENT_PKT; 426275e0569fSMarcel Holtmann memcpy(skb_put(skb, 3), hw_err, 3); 426375e0569fSMarcel Holtmann 426475e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 426575e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 426675e0569fSMarcel Holtmann } 426775e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 426875e0569fSMarcel Holtmann 426976bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 4270e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 427176bca880SMarcel Holtmann { 427276bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 427376bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 427476bca880SMarcel Holtmann kfree_skb(skb); 427576bca880SMarcel Holtmann return -ENXIO; 427676bca880SMarcel Holtmann } 427776bca880SMarcel Holtmann 4278d82603c6SJorrit Schippers /* Incoming skb */ 427976bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 428076bca880SMarcel Holtmann 428176bca880SMarcel Holtmann /* Time stamp */ 428276bca880SMarcel Holtmann __net_timestamp(skb); 428376bca880SMarcel Holtmann 428476bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 4285b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 4286c78ae283SMarcel Holtmann 428776bca880SMarcel Holtmann return 0; 428876bca880SMarcel Holtmann } 428976bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 429076bca880SMarcel Holtmann 429133e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 42921e429f38SGustavo F. Padovan int count, __u8 index) 429333e882a5SSuraj Sumangala { 429433e882a5SSuraj Sumangala int len = 0; 429533e882a5SSuraj Sumangala int hlen = 0; 429633e882a5SSuraj Sumangala int remain = count; 429733e882a5SSuraj Sumangala struct sk_buff *skb; 429833e882a5SSuraj Sumangala struct bt_skb_cb *scb; 429933e882a5SSuraj Sumangala 430033e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 430133e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 430233e882a5SSuraj Sumangala return -EILSEQ; 430333e882a5SSuraj Sumangala 430433e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 430533e882a5SSuraj Sumangala 430633e882a5SSuraj Sumangala if (!skb) { 430733e882a5SSuraj Sumangala switch (type) { 430833e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 430933e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 431033e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 431133e882a5SSuraj Sumangala break; 431233e882a5SSuraj Sumangala case HCI_EVENT_PKT: 431333e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 431433e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 431533e882a5SSuraj Sumangala break; 431633e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 431733e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 431833e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 431933e882a5SSuraj Sumangala break; 432033e882a5SSuraj Sumangala } 432133e882a5SSuraj Sumangala 43221e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 432333e882a5SSuraj Sumangala if (!skb) 432433e882a5SSuraj Sumangala return -ENOMEM; 432533e882a5SSuraj Sumangala 432633e882a5SSuraj Sumangala scb = (void *) skb->cb; 432733e882a5SSuraj Sumangala scb->expect = hlen; 432833e882a5SSuraj Sumangala scb->pkt_type = type; 432933e882a5SSuraj Sumangala 433033e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 433133e882a5SSuraj Sumangala } 433233e882a5SSuraj Sumangala 433333e882a5SSuraj Sumangala while (count) { 433433e882a5SSuraj Sumangala scb = (void *) skb->cb; 433589bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 433633e882a5SSuraj Sumangala 433733e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 433833e882a5SSuraj Sumangala 433933e882a5SSuraj Sumangala count -= len; 434033e882a5SSuraj Sumangala data += len; 434133e882a5SSuraj Sumangala scb->expect -= len; 434233e882a5SSuraj Sumangala remain = count; 434333e882a5SSuraj Sumangala 434433e882a5SSuraj Sumangala switch (type) { 434533e882a5SSuraj Sumangala case HCI_EVENT_PKT: 434633e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 434733e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 434833e882a5SSuraj Sumangala scb->expect = h->plen; 434933e882a5SSuraj Sumangala 435033e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 435133e882a5SSuraj Sumangala kfree_skb(skb); 435233e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 435333e882a5SSuraj Sumangala return -ENOMEM; 435433e882a5SSuraj Sumangala } 435533e882a5SSuraj Sumangala } 435633e882a5SSuraj Sumangala break; 435733e882a5SSuraj Sumangala 435833e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 435933e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 436033e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 436133e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 436233e882a5SSuraj Sumangala 436333e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 436433e882a5SSuraj Sumangala kfree_skb(skb); 436533e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 436633e882a5SSuraj Sumangala return -ENOMEM; 436733e882a5SSuraj Sumangala } 436833e882a5SSuraj Sumangala } 436933e882a5SSuraj Sumangala break; 437033e882a5SSuraj Sumangala 437133e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 437233e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 437333e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 437433e882a5SSuraj Sumangala scb->expect = h->dlen; 437533e882a5SSuraj Sumangala 437633e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 437733e882a5SSuraj Sumangala kfree_skb(skb); 437833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 437933e882a5SSuraj Sumangala return -ENOMEM; 438033e882a5SSuraj Sumangala } 438133e882a5SSuraj Sumangala } 438233e882a5SSuraj Sumangala break; 438333e882a5SSuraj Sumangala } 438433e882a5SSuraj Sumangala 438533e882a5SSuraj Sumangala if (scb->expect == 0) { 438633e882a5SSuraj Sumangala /* Complete frame */ 438733e882a5SSuraj Sumangala 438833e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 4389e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 439033e882a5SSuraj Sumangala 439133e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 439233e882a5SSuraj Sumangala return remain; 439333e882a5SSuraj Sumangala } 439433e882a5SSuraj Sumangala } 439533e882a5SSuraj Sumangala 439633e882a5SSuraj Sumangala return remain; 439733e882a5SSuraj Sumangala } 439833e882a5SSuraj Sumangala 439999811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 440099811510SSuraj Sumangala 440199811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 440299811510SSuraj Sumangala { 440399811510SSuraj Sumangala int type; 440499811510SSuraj Sumangala int rem = 0; 440599811510SSuraj Sumangala 4406da5f6c37SGustavo F. Padovan while (count) { 440799811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 440899811510SSuraj Sumangala 440999811510SSuraj Sumangala if (!skb) { 441099811510SSuraj Sumangala struct { char type; } *pkt; 441199811510SSuraj Sumangala 441299811510SSuraj Sumangala /* Start of the frame */ 441399811510SSuraj Sumangala pkt = data; 441499811510SSuraj Sumangala type = pkt->type; 441599811510SSuraj Sumangala 441699811510SSuraj Sumangala data++; 441799811510SSuraj Sumangala count--; 441899811510SSuraj Sumangala } else 441999811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 442099811510SSuraj Sumangala 44211e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 44221e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 442399811510SSuraj Sumangala if (rem < 0) 442499811510SSuraj Sumangala return rem; 442599811510SSuraj Sumangala 442699811510SSuraj Sumangala data += (count - rem); 442799811510SSuraj Sumangala count = rem; 4428f81c6224SJoe Perches } 442999811510SSuraj Sumangala 443099811510SSuraj Sumangala return rem; 443199811510SSuraj Sumangala } 443299811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 443399811510SSuraj Sumangala 44341da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 44351da177e4SLinus Torvalds 44361da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 44371da177e4SLinus Torvalds { 44381da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 44391da177e4SLinus Torvalds 4440f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 44411da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 4442f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 44431da177e4SLinus Torvalds 44441da177e4SLinus Torvalds return 0; 44451da177e4SLinus Torvalds } 44461da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 44471da177e4SLinus Torvalds 44481da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 44491da177e4SLinus Torvalds { 44501da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 44511da177e4SLinus Torvalds 4452f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 44531da177e4SLinus Torvalds list_del(&cb->list); 4454f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 44551da177e4SLinus Torvalds 44561da177e4SLinus Torvalds return 0; 44571da177e4SLinus Torvalds } 44581da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 44591da177e4SLinus Torvalds 446051086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 44611da177e4SLinus Torvalds { 4462cdc52faaSMarcel Holtmann int err; 4463cdc52faaSMarcel Holtmann 44640d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 44651da177e4SLinus Torvalds 44661da177e4SLinus Torvalds /* Time stamp */ 4467a61bbcf2SPatrick McHardy __net_timestamp(skb); 44681da177e4SLinus Torvalds 4469cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4470cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4471cd82e61cSMarcel Holtmann 4472cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 4473cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 4474470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 44751da177e4SLinus Torvalds } 44761da177e4SLinus Torvalds 44771da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 44781da177e4SLinus Torvalds skb_orphan(skb); 44791da177e4SLinus Torvalds 4480cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 4481cdc52faaSMarcel Holtmann if (err < 0) { 4482cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 4483cdc52faaSMarcel Holtmann kfree_skb(skb); 4484cdc52faaSMarcel Holtmann } 44851da177e4SLinus Torvalds } 44861da177e4SLinus Torvalds 44873119ae95SJohan Hedberg void hci_req_init(struct hci_request *req, struct hci_dev *hdev) 44883119ae95SJohan Hedberg { 44893119ae95SJohan Hedberg skb_queue_head_init(&req->cmd_q); 44903119ae95SJohan Hedberg req->hdev = hdev; 44915d73e034SAndre Guedes req->err = 0; 44923119ae95SJohan Hedberg } 44933119ae95SJohan Hedberg 44943119ae95SJohan Hedberg int hci_req_run(struct hci_request *req, hci_req_complete_t complete) 44953119ae95SJohan Hedberg { 44963119ae95SJohan Hedberg struct hci_dev *hdev = req->hdev; 44973119ae95SJohan Hedberg struct sk_buff *skb; 44983119ae95SJohan Hedberg unsigned long flags; 44993119ae95SJohan Hedberg 45003119ae95SJohan Hedberg BT_DBG("length %u", skb_queue_len(&req->cmd_q)); 45013119ae95SJohan Hedberg 450249c922bbSStephen Hemminger /* If an error occurred during request building, remove all HCI 45035d73e034SAndre Guedes * commands queued on the HCI request queue. 45045d73e034SAndre Guedes */ 45055d73e034SAndre Guedes if (req->err) { 45065d73e034SAndre Guedes skb_queue_purge(&req->cmd_q); 45075d73e034SAndre Guedes return req->err; 45085d73e034SAndre Guedes } 45095d73e034SAndre Guedes 45103119ae95SJohan Hedberg /* Do not allow empty requests */ 45113119ae95SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 4512382b0c39SAndre Guedes return -ENODATA; 45133119ae95SJohan Hedberg 45143119ae95SJohan Hedberg skb = skb_peek_tail(&req->cmd_q); 45153119ae95SJohan Hedberg bt_cb(skb)->req.complete = complete; 45163119ae95SJohan Hedberg 45173119ae95SJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 45183119ae95SJohan Hedberg skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q); 45193119ae95SJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 45203119ae95SJohan Hedberg 45213119ae95SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 45223119ae95SJohan Hedberg 45233119ae95SJohan Hedberg return 0; 45243119ae95SJohan Hedberg } 45253119ae95SJohan Hedberg 4526899de765SMarcel Holtmann bool hci_req_pending(struct hci_dev *hdev) 4527899de765SMarcel Holtmann { 4528899de765SMarcel Holtmann return (hdev->req_status == HCI_REQ_PEND); 4529899de765SMarcel Holtmann } 4530899de765SMarcel Holtmann 45311ca3a9d0SJohan Hedberg static struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, 453207dc93ddSJohan Hedberg u32 plen, const void *param) 45331da177e4SLinus Torvalds { 45341da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 45351da177e4SLinus Torvalds struct hci_command_hdr *hdr; 45361da177e4SLinus Torvalds struct sk_buff *skb; 45371da177e4SLinus Torvalds 45381da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 45391ca3a9d0SJohan Hedberg if (!skb) 45401ca3a9d0SJohan Hedberg return NULL; 45411da177e4SLinus Torvalds 45421da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 4543a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 45441da177e4SLinus Torvalds hdr->plen = plen; 45451da177e4SLinus Torvalds 45461da177e4SLinus Torvalds if (plen) 45471da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 45481da177e4SLinus Torvalds 45491da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 45501da177e4SLinus Torvalds 45510d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 455243e73e4eSMarcel Holtmann bt_cb(skb)->opcode = opcode; 4553c78ae283SMarcel Holtmann 45541ca3a9d0SJohan Hedberg return skb; 45551ca3a9d0SJohan Hedberg } 45561ca3a9d0SJohan Hedberg 45571ca3a9d0SJohan Hedberg /* Send HCI command */ 455807dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 455907dc93ddSJohan Hedberg const void *param) 45601ca3a9d0SJohan Hedberg { 45611ca3a9d0SJohan Hedberg struct sk_buff *skb; 45621ca3a9d0SJohan Hedberg 45631ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 45641ca3a9d0SJohan Hedberg 45651ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 45661ca3a9d0SJohan Hedberg if (!skb) { 45671ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 45681ca3a9d0SJohan Hedberg return -ENOMEM; 45691ca3a9d0SJohan Hedberg } 45701ca3a9d0SJohan Hedberg 457149c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 457211714b3dSJohan Hedberg * single-command requests. 457311714b3dSJohan Hedberg */ 457411714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 457511714b3dSJohan Hedberg 45761da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 4577c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 45781da177e4SLinus Torvalds 45791da177e4SLinus Torvalds return 0; 45801da177e4SLinus Torvalds } 45811da177e4SLinus Torvalds 458271c76a17SJohan Hedberg /* Queue a command to an asynchronous HCI request */ 458307dc93ddSJohan Hedberg void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen, 458407dc93ddSJohan Hedberg const void *param, u8 event) 458571c76a17SJohan Hedberg { 458671c76a17SJohan Hedberg struct hci_dev *hdev = req->hdev; 458771c76a17SJohan Hedberg struct sk_buff *skb; 458871c76a17SJohan Hedberg 458971c76a17SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 459071c76a17SJohan Hedberg 459149c922bbSStephen Hemminger /* If an error occurred during request building, there is no point in 459234739c1eSAndre Guedes * queueing the HCI command. We can simply return. 459334739c1eSAndre Guedes */ 459434739c1eSAndre Guedes if (req->err) 459534739c1eSAndre Guedes return; 459634739c1eSAndre Guedes 459771c76a17SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 459871c76a17SJohan Hedberg if (!skb) { 45995d73e034SAndre Guedes BT_ERR("%s no memory for command (opcode 0x%4.4x)", 46005d73e034SAndre Guedes hdev->name, opcode); 46015d73e034SAndre Guedes req->err = -ENOMEM; 4602e348fe6bSAndre Guedes return; 460371c76a17SJohan Hedberg } 460471c76a17SJohan Hedberg 460571c76a17SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 460671c76a17SJohan Hedberg bt_cb(skb)->req.start = true; 460771c76a17SJohan Hedberg 460802350a72SJohan Hedberg bt_cb(skb)->req.event = event; 460902350a72SJohan Hedberg 461071c76a17SJohan Hedberg skb_queue_tail(&req->cmd_q, skb); 461171c76a17SJohan Hedberg } 461271c76a17SJohan Hedberg 461307dc93ddSJohan Hedberg void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, 461407dc93ddSJohan Hedberg const void *param) 461502350a72SJohan Hedberg { 461602350a72SJohan Hedberg hci_req_add_ev(req, opcode, plen, param, 0); 461702350a72SJohan Hedberg } 461802350a72SJohan Hedberg 46191da177e4SLinus Torvalds /* Get data from the previously sent command */ 4620a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 46211da177e4SLinus Torvalds { 46221da177e4SLinus Torvalds struct hci_command_hdr *hdr; 46231da177e4SLinus Torvalds 46241da177e4SLinus Torvalds if (!hdev->sent_cmd) 46251da177e4SLinus Torvalds return NULL; 46261da177e4SLinus Torvalds 46271da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 46281da177e4SLinus Torvalds 4629a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 46301da177e4SLinus Torvalds return NULL; 46311da177e4SLinus Torvalds 4632f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 46331da177e4SLinus Torvalds 46341da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 46351da177e4SLinus Torvalds } 46361da177e4SLinus Torvalds 46371da177e4SLinus Torvalds /* Send ACL data */ 46381da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 46391da177e4SLinus Torvalds { 46401da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 46411da177e4SLinus Torvalds int len = skb->len; 46421da177e4SLinus Torvalds 4643badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 4644badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 46459c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 4646aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 4647aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 46481da177e4SLinus Torvalds } 46491da177e4SLinus Torvalds 4650ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 465173d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 46521da177e4SLinus Torvalds { 4653ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 46541da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 46551da177e4SLinus Torvalds struct sk_buff *list; 46561da177e4SLinus Torvalds 4657087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 4658087bfd99SGustavo Padovan skb->data_len = 0; 4659087bfd99SGustavo Padovan 4660087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4661204a6e54SAndrei Emeltchenko 4662204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 4663204a6e54SAndrei Emeltchenko case HCI_BREDR: 4664087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 4665204a6e54SAndrei Emeltchenko break; 4666204a6e54SAndrei Emeltchenko case HCI_AMP: 4667204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 4668204a6e54SAndrei Emeltchenko break; 4669204a6e54SAndrei Emeltchenko default: 4670204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 4671204a6e54SAndrei Emeltchenko return; 4672204a6e54SAndrei Emeltchenko } 4673087bfd99SGustavo Padovan 467470f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 467570f23020SAndrei Emeltchenko if (!list) { 46761da177e4SLinus Torvalds /* Non fragmented */ 46771da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 46781da177e4SLinus Torvalds 467973d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 46801da177e4SLinus Torvalds } else { 46811da177e4SLinus Torvalds /* Fragmented */ 46821da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 46831da177e4SLinus Torvalds 46841da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 46851da177e4SLinus Torvalds 46869cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 46879cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 46889cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 46899cfd5a23SJukka Rissanen * deadlocks. 46909cfd5a23SJukka Rissanen */ 46919cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 46921da177e4SLinus Torvalds 469373d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 4694e702112fSAndrei Emeltchenko 4695e702112fSAndrei Emeltchenko flags &= ~ACL_START; 4696e702112fSAndrei Emeltchenko flags |= ACL_CONT; 46971da177e4SLinus Torvalds do { 46981da177e4SLinus Torvalds skb = list; list = list->next; 46991da177e4SLinus Torvalds 47000d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4701e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 47021da177e4SLinus Torvalds 47031da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 47041da177e4SLinus Torvalds 470573d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 47061da177e4SLinus Torvalds } while (list); 47071da177e4SLinus Torvalds 47089cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 47091da177e4SLinus Torvalds } 471073d80debSLuiz Augusto von Dentz } 471173d80debSLuiz Augusto von Dentz 471273d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 471373d80debSLuiz Augusto von Dentz { 4714ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 471573d80debSLuiz Augusto von Dentz 4716f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 471773d80debSLuiz Augusto von Dentz 4718ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 47191da177e4SLinus Torvalds 47203eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 47211da177e4SLinus Torvalds } 47221da177e4SLinus Torvalds 47231da177e4SLinus Torvalds /* Send SCO data */ 47240d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 47251da177e4SLinus Torvalds { 47261da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 47271da177e4SLinus Torvalds struct hci_sco_hdr hdr; 47281da177e4SLinus Torvalds 47291da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 47301da177e4SLinus Torvalds 4731aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 47321da177e4SLinus Torvalds hdr.dlen = skb->len; 47331da177e4SLinus Torvalds 4734badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 4735badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 47369c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 47371da177e4SLinus Torvalds 47380d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 4739c78ae283SMarcel Holtmann 47401da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 47413eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 47421da177e4SLinus Torvalds } 47431da177e4SLinus Torvalds 47441da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 47451da177e4SLinus Torvalds 47461da177e4SLinus Torvalds /* HCI Connection scheduler */ 47476039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 4748a8c5fb1aSGustavo Padovan int *quote) 47491da177e4SLinus Torvalds { 47501da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 47518035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 4752abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 47531da177e4SLinus Torvalds 47541da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 47551da177e4SLinus Torvalds * added and removed with TX task disabled. */ 4756bf4c6325SGustavo F. Padovan 4757bf4c6325SGustavo F. Padovan rcu_read_lock(); 4758bf4c6325SGustavo F. Padovan 4759bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4760769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 47611da177e4SLinus Torvalds continue; 4762769be974SMarcel Holtmann 4763769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 4764769be974SMarcel Holtmann continue; 4765769be974SMarcel Holtmann 47661da177e4SLinus Torvalds num++; 47671da177e4SLinus Torvalds 47681da177e4SLinus Torvalds if (c->sent < min) { 47691da177e4SLinus Torvalds min = c->sent; 47701da177e4SLinus Torvalds conn = c; 47711da177e4SLinus Torvalds } 477252087a79SLuiz Augusto von Dentz 477352087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 477452087a79SLuiz Augusto von Dentz break; 47751da177e4SLinus Torvalds } 47761da177e4SLinus Torvalds 4777bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4778bf4c6325SGustavo F. Padovan 47791da177e4SLinus Torvalds if (conn) { 47806ed58ec5SVille Tervo int cnt, q; 47816ed58ec5SVille Tervo 47826ed58ec5SVille Tervo switch (conn->type) { 47836ed58ec5SVille Tervo case ACL_LINK: 47846ed58ec5SVille Tervo cnt = hdev->acl_cnt; 47856ed58ec5SVille Tervo break; 47866ed58ec5SVille Tervo case SCO_LINK: 47876ed58ec5SVille Tervo case ESCO_LINK: 47886ed58ec5SVille Tervo cnt = hdev->sco_cnt; 47896ed58ec5SVille Tervo break; 47906ed58ec5SVille Tervo case LE_LINK: 47916ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 47926ed58ec5SVille Tervo break; 47936ed58ec5SVille Tervo default: 47946ed58ec5SVille Tervo cnt = 0; 47956ed58ec5SVille Tervo BT_ERR("Unknown link type"); 47966ed58ec5SVille Tervo } 47976ed58ec5SVille Tervo 47986ed58ec5SVille Tervo q = cnt / num; 47991da177e4SLinus Torvalds *quote = q ? q : 1; 48001da177e4SLinus Torvalds } else 48011da177e4SLinus Torvalds *quote = 0; 48021da177e4SLinus Torvalds 48031da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 48041da177e4SLinus Torvalds return conn; 48051da177e4SLinus Torvalds } 48061da177e4SLinus Torvalds 48076039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 48081da177e4SLinus Torvalds { 48091da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 48101da177e4SLinus Torvalds struct hci_conn *c; 48111da177e4SLinus Torvalds 4812bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 48131da177e4SLinus Torvalds 4814bf4c6325SGustavo F. Padovan rcu_read_lock(); 4815bf4c6325SGustavo F. Padovan 48161da177e4SLinus Torvalds /* Kill stalled connections */ 4817bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4818bae1f5d9SVille Tervo if (c->type == type && c->sent) { 48196ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 48206ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 4821bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 48221da177e4SLinus Torvalds } 48231da177e4SLinus Torvalds } 4824bf4c6325SGustavo F. Padovan 4825bf4c6325SGustavo F. Padovan rcu_read_unlock(); 48261da177e4SLinus Torvalds } 48271da177e4SLinus Torvalds 48286039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 482973d80debSLuiz Augusto von Dentz int *quote) 483073d80debSLuiz Augusto von Dentz { 483173d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 483273d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 4833abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 483473d80debSLuiz Augusto von Dentz struct hci_conn *conn; 483573d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 483673d80debSLuiz Augusto von Dentz 483773d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 483873d80debSLuiz Augusto von Dentz 4839bf4c6325SGustavo F. Padovan rcu_read_lock(); 4840bf4c6325SGustavo F. Padovan 4841bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 484273d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 484373d80debSLuiz Augusto von Dentz 484473d80debSLuiz Augusto von Dentz if (conn->type != type) 484573d80debSLuiz Augusto von Dentz continue; 484673d80debSLuiz Augusto von Dentz 484773d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 484873d80debSLuiz Augusto von Dentz continue; 484973d80debSLuiz Augusto von Dentz 485073d80debSLuiz Augusto von Dentz conn_num++; 485173d80debSLuiz Augusto von Dentz 48528192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 485373d80debSLuiz Augusto von Dentz struct sk_buff *skb; 485473d80debSLuiz Augusto von Dentz 485573d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 485673d80debSLuiz Augusto von Dentz continue; 485773d80debSLuiz Augusto von Dentz 485873d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 485973d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 486073d80debSLuiz Augusto von Dentz continue; 486173d80debSLuiz Augusto von Dentz 486273d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 486373d80debSLuiz Augusto von Dentz num = 0; 486473d80debSLuiz Augusto von Dentz min = ~0; 486573d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 486673d80debSLuiz Augusto von Dentz } 486773d80debSLuiz Augusto von Dentz 486873d80debSLuiz Augusto von Dentz num++; 486973d80debSLuiz Augusto von Dentz 487073d80debSLuiz Augusto von Dentz if (conn->sent < min) { 487173d80debSLuiz Augusto von Dentz min = conn->sent; 487273d80debSLuiz Augusto von Dentz chan = tmp; 487373d80debSLuiz Augusto von Dentz } 487473d80debSLuiz Augusto von Dentz } 487573d80debSLuiz Augusto von Dentz 487673d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 487773d80debSLuiz Augusto von Dentz break; 487873d80debSLuiz Augusto von Dentz } 487973d80debSLuiz Augusto von Dentz 4880bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4881bf4c6325SGustavo F. Padovan 488273d80debSLuiz Augusto von Dentz if (!chan) 488373d80debSLuiz Augusto von Dentz return NULL; 488473d80debSLuiz Augusto von Dentz 488573d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 488673d80debSLuiz Augusto von Dentz case ACL_LINK: 488773d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 488873d80debSLuiz Augusto von Dentz break; 4889bd1eb66bSAndrei Emeltchenko case AMP_LINK: 4890bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 4891bd1eb66bSAndrei Emeltchenko break; 489273d80debSLuiz Augusto von Dentz case SCO_LINK: 489373d80debSLuiz Augusto von Dentz case ESCO_LINK: 489473d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 489573d80debSLuiz Augusto von Dentz break; 489673d80debSLuiz Augusto von Dentz case LE_LINK: 489773d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 489873d80debSLuiz Augusto von Dentz break; 489973d80debSLuiz Augusto von Dentz default: 490073d80debSLuiz Augusto von Dentz cnt = 0; 490173d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 490273d80debSLuiz Augusto von Dentz } 490373d80debSLuiz Augusto von Dentz 490473d80debSLuiz Augusto von Dentz q = cnt / num; 490573d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 490673d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 490773d80debSLuiz Augusto von Dentz return chan; 490873d80debSLuiz Augusto von Dentz } 490973d80debSLuiz Augusto von Dentz 491002b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 491102b20f0bSLuiz Augusto von Dentz { 491202b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 491302b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 491402b20f0bSLuiz Augusto von Dentz int num = 0; 491502b20f0bSLuiz Augusto von Dentz 491602b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 491702b20f0bSLuiz Augusto von Dentz 4918bf4c6325SGustavo F. Padovan rcu_read_lock(); 4919bf4c6325SGustavo F. Padovan 4920bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 492102b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 492202b20f0bSLuiz Augusto von Dentz 492302b20f0bSLuiz Augusto von Dentz if (conn->type != type) 492402b20f0bSLuiz Augusto von Dentz continue; 492502b20f0bSLuiz Augusto von Dentz 492602b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 492702b20f0bSLuiz Augusto von Dentz continue; 492802b20f0bSLuiz Augusto von Dentz 492902b20f0bSLuiz Augusto von Dentz num++; 493002b20f0bSLuiz Augusto von Dentz 49318192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 493202b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 493302b20f0bSLuiz Augusto von Dentz 493402b20f0bSLuiz Augusto von Dentz if (chan->sent) { 493502b20f0bSLuiz Augusto von Dentz chan->sent = 0; 493602b20f0bSLuiz Augusto von Dentz continue; 493702b20f0bSLuiz Augusto von Dentz } 493802b20f0bSLuiz Augusto von Dentz 493902b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 494002b20f0bSLuiz Augusto von Dentz continue; 494102b20f0bSLuiz Augusto von Dentz 494202b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 494302b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 494402b20f0bSLuiz Augusto von Dentz continue; 494502b20f0bSLuiz Augusto von Dentz 494602b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 494702b20f0bSLuiz Augusto von Dentz 494802b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 494902b20f0bSLuiz Augusto von Dentz skb->priority); 495002b20f0bSLuiz Augusto von Dentz } 495102b20f0bSLuiz Augusto von Dentz 495202b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 495302b20f0bSLuiz Augusto von Dentz break; 495402b20f0bSLuiz Augusto von Dentz } 4955bf4c6325SGustavo F. Padovan 4956bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4957bf4c6325SGustavo F. Padovan 495802b20f0bSLuiz Augusto von Dentz } 495902b20f0bSLuiz Augusto von Dentz 4960b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 4961b71d385aSAndrei Emeltchenko { 4962b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 4963b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 4964b71d385aSAndrei Emeltchenko } 4965b71d385aSAndrei Emeltchenko 49666039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 49671da177e4SLinus Torvalds { 49684a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 49691da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 49701da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 497163d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 49725f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 4973bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 49741da177e4SLinus Torvalds } 497563d2bc1bSAndrei Emeltchenko } 49761da177e4SLinus Torvalds 49776039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 497863d2bc1bSAndrei Emeltchenko { 497963d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 498063d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 498163d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 498263d2bc1bSAndrei Emeltchenko int quote; 498363d2bc1bSAndrei Emeltchenko 498463d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 498504837f64SMarcel Holtmann 498673d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 498773d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 4988ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4989ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 499073d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 499173d80debSLuiz Augusto von Dentz skb->len, skb->priority); 499273d80debSLuiz Augusto von Dentz 4993ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4994ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4995ec1cce24SLuiz Augusto von Dentz break; 4996ec1cce24SLuiz Augusto von Dentz 4997ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4998ec1cce24SLuiz Augusto von Dentz 499973d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 500073d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 500104837f64SMarcel Holtmann 500257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 50031da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 50041da177e4SLinus Torvalds 50051da177e4SLinus Torvalds hdev->acl_cnt--; 500673d80debSLuiz Augusto von Dentz chan->sent++; 500773d80debSLuiz Augusto von Dentz chan->conn->sent++; 50081da177e4SLinus Torvalds } 50091da177e4SLinus Torvalds } 501002b20f0bSLuiz Augusto von Dentz 501102b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 501202b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 50131da177e4SLinus Torvalds } 50141da177e4SLinus Torvalds 50156039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 5016b71d385aSAndrei Emeltchenko { 501763d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 5018b71d385aSAndrei Emeltchenko struct hci_chan *chan; 5019b71d385aSAndrei Emeltchenko struct sk_buff *skb; 5020b71d385aSAndrei Emeltchenko int quote; 5021bd1eb66bSAndrei Emeltchenko u8 type; 5022b71d385aSAndrei Emeltchenko 502363d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 5024b71d385aSAndrei Emeltchenko 5025bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 5026bd1eb66bSAndrei Emeltchenko 5027bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 5028bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 5029bd1eb66bSAndrei Emeltchenko else 5030bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 5031bd1eb66bSAndrei Emeltchenko 5032b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 5033bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 5034b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 5035b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 5036b71d385aSAndrei Emeltchenko int blocks; 5037b71d385aSAndrei Emeltchenko 5038b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 5039b71d385aSAndrei Emeltchenko skb->len, skb->priority); 5040b71d385aSAndrei Emeltchenko 5041b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 5042b71d385aSAndrei Emeltchenko if (skb->priority < priority) 5043b71d385aSAndrei Emeltchenko break; 5044b71d385aSAndrei Emeltchenko 5045b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 5046b71d385aSAndrei Emeltchenko 5047b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 5048b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 5049b71d385aSAndrei Emeltchenko return; 5050b71d385aSAndrei Emeltchenko 5051b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 5052b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 5053b71d385aSAndrei Emeltchenko 505457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 5055b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 5056b71d385aSAndrei Emeltchenko 5057b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 5058b71d385aSAndrei Emeltchenko quote -= blocks; 5059b71d385aSAndrei Emeltchenko 5060b71d385aSAndrei Emeltchenko chan->sent += blocks; 5061b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 5062b71d385aSAndrei Emeltchenko } 5063b71d385aSAndrei Emeltchenko } 5064b71d385aSAndrei Emeltchenko 5065b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 5066bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 5067b71d385aSAndrei Emeltchenko } 5068b71d385aSAndrei Emeltchenko 50696039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 5070b71d385aSAndrei Emeltchenko { 5071b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 5072b71d385aSAndrei Emeltchenko 5073bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 5074bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 5075bd1eb66bSAndrei Emeltchenko return; 5076bd1eb66bSAndrei Emeltchenko 5077bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 5078bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 5079b71d385aSAndrei Emeltchenko return; 5080b71d385aSAndrei Emeltchenko 5081b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 5082b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 5083b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 5084b71d385aSAndrei Emeltchenko break; 5085b71d385aSAndrei Emeltchenko 5086b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 5087b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 5088b71d385aSAndrei Emeltchenko break; 5089b71d385aSAndrei Emeltchenko } 5090b71d385aSAndrei Emeltchenko } 5091b71d385aSAndrei Emeltchenko 50921da177e4SLinus Torvalds /* Schedule SCO */ 50936039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 50941da177e4SLinus Torvalds { 50951da177e4SLinus Torvalds struct hci_conn *conn; 50961da177e4SLinus Torvalds struct sk_buff *skb; 50971da177e4SLinus Torvalds int quote; 50981da177e4SLinus Torvalds 50991da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 51001da177e4SLinus Torvalds 510152087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 510252087a79SLuiz Augusto von Dentz return; 510352087a79SLuiz Augusto von Dentz 51041da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 51051da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 51061da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 510757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 51081da177e4SLinus Torvalds 51091da177e4SLinus Torvalds conn->sent++; 51101da177e4SLinus Torvalds if (conn->sent == ~0) 51111da177e4SLinus Torvalds conn->sent = 0; 51121da177e4SLinus Torvalds } 51131da177e4SLinus Torvalds } 51141da177e4SLinus Torvalds } 51151da177e4SLinus Torvalds 51166039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 5117b6a0dc82SMarcel Holtmann { 5118b6a0dc82SMarcel Holtmann struct hci_conn *conn; 5119b6a0dc82SMarcel Holtmann struct sk_buff *skb; 5120b6a0dc82SMarcel Holtmann int quote; 5121b6a0dc82SMarcel Holtmann 5122b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 5123b6a0dc82SMarcel Holtmann 512452087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 512552087a79SLuiz Augusto von Dentz return; 512652087a79SLuiz Augusto von Dentz 51278fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 51288fc9ced3SGustavo Padovan "e))) { 5129b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 5130b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 513157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 5132b6a0dc82SMarcel Holtmann 5133b6a0dc82SMarcel Holtmann conn->sent++; 5134b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 5135b6a0dc82SMarcel Holtmann conn->sent = 0; 5136b6a0dc82SMarcel Holtmann } 5137b6a0dc82SMarcel Holtmann } 5138b6a0dc82SMarcel Holtmann } 5139b6a0dc82SMarcel Holtmann 51406039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 51416ed58ec5SVille Tervo { 514273d80debSLuiz Augusto von Dentz struct hci_chan *chan; 51436ed58ec5SVille Tervo struct sk_buff *skb; 514402b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 51456ed58ec5SVille Tervo 51466ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 51476ed58ec5SVille Tervo 514852087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 514952087a79SLuiz Augusto von Dentz return; 515052087a79SLuiz Augusto von Dentz 51514a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 51526ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 51536ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 5154bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 51556ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 5156bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 51576ed58ec5SVille Tervo } 51586ed58ec5SVille Tervo 51596ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 516002b20f0bSLuiz Augusto von Dentz tmp = cnt; 516173d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 5162ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 5163ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 516473d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 516573d80debSLuiz Augusto von Dentz skb->len, skb->priority); 51666ed58ec5SVille Tervo 5167ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 5168ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 5169ec1cce24SLuiz Augusto von Dentz break; 5170ec1cce24SLuiz Augusto von Dentz 5171ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 5172ec1cce24SLuiz Augusto von Dentz 517357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 51746ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 51756ed58ec5SVille Tervo 51766ed58ec5SVille Tervo cnt--; 517773d80debSLuiz Augusto von Dentz chan->sent++; 517873d80debSLuiz Augusto von Dentz chan->conn->sent++; 51796ed58ec5SVille Tervo } 51806ed58ec5SVille Tervo } 518173d80debSLuiz Augusto von Dentz 51826ed58ec5SVille Tervo if (hdev->le_pkts) 51836ed58ec5SVille Tervo hdev->le_cnt = cnt; 51846ed58ec5SVille Tervo else 51856ed58ec5SVille Tervo hdev->acl_cnt = cnt; 518602b20f0bSLuiz Augusto von Dentz 518702b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 518802b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 51896ed58ec5SVille Tervo } 51906ed58ec5SVille Tervo 51913eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 51921da177e4SLinus Torvalds { 51933eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 51941da177e4SLinus Torvalds struct sk_buff *skb; 51951da177e4SLinus Torvalds 51966ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 51976ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 51981da177e4SLinus Torvalds 519952de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 52001da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 52011da177e4SLinus Torvalds hci_sched_acl(hdev); 52021da177e4SLinus Torvalds hci_sched_sco(hdev); 5203b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 52046ed58ec5SVille Tervo hci_sched_le(hdev); 520552de599eSMarcel Holtmann } 52066ed58ec5SVille Tervo 52071da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 52081da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 520957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 52101da177e4SLinus Torvalds } 52111da177e4SLinus Torvalds 521225985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 52131da177e4SLinus Torvalds 52141da177e4SLinus Torvalds /* ACL data packet */ 52156039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 52161da177e4SLinus Torvalds { 52171da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 52181da177e4SLinus Torvalds struct hci_conn *conn; 52191da177e4SLinus Torvalds __u16 handle, flags; 52201da177e4SLinus Torvalds 52211da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 52221da177e4SLinus Torvalds 52231da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 52241da177e4SLinus Torvalds flags = hci_flags(handle); 52251da177e4SLinus Torvalds handle = hci_handle(handle); 52261da177e4SLinus Torvalds 5227f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 5228a8c5fb1aSGustavo Padovan handle, flags); 52291da177e4SLinus Torvalds 52301da177e4SLinus Torvalds hdev->stat.acl_rx++; 52311da177e4SLinus Torvalds 52321da177e4SLinus Torvalds hci_dev_lock(hdev); 52331da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 52341da177e4SLinus Torvalds hci_dev_unlock(hdev); 52351da177e4SLinus Torvalds 52361da177e4SLinus Torvalds if (conn) { 523765983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 523804837f64SMarcel Holtmann 52391da177e4SLinus Torvalds /* Send to upper protocol */ 5240686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 52411da177e4SLinus Torvalds return; 52421da177e4SLinus Torvalds } else { 52431da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 52441da177e4SLinus Torvalds hdev->name, handle); 52451da177e4SLinus Torvalds } 52461da177e4SLinus Torvalds 52471da177e4SLinus Torvalds kfree_skb(skb); 52481da177e4SLinus Torvalds } 52491da177e4SLinus Torvalds 52501da177e4SLinus Torvalds /* SCO data packet */ 52516039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 52521da177e4SLinus Torvalds { 52531da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 52541da177e4SLinus Torvalds struct hci_conn *conn; 52551da177e4SLinus Torvalds __u16 handle; 52561da177e4SLinus Torvalds 52571da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 52581da177e4SLinus Torvalds 52591da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 52601da177e4SLinus Torvalds 5261f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 52621da177e4SLinus Torvalds 52631da177e4SLinus Torvalds hdev->stat.sco_rx++; 52641da177e4SLinus Torvalds 52651da177e4SLinus Torvalds hci_dev_lock(hdev); 52661da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 52671da177e4SLinus Torvalds hci_dev_unlock(hdev); 52681da177e4SLinus Torvalds 52691da177e4SLinus Torvalds if (conn) { 52701da177e4SLinus Torvalds /* Send to upper protocol */ 5271686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 52721da177e4SLinus Torvalds return; 52731da177e4SLinus Torvalds } else { 52741da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 52751da177e4SLinus Torvalds hdev->name, handle); 52761da177e4SLinus Torvalds } 52771da177e4SLinus Torvalds 52781da177e4SLinus Torvalds kfree_skb(skb); 52791da177e4SLinus Torvalds } 52801da177e4SLinus Torvalds 52819238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 52829238f36aSJohan Hedberg { 52839238f36aSJohan Hedberg struct sk_buff *skb; 52849238f36aSJohan Hedberg 52859238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 52869238f36aSJohan Hedberg if (!skb) 52879238f36aSJohan Hedberg return true; 52889238f36aSJohan Hedberg 52899238f36aSJohan Hedberg return bt_cb(skb)->req.start; 52909238f36aSJohan Hedberg } 52919238f36aSJohan Hedberg 529242c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 529342c6b129SJohan Hedberg { 529442c6b129SJohan Hedberg struct hci_command_hdr *sent; 529542c6b129SJohan Hedberg struct sk_buff *skb; 529642c6b129SJohan Hedberg u16 opcode; 529742c6b129SJohan Hedberg 529842c6b129SJohan Hedberg if (!hdev->sent_cmd) 529942c6b129SJohan Hedberg return; 530042c6b129SJohan Hedberg 530142c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 530242c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 530342c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 530442c6b129SJohan Hedberg return; 530542c6b129SJohan Hedberg 530642c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 530742c6b129SJohan Hedberg if (!skb) 530842c6b129SJohan Hedberg return; 530942c6b129SJohan Hedberg 531042c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 531142c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 531242c6b129SJohan Hedberg } 531342c6b129SJohan Hedberg 53149238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 53159238f36aSJohan Hedberg { 53169238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 53179238f36aSJohan Hedberg struct sk_buff *skb; 53189238f36aSJohan Hedberg unsigned long flags; 53199238f36aSJohan Hedberg 53209238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 53219238f36aSJohan Hedberg 532242c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 532342c6b129SJohan Hedberg * sent we need to do special handling of it. 53249238f36aSJohan Hedberg */ 532542c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 532642c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 532742c6b129SJohan Hedberg * reset complete event during init and any pending 532842c6b129SJohan Hedberg * command will never be completed. In such a case we 532942c6b129SJohan Hedberg * need to resend whatever was the last sent 533042c6b129SJohan Hedberg * command. 533142c6b129SJohan Hedberg */ 533242c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 533342c6b129SJohan Hedberg hci_resend_last(hdev); 533442c6b129SJohan Hedberg 53359238f36aSJohan Hedberg return; 533642c6b129SJohan Hedberg } 53379238f36aSJohan Hedberg 53389238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 53399238f36aSJohan Hedberg * this request the request is not yet complete. 53409238f36aSJohan Hedberg */ 53419238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 53429238f36aSJohan Hedberg return; 53439238f36aSJohan Hedberg 53449238f36aSJohan Hedberg /* If this was the last command in a request the complete 53459238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 53469238f36aSJohan Hedberg * command queue (hdev->cmd_q). 53479238f36aSJohan Hedberg */ 53489238f36aSJohan Hedberg if (hdev->sent_cmd) { 53499238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 535053e21fbcSJohan Hedberg 535153e21fbcSJohan Hedberg if (req_complete) { 535253e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 535353e21fbcSJohan Hedberg * avoid calling the callback more than once if 535453e21fbcSJohan Hedberg * this function gets called again. 535553e21fbcSJohan Hedberg */ 535653e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 535753e21fbcSJohan Hedberg 53589238f36aSJohan Hedberg goto call_complete; 53599238f36aSJohan Hedberg } 536053e21fbcSJohan Hedberg } 53619238f36aSJohan Hedberg 53629238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 53639238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 53649238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 53659238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 53669238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 53679238f36aSJohan Hedberg break; 53689238f36aSJohan Hedberg } 53699238f36aSJohan Hedberg 53709238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 53719238f36aSJohan Hedberg kfree_skb(skb); 53729238f36aSJohan Hedberg } 53739238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 53749238f36aSJohan Hedberg 53759238f36aSJohan Hedberg call_complete: 53769238f36aSJohan Hedberg if (req_complete) 53779238f36aSJohan Hedberg req_complete(hdev, status); 53789238f36aSJohan Hedberg } 53799238f36aSJohan Hedberg 5380b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 53811da177e4SLinus Torvalds { 5382b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 53831da177e4SLinus Torvalds struct sk_buff *skb; 53841da177e4SLinus Torvalds 53851da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 53861da177e4SLinus Torvalds 53871da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 5388cd82e61cSMarcel Holtmann /* Send copy to monitor */ 5389cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 5390cd82e61cSMarcel Holtmann 53911da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 53921da177e4SLinus Torvalds /* Send copy to the sockets */ 5393470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 53941da177e4SLinus Torvalds } 53951da177e4SLinus Torvalds 5396fee746b0SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 53971da177e4SLinus Torvalds kfree_skb(skb); 53981da177e4SLinus Torvalds continue; 53991da177e4SLinus Torvalds } 54001da177e4SLinus Torvalds 54011da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 54021da177e4SLinus Torvalds /* Don't process data packets in this states. */ 54030d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 54041da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 54051da177e4SLinus Torvalds case HCI_SCODATA_PKT: 54061da177e4SLinus Torvalds kfree_skb(skb); 54071da177e4SLinus Torvalds continue; 54083ff50b79SStephen Hemminger } 54091da177e4SLinus Torvalds } 54101da177e4SLinus Torvalds 54111da177e4SLinus Torvalds /* Process frame */ 54120d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 54131da177e4SLinus Torvalds case HCI_EVENT_PKT: 5414b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 54151da177e4SLinus Torvalds hci_event_packet(hdev, skb); 54161da177e4SLinus Torvalds break; 54171da177e4SLinus Torvalds 54181da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 54191da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 54201da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 54211da177e4SLinus Torvalds break; 54221da177e4SLinus Torvalds 54231da177e4SLinus Torvalds case HCI_SCODATA_PKT: 54241da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 54251da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 54261da177e4SLinus Torvalds break; 54271da177e4SLinus Torvalds 54281da177e4SLinus Torvalds default: 54291da177e4SLinus Torvalds kfree_skb(skb); 54301da177e4SLinus Torvalds break; 54311da177e4SLinus Torvalds } 54321da177e4SLinus Torvalds } 54331da177e4SLinus Torvalds } 54341da177e4SLinus Torvalds 5435c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 54361da177e4SLinus Torvalds { 5437c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 54381da177e4SLinus Torvalds struct sk_buff *skb; 54391da177e4SLinus Torvalds 54402104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 54412104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 54421da177e4SLinus Torvalds 54431da177e4SLinus Torvalds /* Send queued commands */ 54445a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 54455a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 54465a08ecceSAndrei Emeltchenko if (!skb) 54475a08ecceSAndrei Emeltchenko return; 54485a08ecceSAndrei Emeltchenko 54491da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 54501da177e4SLinus Torvalds 5451a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 545270f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 54531da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 545457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 54557bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 545665cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 54577bdb8a5cSSzymon Janc else 545865cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 545965cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 54601da177e4SLinus Torvalds } else { 54611da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 5462c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 54631da177e4SLinus Torvalds } 54641da177e4SLinus Torvalds } 54651da177e4SLinus Torvalds } 5466b1efcc28SAndre Guedes 5467b1efcc28SAndre Guedes void hci_req_add_le_scan_disable(struct hci_request *req) 5468b1efcc28SAndre Guedes { 5469b1efcc28SAndre Guedes struct hci_cp_le_set_scan_enable cp; 5470b1efcc28SAndre Guedes 5471b1efcc28SAndre Guedes memset(&cp, 0, sizeof(cp)); 5472b1efcc28SAndre Guedes cp.enable = LE_SCAN_DISABLE; 5473b1efcc28SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 5474b1efcc28SAndre Guedes } 5475a4790dbdSAndre Guedes 54768540f6c0SMarcel Holtmann static void add_to_white_list(struct hci_request *req, 54778540f6c0SMarcel Holtmann struct hci_conn_params *params) 54788540f6c0SMarcel Holtmann { 54798540f6c0SMarcel Holtmann struct hci_cp_le_add_to_white_list cp; 54808540f6c0SMarcel Holtmann 54818540f6c0SMarcel Holtmann cp.bdaddr_type = params->addr_type; 54828540f6c0SMarcel Holtmann bacpy(&cp.bdaddr, ¶ms->addr); 54838540f6c0SMarcel Holtmann 54848540f6c0SMarcel Holtmann hci_req_add(req, HCI_OP_LE_ADD_TO_WHITE_LIST, sizeof(cp), &cp); 54858540f6c0SMarcel Holtmann } 54868540f6c0SMarcel Holtmann 54878540f6c0SMarcel Holtmann static u8 update_white_list(struct hci_request *req) 54888540f6c0SMarcel Holtmann { 54898540f6c0SMarcel Holtmann struct hci_dev *hdev = req->hdev; 54908540f6c0SMarcel Holtmann struct hci_conn_params *params; 54918540f6c0SMarcel Holtmann struct bdaddr_list *b; 54928540f6c0SMarcel Holtmann uint8_t white_list_entries = 0; 54938540f6c0SMarcel Holtmann 54948540f6c0SMarcel Holtmann /* Go through the current white list programmed into the 54958540f6c0SMarcel Holtmann * controller one by one and check if that address is still 54968540f6c0SMarcel Holtmann * in the list of pending connections or list of devices to 54978540f6c0SMarcel Holtmann * report. If not present in either list, then queue the 54988540f6c0SMarcel Holtmann * command to remove it from the controller. 54998540f6c0SMarcel Holtmann */ 55008540f6c0SMarcel Holtmann list_for_each_entry(b, &hdev->le_white_list, list) { 55018540f6c0SMarcel Holtmann struct hci_cp_le_del_from_white_list cp; 55028540f6c0SMarcel Holtmann 55038540f6c0SMarcel Holtmann if (hci_pend_le_action_lookup(&hdev->pend_le_conns, 55048540f6c0SMarcel Holtmann &b->bdaddr, b->bdaddr_type) || 55058540f6c0SMarcel Holtmann hci_pend_le_action_lookup(&hdev->pend_le_reports, 55068540f6c0SMarcel Holtmann &b->bdaddr, b->bdaddr_type)) { 55078540f6c0SMarcel Holtmann white_list_entries++; 55088540f6c0SMarcel Holtmann continue; 55098540f6c0SMarcel Holtmann } 55108540f6c0SMarcel Holtmann 55118540f6c0SMarcel Holtmann cp.bdaddr_type = b->bdaddr_type; 55128540f6c0SMarcel Holtmann bacpy(&cp.bdaddr, &b->bdaddr); 55138540f6c0SMarcel Holtmann 55148540f6c0SMarcel Holtmann hci_req_add(req, HCI_OP_LE_DEL_FROM_WHITE_LIST, 55158540f6c0SMarcel Holtmann sizeof(cp), &cp); 55168540f6c0SMarcel Holtmann } 55178540f6c0SMarcel Holtmann 55188540f6c0SMarcel Holtmann /* Since all no longer valid white list entries have been 55198540f6c0SMarcel Holtmann * removed, walk through the list of pending connections 55208540f6c0SMarcel Holtmann * and ensure that any new device gets programmed into 55218540f6c0SMarcel Holtmann * the controller. 55228540f6c0SMarcel Holtmann * 55238540f6c0SMarcel Holtmann * If the list of the devices is larger than the list of 55248540f6c0SMarcel Holtmann * available white list entries in the controller, then 55258540f6c0SMarcel Holtmann * just abort and return filer policy value to not use the 55268540f6c0SMarcel Holtmann * white list. 55278540f6c0SMarcel Holtmann */ 55288540f6c0SMarcel Holtmann list_for_each_entry(params, &hdev->pend_le_conns, action) { 55298540f6c0SMarcel Holtmann if (hci_bdaddr_list_lookup(&hdev->le_white_list, 55308540f6c0SMarcel Holtmann ¶ms->addr, params->addr_type)) 55318540f6c0SMarcel Holtmann continue; 55328540f6c0SMarcel Holtmann 55338540f6c0SMarcel Holtmann if (white_list_entries >= hdev->le_white_list_size) { 55348540f6c0SMarcel Holtmann /* Select filter policy to accept all advertising */ 55358540f6c0SMarcel Holtmann return 0x00; 55368540f6c0SMarcel Holtmann } 55378540f6c0SMarcel Holtmann 553866d8e837SMarcel Holtmann if (hci_find_irk_by_addr(hdev, ¶ms->addr, 553966d8e837SMarcel Holtmann params->addr_type)) { 554066d8e837SMarcel Holtmann /* White list can not be used with RPAs */ 554166d8e837SMarcel Holtmann return 0x00; 554266d8e837SMarcel Holtmann } 554366d8e837SMarcel Holtmann 55448540f6c0SMarcel Holtmann white_list_entries++; 55458540f6c0SMarcel Holtmann add_to_white_list(req, params); 55468540f6c0SMarcel Holtmann } 55478540f6c0SMarcel Holtmann 55488540f6c0SMarcel Holtmann /* After adding all new pending connections, walk through 55498540f6c0SMarcel Holtmann * the list of pending reports and also add these to the 55508540f6c0SMarcel Holtmann * white list if there is still space. 55518540f6c0SMarcel Holtmann */ 55528540f6c0SMarcel Holtmann list_for_each_entry(params, &hdev->pend_le_reports, action) { 55538540f6c0SMarcel Holtmann if (hci_bdaddr_list_lookup(&hdev->le_white_list, 55548540f6c0SMarcel Holtmann ¶ms->addr, params->addr_type)) 55558540f6c0SMarcel Holtmann continue; 55568540f6c0SMarcel Holtmann 55578540f6c0SMarcel Holtmann if (white_list_entries >= hdev->le_white_list_size) { 55588540f6c0SMarcel Holtmann /* Select filter policy to accept all advertising */ 55598540f6c0SMarcel Holtmann return 0x00; 55608540f6c0SMarcel Holtmann } 55618540f6c0SMarcel Holtmann 556266d8e837SMarcel Holtmann if (hci_find_irk_by_addr(hdev, ¶ms->addr, 556366d8e837SMarcel Holtmann params->addr_type)) { 556466d8e837SMarcel Holtmann /* White list can not be used with RPAs */ 556566d8e837SMarcel Holtmann return 0x00; 556666d8e837SMarcel Holtmann } 556766d8e837SMarcel Holtmann 55688540f6c0SMarcel Holtmann white_list_entries++; 55698540f6c0SMarcel Holtmann add_to_white_list(req, params); 55708540f6c0SMarcel Holtmann } 55718540f6c0SMarcel Holtmann 55728540f6c0SMarcel Holtmann /* Select filter policy to use white list */ 55738540f6c0SMarcel Holtmann return 0x01; 55748540f6c0SMarcel Holtmann } 55758540f6c0SMarcel Holtmann 55768ef30fd3SAndre Guedes void hci_req_add_le_passive_scan(struct hci_request *req) 55778ef30fd3SAndre Guedes { 55788ef30fd3SAndre Guedes struct hci_cp_le_set_scan_param param_cp; 55798ef30fd3SAndre Guedes struct hci_cp_le_set_scan_enable enable_cp; 55808ef30fd3SAndre Guedes struct hci_dev *hdev = req->hdev; 55818ef30fd3SAndre Guedes u8 own_addr_type; 55828540f6c0SMarcel Holtmann u8 filter_policy; 55838ef30fd3SAndre Guedes 55846ab535a7SMarcel Holtmann /* Set require_privacy to false since no SCAN_REQ are send 55856ab535a7SMarcel Holtmann * during passive scanning. Not using an unresolvable address 55866ab535a7SMarcel Holtmann * here is important so that peer devices using direct 55876ab535a7SMarcel Holtmann * advertising with our address will be correctly reported 55886ab535a7SMarcel Holtmann * by the controller. 55898ef30fd3SAndre Guedes */ 55906ab535a7SMarcel Holtmann if (hci_update_random_address(req, false, &own_addr_type)) 55918ef30fd3SAndre Guedes return; 55928ef30fd3SAndre Guedes 55938540f6c0SMarcel Holtmann /* Adding or removing entries from the white list must 55948540f6c0SMarcel Holtmann * happen before enabling scanning. The controller does 55958540f6c0SMarcel Holtmann * not allow white list modification while scanning. 55968540f6c0SMarcel Holtmann */ 55978540f6c0SMarcel Holtmann filter_policy = update_white_list(req); 55988540f6c0SMarcel Holtmann 55998ef30fd3SAndre Guedes memset(¶m_cp, 0, sizeof(param_cp)); 56008ef30fd3SAndre Guedes param_cp.type = LE_SCAN_PASSIVE; 56018ef30fd3SAndre Guedes param_cp.interval = cpu_to_le16(hdev->le_scan_interval); 56028ef30fd3SAndre Guedes param_cp.window = cpu_to_le16(hdev->le_scan_window); 56038ef30fd3SAndre Guedes param_cp.own_address_type = own_addr_type; 56048540f6c0SMarcel Holtmann param_cp.filter_policy = filter_policy; 56058ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_PARAM, sizeof(param_cp), 56068ef30fd3SAndre Guedes ¶m_cp); 56078ef30fd3SAndre Guedes 56088ef30fd3SAndre Guedes memset(&enable_cp, 0, sizeof(enable_cp)); 56098ef30fd3SAndre Guedes enable_cp.enable = LE_SCAN_ENABLE; 56104340a124SAndre Guedes enable_cp.filter_dup = LE_SCAN_FILTER_DUP_ENABLE; 56118ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(enable_cp), 56128ef30fd3SAndre Guedes &enable_cp); 56138ef30fd3SAndre Guedes } 56148ef30fd3SAndre Guedes 5615a4790dbdSAndre Guedes static void update_background_scan_complete(struct hci_dev *hdev, u8 status) 5616a4790dbdSAndre Guedes { 5617a4790dbdSAndre Guedes if (status) 5618a4790dbdSAndre Guedes BT_DBG("HCI request failed to update background scanning: " 5619a4790dbdSAndre Guedes "status 0x%2.2x", status); 5620a4790dbdSAndre Guedes } 5621a4790dbdSAndre Guedes 5622a4790dbdSAndre Guedes /* This function controls the background scanning based on hdev->pend_le_conns 5623a4790dbdSAndre Guedes * list. If there are pending LE connection we start the background scanning, 5624a4790dbdSAndre Guedes * otherwise we stop it. 5625a4790dbdSAndre Guedes * 5626a4790dbdSAndre Guedes * This function requires the caller holds hdev->lock. 5627a4790dbdSAndre Guedes */ 5628a4790dbdSAndre Guedes void hci_update_background_scan(struct hci_dev *hdev) 5629a4790dbdSAndre Guedes { 5630a4790dbdSAndre Guedes struct hci_request req; 5631a4790dbdSAndre Guedes struct hci_conn *conn; 5632a4790dbdSAndre Guedes int err; 5633a4790dbdSAndre Guedes 5634c20c02d5SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags) || 5635c20c02d5SMarcel Holtmann test_bit(HCI_INIT, &hdev->flags) || 5636c20c02d5SMarcel Holtmann test_bit(HCI_SETUP, &hdev->dev_flags) || 5637d603b76bSMarcel Holtmann test_bit(HCI_CONFIG, &hdev->dev_flags) || 5638b8221770SMarcel Holtmann test_bit(HCI_AUTO_OFF, &hdev->dev_flags) || 5639c20c02d5SMarcel Holtmann test_bit(HCI_UNREGISTER, &hdev->dev_flags)) 56401c1697c0SMarcel Holtmann return; 56411c1697c0SMarcel Holtmann 5642a70f4b5fSJohan Hedberg /* No point in doing scanning if LE support hasn't been enabled */ 5643a70f4b5fSJohan Hedberg if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 5644a70f4b5fSJohan Hedberg return; 5645a70f4b5fSJohan Hedberg 5646ae23ada4SJohan Hedberg /* If discovery is active don't interfere with it */ 5647ae23ada4SJohan Hedberg if (hdev->discovery.state != DISCOVERY_STOPPED) 5648ae23ada4SJohan Hedberg return; 5649ae23ada4SJohan Hedberg 5650a4790dbdSAndre Guedes hci_req_init(&req, hdev); 5651a4790dbdSAndre Guedes 5652d1d588c1SJohan Hedberg if (list_empty(&hdev->pend_le_conns) && 565366f8455aSJohan Hedberg list_empty(&hdev->pend_le_reports)) { 56540d2bf134SJohan Hedberg /* If there is no pending LE connections or devices 56550d2bf134SJohan Hedberg * to be scanned for, we should stop the background 56560d2bf134SJohan Hedberg * scanning. 5657a4790dbdSAndre Guedes */ 5658a4790dbdSAndre Guedes 5659a4790dbdSAndre Guedes /* If controller is not scanning we are done. */ 5660a4790dbdSAndre Guedes if (!test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 5661a4790dbdSAndre Guedes return; 5662a4790dbdSAndre Guedes 5663a4790dbdSAndre Guedes hci_req_add_le_scan_disable(&req); 5664a4790dbdSAndre Guedes 5665a4790dbdSAndre Guedes BT_DBG("%s stopping background scanning", hdev->name); 5666a4790dbdSAndre Guedes } else { 5667a4790dbdSAndre Guedes /* If there is at least one pending LE connection, we should 5668a4790dbdSAndre Guedes * keep the background scan running. 5669a4790dbdSAndre Guedes */ 5670a4790dbdSAndre Guedes 5671a4790dbdSAndre Guedes /* If controller is connecting, we should not start scanning 5672a4790dbdSAndre Guedes * since some controllers are not able to scan and connect at 5673a4790dbdSAndre Guedes * the same time. 5674a4790dbdSAndre Guedes */ 5675a4790dbdSAndre Guedes conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT); 5676a4790dbdSAndre Guedes if (conn) 5677a4790dbdSAndre Guedes return; 5678a4790dbdSAndre Guedes 56794340a124SAndre Guedes /* If controller is currently scanning, we stop it to ensure we 56804340a124SAndre Guedes * don't miss any advertising (due to duplicates filter). 56814340a124SAndre Guedes */ 56824340a124SAndre Guedes if (test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 56834340a124SAndre Guedes hci_req_add_le_scan_disable(&req); 56844340a124SAndre Guedes 56858ef30fd3SAndre Guedes hci_req_add_le_passive_scan(&req); 5686a4790dbdSAndre Guedes 5687a4790dbdSAndre Guedes BT_DBG("%s starting background scanning", hdev->name); 5688a4790dbdSAndre Guedes } 5689a4790dbdSAndre Guedes 5690a4790dbdSAndre Guedes err = hci_req_run(&req, update_background_scan_complete); 5691a4790dbdSAndre Guedes if (err) 5692a4790dbdSAndre Guedes BT_ERR("Failed to run HCI request: err %d", err); 5693a4790dbdSAndre Guedes } 5694432df05eSJohan Hedberg 569522f433dcSJohan Hedberg static bool disconnected_whitelist_entries(struct hci_dev *hdev) 569622f433dcSJohan Hedberg { 569722f433dcSJohan Hedberg struct bdaddr_list *b; 569822f433dcSJohan Hedberg 569922f433dcSJohan Hedberg list_for_each_entry(b, &hdev->whitelist, list) { 570022f433dcSJohan Hedberg struct hci_conn *conn; 570122f433dcSJohan Hedberg 570222f433dcSJohan Hedberg conn = hci_conn_hash_lookup_ba(hdev, ACL_LINK, &b->bdaddr); 570322f433dcSJohan Hedberg if (!conn) 570422f433dcSJohan Hedberg return true; 570522f433dcSJohan Hedberg 570622f433dcSJohan Hedberg if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 570722f433dcSJohan Hedberg return true; 570822f433dcSJohan Hedberg } 570922f433dcSJohan Hedberg 571022f433dcSJohan Hedberg return false; 571122f433dcSJohan Hedberg } 571222f433dcSJohan Hedberg 5713432df05eSJohan Hedberg void hci_update_page_scan(struct hci_dev *hdev, struct hci_request *req) 5714432df05eSJohan Hedberg { 5715432df05eSJohan Hedberg u8 scan; 5716432df05eSJohan Hedberg 5717432df05eSJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) 5718432df05eSJohan Hedberg return; 5719432df05eSJohan Hedberg 5720432df05eSJohan Hedberg if (!hdev_is_powered(hdev)) 5721432df05eSJohan Hedberg return; 5722432df05eSJohan Hedberg 5723432df05eSJohan Hedberg if (mgmt_powering_down(hdev)) 5724432df05eSJohan Hedberg return; 5725432df05eSJohan Hedberg 5726432df05eSJohan Hedberg if (test_bit(HCI_CONNECTABLE, &hdev->dev_flags) || 572722f433dcSJohan Hedberg disconnected_whitelist_entries(hdev)) 5728432df05eSJohan Hedberg scan = SCAN_PAGE; 5729432df05eSJohan Hedberg else 5730432df05eSJohan Hedberg scan = SCAN_DISABLED; 5731432df05eSJohan Hedberg 5732432df05eSJohan Hedberg if (test_bit(HCI_PSCAN, &hdev->flags) == !!(scan & SCAN_PAGE)) 5733432df05eSJohan Hedberg return; 5734432df05eSJohan Hedberg 5735432df05eSJohan Hedberg if (test_bit(HCI_DISCOVERABLE, &hdev->dev_flags)) 5736432df05eSJohan Hedberg scan |= SCAN_INQUIRY; 5737432df05eSJohan Hedberg 5738432df05eSJohan Hedberg if (req) 5739432df05eSJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 5740432df05eSJohan Hedberg else 5741432df05eSJohan Hedberg hci_send_cmd(hdev, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 5742432df05eSJohan Hedberg } 5743