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 9730b3c7d37SMarcel Holtmann static int device_list_show(struct seq_file *f, void *ptr) 9747d474e06SAndre Guedes { 9750b3c7d37SMarcel Holtmann struct hci_dev *hdev = f->private; 9767d474e06SAndre Guedes struct hci_conn_params *p; 9777d474e06SAndre Guedes 9787d474e06SAndre Guedes hci_dev_lock(hdev); 9797d474e06SAndre Guedes list_for_each_entry(p, &hdev->le_conn_params, list) { 9800b3c7d37SMarcel Holtmann seq_printf(f, "%pMR %u %u\n", &p->addr, p->addr_type, 9817d474e06SAndre Guedes p->auto_connect); 9827d474e06SAndre Guedes } 9837d474e06SAndre Guedes hci_dev_unlock(hdev); 9847d474e06SAndre Guedes 9857d474e06SAndre Guedes return 0; 9867d474e06SAndre Guedes } 9877d474e06SAndre Guedes 9880b3c7d37SMarcel Holtmann static int device_list_open(struct inode *inode, struct file *file) 9897d474e06SAndre Guedes { 9900b3c7d37SMarcel Holtmann return single_open(file, device_list_show, inode->i_private); 9917d474e06SAndre Guedes } 9927d474e06SAndre Guedes 9930b3c7d37SMarcel Holtmann static const struct file_operations device_list_fops = { 9940b3c7d37SMarcel Holtmann .open = device_list_open, 9957d474e06SAndre Guedes .read = seq_read, 9967d474e06SAndre Guedes .llseek = seq_lseek, 9977d474e06SAndre Guedes .release = single_release, 9987d474e06SAndre Guedes }; 9997d474e06SAndre Guedes 10001da177e4SLinus Torvalds /* ---- HCI requests ---- */ 10011da177e4SLinus Torvalds 100242c6b129SJohan Hedberg static void hci_req_sync_complete(struct hci_dev *hdev, u8 result) 10031da177e4SLinus Torvalds { 100442c6b129SJohan Hedberg BT_DBG("%s result 0x%2.2x", hdev->name, result); 100575fb0e32SJohan Hedberg 10061da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 10071da177e4SLinus Torvalds hdev->req_result = result; 10081da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 10091da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 10101da177e4SLinus Torvalds } 10111da177e4SLinus Torvalds } 10121da177e4SLinus Torvalds 10131da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 10141da177e4SLinus Torvalds { 10151da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 10161da177e4SLinus Torvalds 10171da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 10181da177e4SLinus Torvalds hdev->req_result = err; 10191da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 10201da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 10211da177e4SLinus Torvalds } 10221da177e4SLinus Torvalds } 10231da177e4SLinus Torvalds 102477a63e0aSFengguang Wu static struct sk_buff *hci_get_cmd_complete(struct hci_dev *hdev, u16 opcode, 102577a63e0aSFengguang Wu u8 event) 102675e84b7cSJohan Hedberg { 102775e84b7cSJohan Hedberg struct hci_ev_cmd_complete *ev; 102875e84b7cSJohan Hedberg struct hci_event_hdr *hdr; 102975e84b7cSJohan Hedberg struct sk_buff *skb; 103075e84b7cSJohan Hedberg 103175e84b7cSJohan Hedberg hci_dev_lock(hdev); 103275e84b7cSJohan Hedberg 103375e84b7cSJohan Hedberg skb = hdev->recv_evt; 103475e84b7cSJohan Hedberg hdev->recv_evt = NULL; 103575e84b7cSJohan Hedberg 103675e84b7cSJohan Hedberg hci_dev_unlock(hdev); 103775e84b7cSJohan Hedberg 103875e84b7cSJohan Hedberg if (!skb) 103975e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 104075e84b7cSJohan Hedberg 104175e84b7cSJohan Hedberg if (skb->len < sizeof(*hdr)) { 104275e84b7cSJohan Hedberg BT_ERR("Too short HCI event"); 104375e84b7cSJohan Hedberg goto failed; 104475e84b7cSJohan Hedberg } 104575e84b7cSJohan Hedberg 104675e84b7cSJohan Hedberg hdr = (void *) skb->data; 104775e84b7cSJohan Hedberg skb_pull(skb, HCI_EVENT_HDR_SIZE); 104875e84b7cSJohan Hedberg 10497b1abbbeSJohan Hedberg if (event) { 10507b1abbbeSJohan Hedberg if (hdr->evt != event) 10517b1abbbeSJohan Hedberg goto failed; 10527b1abbbeSJohan Hedberg return skb; 10537b1abbbeSJohan Hedberg } 10547b1abbbeSJohan Hedberg 105575e84b7cSJohan Hedberg if (hdr->evt != HCI_EV_CMD_COMPLETE) { 105675e84b7cSJohan Hedberg BT_DBG("Last event is not cmd complete (0x%2.2x)", hdr->evt); 105775e84b7cSJohan Hedberg goto failed; 105875e84b7cSJohan Hedberg } 105975e84b7cSJohan Hedberg 106075e84b7cSJohan Hedberg if (skb->len < sizeof(*ev)) { 106175e84b7cSJohan Hedberg BT_ERR("Too short cmd_complete event"); 106275e84b7cSJohan Hedberg goto failed; 106375e84b7cSJohan Hedberg } 106475e84b7cSJohan Hedberg 106575e84b7cSJohan Hedberg ev = (void *) skb->data; 106675e84b7cSJohan Hedberg skb_pull(skb, sizeof(*ev)); 106775e84b7cSJohan Hedberg 106875e84b7cSJohan Hedberg if (opcode == __le16_to_cpu(ev->opcode)) 106975e84b7cSJohan Hedberg return skb; 107075e84b7cSJohan Hedberg 107175e84b7cSJohan Hedberg BT_DBG("opcode doesn't match (0x%2.2x != 0x%2.2x)", opcode, 107275e84b7cSJohan Hedberg __le16_to_cpu(ev->opcode)); 107375e84b7cSJohan Hedberg 107475e84b7cSJohan Hedberg failed: 107575e84b7cSJohan Hedberg kfree_skb(skb); 107675e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 107775e84b7cSJohan Hedberg } 107875e84b7cSJohan Hedberg 10797b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, 108007dc93ddSJohan Hedberg const void *param, u8 event, u32 timeout) 108175e84b7cSJohan Hedberg { 108275e84b7cSJohan Hedberg DECLARE_WAITQUEUE(wait, current); 108375e84b7cSJohan Hedberg struct hci_request req; 108475e84b7cSJohan Hedberg int err = 0; 108575e84b7cSJohan Hedberg 108675e84b7cSJohan Hedberg BT_DBG("%s", hdev->name); 108775e84b7cSJohan Hedberg 108875e84b7cSJohan Hedberg hci_req_init(&req, hdev); 108975e84b7cSJohan Hedberg 10907b1abbbeSJohan Hedberg hci_req_add_ev(&req, opcode, plen, param, event); 109175e84b7cSJohan Hedberg 109275e84b7cSJohan Hedberg hdev->req_status = HCI_REQ_PEND; 109375e84b7cSJohan Hedberg 109475e84b7cSJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 109575e84b7cSJohan Hedberg if (err < 0) 109675e84b7cSJohan Hedberg return ERR_PTR(err); 109775e84b7cSJohan Hedberg 109875e84b7cSJohan Hedberg add_wait_queue(&hdev->req_wait_q, &wait); 109975e84b7cSJohan Hedberg set_current_state(TASK_INTERRUPTIBLE); 110075e84b7cSJohan Hedberg 110175e84b7cSJohan Hedberg schedule_timeout(timeout); 110275e84b7cSJohan Hedberg 110375e84b7cSJohan Hedberg remove_wait_queue(&hdev->req_wait_q, &wait); 110475e84b7cSJohan Hedberg 110575e84b7cSJohan Hedberg if (signal_pending(current)) 110675e84b7cSJohan Hedberg return ERR_PTR(-EINTR); 110775e84b7cSJohan Hedberg 110875e84b7cSJohan Hedberg switch (hdev->req_status) { 110975e84b7cSJohan Hedberg case HCI_REQ_DONE: 111075e84b7cSJohan Hedberg err = -bt_to_errno(hdev->req_result); 111175e84b7cSJohan Hedberg break; 111275e84b7cSJohan Hedberg 111375e84b7cSJohan Hedberg case HCI_REQ_CANCELED: 111475e84b7cSJohan Hedberg err = -hdev->req_result; 111575e84b7cSJohan Hedberg break; 111675e84b7cSJohan Hedberg 111775e84b7cSJohan Hedberg default: 111875e84b7cSJohan Hedberg err = -ETIMEDOUT; 111975e84b7cSJohan Hedberg break; 112075e84b7cSJohan Hedberg } 112175e84b7cSJohan Hedberg 112275e84b7cSJohan Hedberg hdev->req_status = hdev->req_result = 0; 112375e84b7cSJohan Hedberg 112475e84b7cSJohan Hedberg BT_DBG("%s end: err %d", hdev->name, err); 112575e84b7cSJohan Hedberg 112675e84b7cSJohan Hedberg if (err < 0) 112775e84b7cSJohan Hedberg return ERR_PTR(err); 112875e84b7cSJohan Hedberg 11297b1abbbeSJohan Hedberg return hci_get_cmd_complete(hdev, opcode, event); 11307b1abbbeSJohan Hedberg } 11317b1abbbeSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync_ev); 11327b1abbbeSJohan Hedberg 11337b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 113407dc93ddSJohan Hedberg const void *param, u32 timeout) 11357b1abbbeSJohan Hedberg { 11367b1abbbeSJohan Hedberg return __hci_cmd_sync_ev(hdev, opcode, plen, param, 0, timeout); 113775e84b7cSJohan Hedberg } 113875e84b7cSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync); 113975e84b7cSJohan Hedberg 11401da177e4SLinus Torvalds /* Execute request and wait for completion. */ 114101178cd4SJohan Hedberg static int __hci_req_sync(struct hci_dev *hdev, 114242c6b129SJohan Hedberg void (*func)(struct hci_request *req, 114342c6b129SJohan Hedberg unsigned long opt), 11441da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 11451da177e4SLinus Torvalds { 114642c6b129SJohan Hedberg struct hci_request req; 11471da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 11481da177e4SLinus Torvalds int err = 0; 11491da177e4SLinus Torvalds 11501da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 11511da177e4SLinus Torvalds 115242c6b129SJohan Hedberg hci_req_init(&req, hdev); 115342c6b129SJohan Hedberg 11541da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 11551da177e4SLinus Torvalds 115642c6b129SJohan Hedberg func(&req, opt); 115753cce22dSJohan Hedberg 115842c6b129SJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 115942c6b129SJohan Hedberg if (err < 0) { 116053cce22dSJohan Hedberg hdev->req_status = 0; 1161920c8300SAndre Guedes 1162920c8300SAndre Guedes /* ENODATA means the HCI request command queue is empty. 1163920c8300SAndre Guedes * This can happen when a request with conditionals doesn't 1164920c8300SAndre Guedes * trigger any commands to be sent. This is normal behavior 1165920c8300SAndre Guedes * and should not trigger an error return. 116642c6b129SJohan Hedberg */ 1167920c8300SAndre Guedes if (err == -ENODATA) 116842c6b129SJohan Hedberg return 0; 1169920c8300SAndre Guedes 1170920c8300SAndre Guedes return err; 117153cce22dSJohan Hedberg } 117253cce22dSJohan Hedberg 1173bc4445c7SAndre Guedes add_wait_queue(&hdev->req_wait_q, &wait); 1174bc4445c7SAndre Guedes set_current_state(TASK_INTERRUPTIBLE); 1175bc4445c7SAndre Guedes 11761da177e4SLinus Torvalds schedule_timeout(timeout); 11771da177e4SLinus Torvalds 11781da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 11791da177e4SLinus Torvalds 11801da177e4SLinus Torvalds if (signal_pending(current)) 11811da177e4SLinus Torvalds return -EINTR; 11821da177e4SLinus Torvalds 11831da177e4SLinus Torvalds switch (hdev->req_status) { 11841da177e4SLinus Torvalds case HCI_REQ_DONE: 1185e175072fSJoe Perches err = -bt_to_errno(hdev->req_result); 11861da177e4SLinus Torvalds break; 11871da177e4SLinus Torvalds 11881da177e4SLinus Torvalds case HCI_REQ_CANCELED: 11891da177e4SLinus Torvalds err = -hdev->req_result; 11901da177e4SLinus Torvalds break; 11911da177e4SLinus Torvalds 11921da177e4SLinus Torvalds default: 11931da177e4SLinus Torvalds err = -ETIMEDOUT; 11941da177e4SLinus Torvalds break; 11953ff50b79SStephen Hemminger } 11961da177e4SLinus Torvalds 1197a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 11981da177e4SLinus Torvalds 11991da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 12001da177e4SLinus Torvalds 12011da177e4SLinus Torvalds return err; 12021da177e4SLinus Torvalds } 12031da177e4SLinus Torvalds 120401178cd4SJohan Hedberg static int hci_req_sync(struct hci_dev *hdev, 120542c6b129SJohan Hedberg void (*req)(struct hci_request *req, 120642c6b129SJohan Hedberg unsigned long opt), 12071da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 12081da177e4SLinus Torvalds { 12091da177e4SLinus Torvalds int ret; 12101da177e4SLinus Torvalds 12117c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 12127c6a329eSMarcel Holtmann return -ENETDOWN; 12137c6a329eSMarcel Holtmann 12141da177e4SLinus Torvalds /* Serialize all requests */ 12151da177e4SLinus Torvalds hci_req_lock(hdev); 121601178cd4SJohan Hedberg ret = __hci_req_sync(hdev, req, opt, timeout); 12171da177e4SLinus Torvalds hci_req_unlock(hdev); 12181da177e4SLinus Torvalds 12191da177e4SLinus Torvalds return ret; 12201da177e4SLinus Torvalds } 12211da177e4SLinus Torvalds 122242c6b129SJohan Hedberg static void hci_reset_req(struct hci_request *req, unsigned long opt) 12231da177e4SLinus Torvalds { 122442c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 12251da177e4SLinus Torvalds 12261da177e4SLinus Torvalds /* Reset device */ 122742c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 122842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 12291da177e4SLinus Torvalds } 12301da177e4SLinus Torvalds 123142c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 12321da177e4SLinus Torvalds { 123342c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 12342455a3eaSAndrei Emeltchenko 12351da177e4SLinus Torvalds /* Read Local Supported Features */ 123642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 12371da177e4SLinus Torvalds 12381143e5a6SMarcel Holtmann /* Read Local Version */ 123942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 12402177bab5SJohan Hedberg 12412177bab5SJohan Hedberg /* Read BD Address */ 124242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 12431da177e4SLinus Torvalds } 12441da177e4SLinus Torvalds 124542c6b129SJohan Hedberg static void amp_init(struct hci_request *req) 1246e61ef499SAndrei Emeltchenko { 124742c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 12482455a3eaSAndrei Emeltchenko 1249e61ef499SAndrei Emeltchenko /* Read Local Version */ 125042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 12516bcbc489SAndrei Emeltchenko 1252f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 1253f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 1254f6996cfeSMarcel Holtmann 1255f6996cfeSMarcel Holtmann /* Read Local Supported Features */ 1256f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 1257f6996cfeSMarcel Holtmann 12586bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 125942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 1260e71dfabaSAndrei Emeltchenko 1261e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 126242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 12637528ca1cSMarcel Holtmann 1264f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 1265f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 1266f38ba941SMarcel Holtmann 12677528ca1cSMarcel Holtmann /* Read Location Data */ 12687528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 1269e61ef499SAndrei Emeltchenko } 1270e61ef499SAndrei Emeltchenko 127142c6b129SJohan Hedberg static void hci_init1_req(struct hci_request *req, unsigned long opt) 1272e61ef499SAndrei Emeltchenko { 127342c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 1274e61ef499SAndrei Emeltchenko 1275e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 1276e61ef499SAndrei Emeltchenko 127711778716SAndrei Emeltchenko /* Reset */ 127811778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 127942c6b129SJohan Hedberg hci_reset_req(req, 0); 128011778716SAndrei Emeltchenko 1281e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 1282e61ef499SAndrei Emeltchenko case HCI_BREDR: 128342c6b129SJohan Hedberg bredr_init(req); 1284e61ef499SAndrei Emeltchenko break; 1285e61ef499SAndrei Emeltchenko 1286e61ef499SAndrei Emeltchenko case HCI_AMP: 128742c6b129SJohan Hedberg amp_init(req); 1288e61ef499SAndrei Emeltchenko break; 1289e61ef499SAndrei Emeltchenko 1290e61ef499SAndrei Emeltchenko default: 1291e61ef499SAndrei Emeltchenko BT_ERR("Unknown device type %d", hdev->dev_type); 1292e61ef499SAndrei Emeltchenko break; 1293e61ef499SAndrei Emeltchenko } 1294e61ef499SAndrei Emeltchenko } 1295e61ef499SAndrei Emeltchenko 129642c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 12972177bab5SJohan Hedberg { 12984ca048e3SMarcel Holtmann struct hci_dev *hdev = req->hdev; 12994ca048e3SMarcel Holtmann 13002177bab5SJohan Hedberg __le16 param; 13012177bab5SJohan Hedberg __u8 flt_type; 13022177bab5SJohan Hedberg 13032177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 130442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 13052177bab5SJohan Hedberg 13062177bab5SJohan Hedberg /* Read Class of Device */ 130742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 13082177bab5SJohan Hedberg 13092177bab5SJohan Hedberg /* Read Local Name */ 131042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 13112177bab5SJohan Hedberg 13122177bab5SJohan Hedberg /* Read Voice Setting */ 131342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 13142177bab5SJohan Hedberg 1315b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 1316b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 1317b4cb9fb2SMarcel Holtmann 13184b836f39SMarcel Holtmann /* Read Current IAC LAP */ 13194b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 13204b836f39SMarcel Holtmann 13212177bab5SJohan Hedberg /* Clear Event Filters */ 13222177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 132342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 13242177bab5SJohan Hedberg 13252177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 1326dcf4adbfSJoe Perches param = cpu_to_le16(0x7d00); 132742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 13282177bab5SJohan Hedberg 13294ca048e3SMarcel Holtmann /* AVM Berlin (31), aka "BlueFRITZ!", reports version 1.2, 13304ca048e3SMarcel Holtmann * but it does not support page scan related HCI commands. 13314ca048e3SMarcel Holtmann */ 13324ca048e3SMarcel Holtmann if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) { 1333f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 1334f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 1335f332ec66SJohan Hedberg } 13362177bab5SJohan Hedberg } 13372177bab5SJohan Hedberg 133842c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 13392177bab5SJohan Hedberg { 1340c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 1341c73eee91SJohan Hedberg 13422177bab5SJohan Hedberg /* Read LE Buffer Size */ 134342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 13442177bab5SJohan Hedberg 13452177bab5SJohan Hedberg /* Read LE Local Supported Features */ 134642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 13472177bab5SJohan Hedberg 1348747d3f03SMarcel Holtmann /* Read LE Supported States */ 1349747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 1350747d3f03SMarcel Holtmann 13512177bab5SJohan Hedberg /* Read LE Advertising Channel TX Power */ 135242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 13532177bab5SJohan Hedberg 13542177bab5SJohan Hedberg /* Read LE White List Size */ 135542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 0, NULL); 13562177bab5SJohan Hedberg 1357747d3f03SMarcel Holtmann /* Clear LE White List */ 1358747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 1359c73eee91SJohan Hedberg 1360c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 1361c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1362c73eee91SJohan Hedberg set_bit(HCI_LE_ENABLED, &hdev->dev_flags); 13632177bab5SJohan Hedberg } 13642177bab5SJohan Hedberg 13652177bab5SJohan Hedberg static u8 hci_get_inquiry_mode(struct hci_dev *hdev) 13662177bab5SJohan Hedberg { 13672177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 13682177bab5SJohan Hedberg return 0x02; 13692177bab5SJohan Hedberg 13702177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 13712177bab5SJohan Hedberg return 0x01; 13722177bab5SJohan Hedberg 13732177bab5SJohan Hedberg if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 && 13742177bab5SJohan Hedberg hdev->lmp_subver == 0x0757) 13752177bab5SJohan Hedberg return 0x01; 13762177bab5SJohan Hedberg 13772177bab5SJohan Hedberg if (hdev->manufacturer == 15) { 13782177bab5SJohan Hedberg if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963) 13792177bab5SJohan Hedberg return 0x01; 13802177bab5SJohan Hedberg if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963) 13812177bab5SJohan Hedberg return 0x01; 13822177bab5SJohan Hedberg if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965) 13832177bab5SJohan Hedberg return 0x01; 13842177bab5SJohan Hedberg } 13852177bab5SJohan Hedberg 13862177bab5SJohan Hedberg if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 && 13872177bab5SJohan Hedberg hdev->lmp_subver == 0x1805) 13882177bab5SJohan Hedberg return 0x01; 13892177bab5SJohan Hedberg 13902177bab5SJohan Hedberg return 0x00; 13912177bab5SJohan Hedberg } 13922177bab5SJohan Hedberg 139342c6b129SJohan Hedberg static void hci_setup_inquiry_mode(struct hci_request *req) 13942177bab5SJohan Hedberg { 13952177bab5SJohan Hedberg u8 mode; 13962177bab5SJohan Hedberg 139742c6b129SJohan Hedberg mode = hci_get_inquiry_mode(req->hdev); 13982177bab5SJohan Hedberg 139942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 14002177bab5SJohan Hedberg } 14012177bab5SJohan Hedberg 140242c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 14032177bab5SJohan Hedberg { 140442c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 140542c6b129SJohan Hedberg 14062177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 14072177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 14082177bab5SJohan Hedberg * command otherwise. 14092177bab5SJohan Hedberg */ 14102177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 14112177bab5SJohan Hedberg 14122177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 14132177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 14142177bab5SJohan Hedberg */ 14152177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 14162177bab5SJohan Hedberg return; 14172177bab5SJohan Hedberg 14182177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 14192177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 14202177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 14212177bab5SJohan Hedberg events[4] |= 0x04; /* Read Remote Extended Features Complete */ 14222177bab5SJohan Hedberg events[5] |= 0x08; /* Synchronous Connection Complete */ 14232177bab5SJohan Hedberg events[5] |= 0x10; /* Synchronous Connection Changed */ 1424c7882cbdSMarcel Holtmann } else { 1425c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 1426c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 1427c7882cbdSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 1428c7882cbdSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 1429c7882cbdSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information Complete */ 1430c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 1431c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 1432c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 1433c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 1434c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 1435c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 14362177bab5SJohan Hedberg } 14372177bab5SJohan Hedberg 14382177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 14392177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 14402177bab5SJohan Hedberg 14412177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 14422177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 14432177bab5SJohan Hedberg 14442177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 14452177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 14462177bab5SJohan Hedberg 14472177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 14482177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 14492177bab5SJohan Hedberg 14502177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 14512177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 14522177bab5SJohan Hedberg 14532177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 14542177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 14552177bab5SJohan Hedberg 14562177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 14572177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 14582177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 14592177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 14602177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 14612177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 14622177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 14632177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 14642177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 14652177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 14662177bab5SJohan Hedberg * Features Notification 14672177bab5SJohan Hedberg */ 14682177bab5SJohan Hedberg } 14692177bab5SJohan Hedberg 14702177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 14712177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 14722177bab5SJohan Hedberg 147342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 14742177bab5SJohan Hedberg } 14752177bab5SJohan Hedberg 147642c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 14772177bab5SJohan Hedberg { 147842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 147942c6b129SJohan Hedberg 14802177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 148142c6b129SJohan Hedberg bredr_setup(req); 148256f87901SJohan Hedberg else 148356f87901SJohan Hedberg clear_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 14842177bab5SJohan Hedberg 14852177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 148642c6b129SJohan Hedberg le_setup(req); 14872177bab5SJohan Hedberg 148842c6b129SJohan Hedberg hci_setup_event_mask(req); 14892177bab5SJohan Hedberg 14903f8e2d75SJohan Hedberg /* AVM Berlin (31), aka "BlueFRITZ!", doesn't support the read 14913f8e2d75SJohan Hedberg * local supported commands HCI command. 14923f8e2d75SJohan Hedberg */ 14933f8e2d75SJohan Hedberg if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) 149442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 14952177bab5SJohan Hedberg 14962177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 149757af75a8SMarcel Holtmann /* When SSP is available, then the host features page 149857af75a8SMarcel Holtmann * should also be available as well. However some 149957af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 150057af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 150157af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 150257af75a8SMarcel Holtmann */ 150357af75a8SMarcel Holtmann hdev->max_page = 0x01; 150457af75a8SMarcel Holtmann 15052177bab5SJohan Hedberg if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) { 15062177bab5SJohan Hedberg u8 mode = 0x01; 150742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 15082177bab5SJohan Hedberg sizeof(mode), &mode); 15092177bab5SJohan Hedberg } else { 15102177bab5SJohan Hedberg struct hci_cp_write_eir cp; 15112177bab5SJohan Hedberg 15122177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 15132177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 15142177bab5SJohan Hedberg 151542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 15162177bab5SJohan Hedberg } 15172177bab5SJohan Hedberg } 15182177bab5SJohan Hedberg 15192177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 152042c6b129SJohan Hedberg hci_setup_inquiry_mode(req); 15212177bab5SJohan Hedberg 15222177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 152342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 15242177bab5SJohan Hedberg 15252177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 15262177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 15272177bab5SJohan Hedberg 15282177bab5SJohan Hedberg cp.page = 0x01; 152942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 153042c6b129SJohan Hedberg sizeof(cp), &cp); 15312177bab5SJohan Hedberg } 15322177bab5SJohan Hedberg 15332177bab5SJohan Hedberg if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) { 15342177bab5SJohan Hedberg u8 enable = 1; 153542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 15362177bab5SJohan Hedberg &enable); 15372177bab5SJohan Hedberg } 15382177bab5SJohan Hedberg } 15392177bab5SJohan Hedberg 154042c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 15412177bab5SJohan Hedberg { 154242c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 15432177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 15442177bab5SJohan Hedberg u16 link_policy = 0; 15452177bab5SJohan Hedberg 15462177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 15472177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 15482177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 15492177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 15502177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 15512177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 15522177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 15532177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 15542177bab5SJohan Hedberg 15552177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 155642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 15572177bab5SJohan Hedberg } 15582177bab5SJohan Hedberg 155942c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 15602177bab5SJohan Hedberg { 156142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 15622177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 15632177bab5SJohan Hedberg 1564c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 1565c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1566c73eee91SJohan Hedberg return; 1567c73eee91SJohan Hedberg 15682177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 15692177bab5SJohan Hedberg 15702177bab5SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) { 15712177bab5SJohan Hedberg cp.le = 0x01; 15722177bab5SJohan Hedberg cp.simul = lmp_le_br_capable(hdev); 15732177bab5SJohan Hedberg } 15742177bab5SJohan Hedberg 15752177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 157642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 15772177bab5SJohan Hedberg &cp); 15782177bab5SJohan Hedberg } 15792177bab5SJohan Hedberg 1580d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 1581d62e6d67SJohan Hedberg { 1582d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 1583d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 1584d62e6d67SJohan Hedberg 1585d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 1586d62e6d67SJohan Hedberg * enable all necessary events for it. 1587d62e6d67SJohan Hedberg */ 158853b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 1589d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 1590d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 1591d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 1592d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 1593d62e6d67SJohan Hedberg } 1594d62e6d67SJohan Hedberg 1595d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 1596d62e6d67SJohan Hedberg * enable all necessary events for it. 1597d62e6d67SJohan Hedberg */ 159853b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 1599d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 1600d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 1601d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 1602d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 1603d62e6d67SJohan Hedberg } 1604d62e6d67SJohan Hedberg 160540c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 1606cd7ca0ecSMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) 160740c59fcbSMarcel Holtmann events[2] |= 0x80; 160840c59fcbSMarcel Holtmann 1609d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 1610d62e6d67SJohan Hedberg } 1611d62e6d67SJohan Hedberg 161242c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 16132177bab5SJohan Hedberg { 161442c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 1615d2c5d77fSJohan Hedberg u8 p; 161642c6b129SJohan Hedberg 1617b8f4e068SGustavo Padovan /* Some Broadcom based Bluetooth controllers do not support the 1618b8f4e068SGustavo Padovan * Delete Stored Link Key command. They are clearly indicating its 1619b8f4e068SGustavo Padovan * absence in the bit mask of supported commands. 1620b8f4e068SGustavo Padovan * 1621b8f4e068SGustavo Padovan * Check the supported commands and only if the the command is marked 1622b8f4e068SGustavo Padovan * as supported send it. If not supported assume that the controller 1623b8f4e068SGustavo Padovan * does not have actual support for stored link keys which makes this 1624b8f4e068SGustavo Padovan * command redundant anyway. 1625f9f462faSMarcel Holtmann * 1626f9f462faSMarcel Holtmann * Some controllers indicate that they support handling deleting 1627f9f462faSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 1628f9f462faSMarcel Holtmann * just disable this command. 1629b8f4e068SGustavo Padovan */ 1630f9f462faSMarcel Holtmann if (hdev->commands[6] & 0x80 && 1631f9f462faSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 163259f45d57SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 163359f45d57SJohan Hedberg 163459f45d57SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 163559f45d57SJohan Hedberg cp.delete_all = 0x01; 163659f45d57SJohan Hedberg hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 163759f45d57SJohan Hedberg sizeof(cp), &cp); 163859f45d57SJohan Hedberg } 163959f45d57SJohan Hedberg 16402177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 164142c6b129SJohan Hedberg hci_setup_link_policy(req); 16422177bab5SJohan Hedberg 16439193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 16449193c6e8SAndre Guedes u8 events[8]; 16459193c6e8SAndre Guedes 16469193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 16479193c6e8SAndre Guedes events[0] = 0x1f; 1648662bc2e6SAndre Guedes 1649662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 1650662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 1651662bc2e6SAndre Guedes */ 1652662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 1653662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 1654662bc2e6SAndre Guedes * Parameter Request 1655662bc2e6SAndre Guedes */ 1656662bc2e6SAndre Guedes 16579193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 16589193c6e8SAndre Guedes events); 16599193c6e8SAndre Guedes 166042c6b129SJohan Hedberg hci_set_le_support(req); 16619193c6e8SAndre Guedes } 1662d2c5d77fSJohan Hedberg 1663d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 1664d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 1665d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 1666d2c5d77fSJohan Hedberg 1667d2c5d77fSJohan Hedberg cp.page = p; 1668d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 1669d2c5d77fSJohan Hedberg sizeof(cp), &cp); 1670d2c5d77fSJohan Hedberg } 16712177bab5SJohan Hedberg } 16722177bab5SJohan Hedberg 16735d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 16745d4e7e8dSJohan Hedberg { 16755d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 16765d4e7e8dSJohan Hedberg 1677d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 1678d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 1679d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 1680d62e6d67SJohan Hedberg 16815d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 168253b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 16835d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 1684a6d0d690SMarcel Holtmann 1685a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 16865afeac14SMarcel Holtmann if ((lmp_sc_capable(hdev) || 1687111902f7SMarcel Holtmann test_bit(HCI_FORCE_SC, &hdev->dbg_flags)) && 1688a6d0d690SMarcel Holtmann test_bit(HCI_SC_ENABLED, &hdev->dev_flags)) { 1689a6d0d690SMarcel Holtmann u8 support = 0x01; 1690a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 1691a6d0d690SMarcel Holtmann sizeof(support), &support); 1692a6d0d690SMarcel Holtmann } 16935d4e7e8dSJohan Hedberg } 16945d4e7e8dSJohan Hedberg 16952177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 16962177bab5SJohan Hedberg { 16972177bab5SJohan Hedberg int err; 16982177bab5SJohan Hedberg 16992177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 17002177bab5SJohan Hedberg if (err < 0) 17012177bab5SJohan Hedberg return err; 17022177bab5SJohan Hedberg 17034b4148e9SMarcel Holtmann /* The Device Under Test (DUT) mode is special and available for 17044b4148e9SMarcel Holtmann * all controller types. So just create it early on. 17054b4148e9SMarcel Holtmann */ 17064b4148e9SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 17074b4148e9SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 17084b4148e9SMarcel Holtmann &dut_mode_fops); 17094b4148e9SMarcel Holtmann } 17104b4148e9SMarcel Holtmann 17112177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 17122177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 17132177bab5SJohan Hedberg * first stage init. 17142177bab5SJohan Hedberg */ 17152177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 17162177bab5SJohan Hedberg return 0; 17172177bab5SJohan Hedberg 17182177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 17192177bab5SJohan Hedberg if (err < 0) 17202177bab5SJohan Hedberg return err; 17212177bab5SJohan Hedberg 17225d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 17235d4e7e8dSJohan Hedberg if (err < 0) 17245d4e7e8dSJohan Hedberg return err; 17255d4e7e8dSJohan Hedberg 1726baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 1727baf27f6eSMarcel Holtmann if (err < 0) 1728baf27f6eSMarcel Holtmann return err; 1729baf27f6eSMarcel Holtmann 1730baf27f6eSMarcel Holtmann /* Only create debugfs entries during the initial setup 1731baf27f6eSMarcel Holtmann * phase and not every time the controller gets powered on. 1732baf27f6eSMarcel Holtmann */ 1733baf27f6eSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 1734baf27f6eSMarcel Holtmann return 0; 1735baf27f6eSMarcel Holtmann 1736dfb826a8SMarcel Holtmann debugfs_create_file("features", 0444, hdev->debugfs, hdev, 1737dfb826a8SMarcel Holtmann &features_fops); 1738ceeb3bc0SMarcel Holtmann debugfs_create_u16("manufacturer", 0444, hdev->debugfs, 1739ceeb3bc0SMarcel Holtmann &hdev->manufacturer); 1740ceeb3bc0SMarcel Holtmann debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver); 1741ceeb3bc0SMarcel Holtmann debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev); 174270afe0b8SMarcel Holtmann debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev, 174370afe0b8SMarcel Holtmann &blacklist_fops); 17446659358eSJohan Hedberg debugfs_create_file("whitelist", 0444, hdev->debugfs, hdev, 17456659358eSJohan Hedberg &whitelist_fops); 174647219839SMarcel Holtmann debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 174747219839SMarcel Holtmann 174831ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev, 174931ad1691SAndrzej Kaczmarek &conn_info_min_age_fops); 175031ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev, 175131ad1691SAndrzej Kaczmarek &conn_info_max_age_fops); 175231ad1691SAndrzej Kaczmarek 1753baf27f6eSMarcel Holtmann if (lmp_bredr_capable(hdev)) { 1754baf27f6eSMarcel Holtmann debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, 1755baf27f6eSMarcel Holtmann hdev, &inquiry_cache_fops); 175602d08d15SMarcel Holtmann debugfs_create_file("link_keys", 0400, hdev->debugfs, 175702d08d15SMarcel Holtmann hdev, &link_keys_fops); 1758babdbb3cSMarcel Holtmann debugfs_create_file("dev_class", 0444, hdev->debugfs, 1759babdbb3cSMarcel Holtmann hdev, &dev_class_fops); 1760041000b9SMarcel Holtmann debugfs_create_file("voice_setting", 0444, hdev->debugfs, 1761041000b9SMarcel Holtmann hdev, &voice_setting_fops); 1762baf27f6eSMarcel Holtmann } 1763baf27f6eSMarcel Holtmann 176406f5b778SMarcel Holtmann if (lmp_ssp_capable(hdev)) { 1765ebd1e33bSMarcel Holtmann debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 1766ebd1e33bSMarcel Holtmann hdev, &auto_accept_delay_fops); 17675afeac14SMarcel Holtmann debugfs_create_file("force_sc_support", 0644, hdev->debugfs, 17685afeac14SMarcel Holtmann hdev, &force_sc_support_fops); 1769134c2a89SMarcel Holtmann debugfs_create_file("sc_only_mode", 0444, hdev->debugfs, 1770134c2a89SMarcel Holtmann hdev, &sc_only_mode_fops); 177106f5b778SMarcel Holtmann } 1772ebd1e33bSMarcel Holtmann 17732bfa3531SMarcel Holtmann if (lmp_sniff_capable(hdev)) { 17742bfa3531SMarcel Holtmann debugfs_create_file("idle_timeout", 0644, hdev->debugfs, 17752bfa3531SMarcel Holtmann hdev, &idle_timeout_fops); 17762bfa3531SMarcel Holtmann debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs, 17772bfa3531SMarcel Holtmann hdev, &sniff_min_interval_fops); 17782bfa3531SMarcel Holtmann debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs, 17792bfa3531SMarcel Holtmann hdev, &sniff_max_interval_fops); 17802bfa3531SMarcel Holtmann } 17812bfa3531SMarcel Holtmann 1782d0f729b8SMarcel Holtmann if (lmp_le_capable(hdev)) { 1783ac345813SMarcel Holtmann debugfs_create_file("identity", 0400, hdev->debugfs, 1784ac345813SMarcel Holtmann hdev, &identity_fops); 1785ac345813SMarcel Holtmann debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, 1786ac345813SMarcel Holtmann hdev, &rpa_timeout_fops); 17877a4cd51dSMarcel Holtmann debugfs_create_file("random_address", 0444, hdev->debugfs, 17887a4cd51dSMarcel Holtmann hdev, &random_address_fops); 1789e7b8fc92SMarcel Holtmann debugfs_create_file("static_address", 0444, hdev->debugfs, 1790e7b8fc92SMarcel Holtmann hdev, &static_address_fops); 1791b32bba6cSMarcel Holtmann 1792b32bba6cSMarcel Holtmann /* For controllers with a public address, provide a debug 1793b32bba6cSMarcel Holtmann * option to force the usage of the configured static 1794b32bba6cSMarcel Holtmann * address. By default the public address is used. 1795b32bba6cSMarcel Holtmann */ 1796b32bba6cSMarcel Holtmann if (bacmp(&hdev->bdaddr, BDADDR_ANY)) 1797b32bba6cSMarcel Holtmann debugfs_create_file("force_static_address", 0644, 1798b32bba6cSMarcel Holtmann hdev->debugfs, hdev, 1799b32bba6cSMarcel Holtmann &force_static_address_fops); 1800b32bba6cSMarcel Holtmann 1801b32bba6cSMarcel Holtmann debugfs_create_u8("white_list_size", 0444, hdev->debugfs, 1802b32bba6cSMarcel Holtmann &hdev->le_white_list_size); 1803d2ab0ac1SMarcel Holtmann debugfs_create_file("white_list", 0444, hdev->debugfs, hdev, 1804d2ab0ac1SMarcel Holtmann &white_list_fops); 18053698d704SMarcel Holtmann debugfs_create_file("identity_resolving_keys", 0400, 18063698d704SMarcel Holtmann hdev->debugfs, hdev, 18073698d704SMarcel Holtmann &identity_resolving_keys_fops); 18088f8625cdSMarcel Holtmann debugfs_create_file("long_term_keys", 0400, hdev->debugfs, 18098f8625cdSMarcel Holtmann hdev, &long_term_keys_fops); 18104e70c7e7SMarcel Holtmann debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, 18114e70c7e7SMarcel Holtmann hdev, &conn_min_interval_fops); 18124e70c7e7SMarcel Holtmann debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, 18134e70c7e7SMarcel Holtmann hdev, &conn_max_interval_fops); 1814816a93d1SMarcel Holtmann debugfs_create_file("conn_latency", 0644, hdev->debugfs, 1815816a93d1SMarcel Holtmann hdev, &conn_latency_fops); 1816f1649577SMarcel Holtmann debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, 1817f1649577SMarcel Holtmann hdev, &supervision_timeout_fops); 18183f959d46SMarcel Holtmann debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, 18193f959d46SMarcel Holtmann hdev, &adv_channel_map_fops); 18200b3c7d37SMarcel Holtmann debugfs_create_file("device_list", 0444, hdev->debugfs, hdev, 18210b3c7d37SMarcel Holtmann &device_list_fops); 1822b9a7a61eSLukasz Rymanowski debugfs_create_u16("discov_interleaved_timeout", 0644, 1823b9a7a61eSLukasz Rymanowski hdev->debugfs, 1824b9a7a61eSLukasz Rymanowski &hdev->discov_interleaved_timeout); 1825d0f729b8SMarcel Holtmann } 1826e7b8fc92SMarcel Holtmann 1827baf27f6eSMarcel Holtmann return 0; 18282177bab5SJohan Hedberg } 18292177bab5SJohan Hedberg 18300ebca7d6SMarcel Holtmann static void hci_init0_req(struct hci_request *req, unsigned long opt) 18310ebca7d6SMarcel Holtmann { 18320ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 18330ebca7d6SMarcel Holtmann 18340ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 18350ebca7d6SMarcel Holtmann 18360ebca7d6SMarcel Holtmann /* Reset */ 18370ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 18380ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 18390ebca7d6SMarcel Holtmann 18400ebca7d6SMarcel Holtmann /* Read Local Version */ 18410ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 18420ebca7d6SMarcel Holtmann 18430ebca7d6SMarcel Holtmann /* Read BD Address */ 18440ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 18450ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 18460ebca7d6SMarcel Holtmann } 18470ebca7d6SMarcel Holtmann 18480ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 18490ebca7d6SMarcel Holtmann { 18500ebca7d6SMarcel Holtmann int err; 18510ebca7d6SMarcel Holtmann 1852cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 1853cc78b44bSMarcel Holtmann return 0; 1854cc78b44bSMarcel Holtmann 18550ebca7d6SMarcel Holtmann err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT); 18560ebca7d6SMarcel Holtmann if (err < 0) 18570ebca7d6SMarcel Holtmann return err; 18580ebca7d6SMarcel Holtmann 18590ebca7d6SMarcel Holtmann return 0; 18600ebca7d6SMarcel Holtmann } 18610ebca7d6SMarcel Holtmann 186242c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 18631da177e4SLinus Torvalds { 18641da177e4SLinus Torvalds __u8 scan = opt; 18651da177e4SLinus Torvalds 186642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 18671da177e4SLinus Torvalds 18681da177e4SLinus Torvalds /* Inquiry and Page scans */ 186942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 18701da177e4SLinus Torvalds } 18711da177e4SLinus Torvalds 187242c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 18731da177e4SLinus Torvalds { 18741da177e4SLinus Torvalds __u8 auth = opt; 18751da177e4SLinus Torvalds 187642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 18771da177e4SLinus Torvalds 18781da177e4SLinus Torvalds /* Authentication */ 187942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 18801da177e4SLinus Torvalds } 18811da177e4SLinus Torvalds 188242c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 18831da177e4SLinus Torvalds { 18841da177e4SLinus Torvalds __u8 encrypt = opt; 18851da177e4SLinus Torvalds 188642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 18871da177e4SLinus Torvalds 1888e4e8e37cSMarcel Holtmann /* Encryption */ 188942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 18901da177e4SLinus Torvalds } 18911da177e4SLinus Torvalds 189242c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1893e4e8e37cSMarcel Holtmann { 1894e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1895e4e8e37cSMarcel Holtmann 189642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1897e4e8e37cSMarcel Holtmann 1898e4e8e37cSMarcel Holtmann /* Default link policy */ 189942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1900e4e8e37cSMarcel Holtmann } 1901e4e8e37cSMarcel Holtmann 19021da177e4SLinus Torvalds /* Get HCI device by index. 19031da177e4SLinus Torvalds * Device is held on return. */ 19041da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 19051da177e4SLinus Torvalds { 19068035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 19071da177e4SLinus Torvalds 19081da177e4SLinus Torvalds BT_DBG("%d", index); 19091da177e4SLinus Torvalds 19101da177e4SLinus Torvalds if (index < 0) 19111da177e4SLinus Torvalds return NULL; 19121da177e4SLinus Torvalds 19131da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 19148035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 19151da177e4SLinus Torvalds if (d->id == index) { 19161da177e4SLinus Torvalds hdev = hci_dev_hold(d); 19171da177e4SLinus Torvalds break; 19181da177e4SLinus Torvalds } 19191da177e4SLinus Torvalds } 19201da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 19211da177e4SLinus Torvalds return hdev; 19221da177e4SLinus Torvalds } 19231da177e4SLinus Torvalds 19241da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1925ff9ef578SJohan Hedberg 192630dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 192730dc78e1SJohan Hedberg { 192830dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 192930dc78e1SJohan Hedberg 19306fbe195dSAndre Guedes switch (discov->state) { 1931343f935bSAndre Guedes case DISCOVERY_FINDING: 19326fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 193330dc78e1SJohan Hedberg return true; 193430dc78e1SJohan Hedberg 19356fbe195dSAndre Guedes default: 193630dc78e1SJohan Hedberg return false; 193730dc78e1SJohan Hedberg } 19386fbe195dSAndre Guedes } 193930dc78e1SJohan Hedberg 1940ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1941ff9ef578SJohan Hedberg { 1942bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 1943bb3e0a33SJohan Hedberg 1944ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1945ff9ef578SJohan Hedberg 1946bb3e0a33SJohan Hedberg if (old_state == state) 1947ff9ef578SJohan Hedberg return; 1948ff9ef578SJohan Hedberg 1949bb3e0a33SJohan Hedberg hdev->discovery.state = state; 1950bb3e0a33SJohan Hedberg 1951ff9ef578SJohan Hedberg switch (state) { 1952ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1953c54c3860SAndre Guedes hci_update_background_scan(hdev); 1954c54c3860SAndre Guedes 1955bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1956ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1957ff9ef578SJohan Hedberg break; 1958ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1959ff9ef578SJohan Hedberg break; 1960343f935bSAndre Guedes case DISCOVERY_FINDING: 1961ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1962ff9ef578SJohan Hedberg break; 196330dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 196430dc78e1SJohan Hedberg break; 1965ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1966ff9ef578SJohan Hedberg break; 1967ff9ef578SJohan Hedberg } 1968ff9ef578SJohan Hedberg } 1969ff9ef578SJohan Hedberg 19701f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 19711da177e4SLinus Torvalds { 197230883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1973b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 19741da177e4SLinus Torvalds 1975561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1976561aafbcSJohan Hedberg list_del(&p->all); 1977b57c1a56SJohan Hedberg kfree(p); 19781da177e4SLinus Torvalds } 1979561aafbcSJohan Hedberg 1980561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1981561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 19821da177e4SLinus Torvalds } 19831da177e4SLinus Torvalds 1984a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1985a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 19861da177e4SLinus Torvalds { 198730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 19881da177e4SLinus Torvalds struct inquiry_entry *e; 19891da177e4SLinus Torvalds 19906ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 19911da177e4SLinus Torvalds 1992561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 19931da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 19941da177e4SLinus Torvalds return e; 19951da177e4SLinus Torvalds } 19961da177e4SLinus Torvalds 1997b57c1a56SJohan Hedberg return NULL; 1998b57c1a56SJohan Hedberg } 1999b57c1a56SJohan Hedberg 2000561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 2001561aafbcSJohan Hedberg bdaddr_t *bdaddr) 2002561aafbcSJohan Hedberg { 200330883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2004561aafbcSJohan Hedberg struct inquiry_entry *e; 2005561aafbcSJohan Hedberg 20066ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 2007561aafbcSJohan Hedberg 2008561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 2009561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 2010561aafbcSJohan Hedberg return e; 2011561aafbcSJohan Hedberg } 2012561aafbcSJohan Hedberg 2013561aafbcSJohan Hedberg return NULL; 2014561aafbcSJohan Hedberg } 2015561aafbcSJohan Hedberg 201630dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 201730dc78e1SJohan Hedberg bdaddr_t *bdaddr, 201830dc78e1SJohan Hedberg int state) 201930dc78e1SJohan Hedberg { 202030dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 202130dc78e1SJohan Hedberg struct inquiry_entry *e; 202230dc78e1SJohan Hedberg 20236ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 202430dc78e1SJohan Hedberg 202530dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 202630dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 202730dc78e1SJohan Hedberg return e; 202830dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 202930dc78e1SJohan Hedberg return e; 203030dc78e1SJohan Hedberg } 203130dc78e1SJohan Hedberg 203230dc78e1SJohan Hedberg return NULL; 203330dc78e1SJohan Hedberg } 203430dc78e1SJohan Hedberg 2035a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 2036a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 2037a3d4e20aSJohan Hedberg { 2038a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2039a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 2040a3d4e20aSJohan Hedberg struct inquiry_entry *p; 2041a3d4e20aSJohan Hedberg 2042a3d4e20aSJohan Hedberg list_del(&ie->list); 2043a3d4e20aSJohan Hedberg 2044a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 2045a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 2046a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 2047a3d4e20aSJohan Hedberg break; 2048a3d4e20aSJohan Hedberg pos = &p->list; 2049a3d4e20aSJohan Hedberg } 2050a3d4e20aSJohan Hedberg 2051a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 2052a3d4e20aSJohan Hedberg } 2053a3d4e20aSJohan Hedberg 2054af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 2055af58925cSMarcel Holtmann bool name_known) 20561da177e4SLinus Torvalds { 205730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 205870f23020SAndrei Emeltchenko struct inquiry_entry *ie; 2059af58925cSMarcel Holtmann u32 flags = 0; 20601da177e4SLinus Torvalds 20616ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 20621da177e4SLinus Torvalds 20632b2fec4dSSzymon Janc hci_remove_remote_oob_data(hdev, &data->bdaddr); 20642b2fec4dSSzymon Janc 2065af58925cSMarcel Holtmann if (!data->ssp_mode) 2066af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 2067388fc8faSJohan Hedberg 206870f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 2069a3d4e20aSJohan Hedberg if (ie) { 2070af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 2071af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 2072388fc8faSJohan Hedberg 2073a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 2074a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 2075a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 2076a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 2077a3d4e20aSJohan Hedberg } 2078a3d4e20aSJohan Hedberg 2079561aafbcSJohan Hedberg goto update; 2080a3d4e20aSJohan Hedberg } 2081561aafbcSJohan Hedberg 20821da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 208370f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 2084af58925cSMarcel Holtmann if (!ie) { 2085af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 2086af58925cSMarcel Holtmann goto done; 2087af58925cSMarcel Holtmann } 208870f23020SAndrei Emeltchenko 2089561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 2090561aafbcSJohan Hedberg 2091561aafbcSJohan Hedberg if (name_known) { 2092561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2093561aafbcSJohan Hedberg } else { 2094561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 2095561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 2096561aafbcSJohan Hedberg } 2097561aafbcSJohan Hedberg 2098561aafbcSJohan Hedberg update: 2099561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 2100561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 2101561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2102561aafbcSJohan Hedberg list_del(&ie->list); 21031da177e4SLinus Torvalds } 21041da177e4SLinus Torvalds 210570f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 210670f23020SAndrei Emeltchenko ie->timestamp = jiffies; 21071da177e4SLinus Torvalds cache->timestamp = jiffies; 21083175405bSJohan Hedberg 21093175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 2110af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 21113175405bSJohan Hedberg 2112af58925cSMarcel Holtmann done: 2113af58925cSMarcel Holtmann return flags; 21141da177e4SLinus Torvalds } 21151da177e4SLinus Torvalds 21161da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 21171da177e4SLinus Torvalds { 211830883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 21191da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 21201da177e4SLinus Torvalds struct inquiry_entry *e; 21211da177e4SLinus Torvalds int copied = 0; 21221da177e4SLinus Torvalds 2123561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 21241da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 2125b57c1a56SJohan Hedberg 2126b57c1a56SJohan Hedberg if (copied >= num) 2127b57c1a56SJohan Hedberg break; 2128b57c1a56SJohan Hedberg 21291da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 21301da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 21311da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 21321da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 21331da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 21341da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 2135b57c1a56SJohan Hedberg 21361da177e4SLinus Torvalds info++; 2137b57c1a56SJohan Hedberg copied++; 21381da177e4SLinus Torvalds } 21391da177e4SLinus Torvalds 21401da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 21411da177e4SLinus Torvalds return copied; 21421da177e4SLinus Torvalds } 21431da177e4SLinus Torvalds 214442c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 21451da177e4SLinus Torvalds { 21461da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 214742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 21481da177e4SLinus Torvalds struct hci_cp_inquiry cp; 21491da177e4SLinus Torvalds 21501da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 21511da177e4SLinus Torvalds 21521da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 21531da177e4SLinus Torvalds return; 21541da177e4SLinus Torvalds 21551da177e4SLinus Torvalds /* Start Inquiry */ 21561da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 21571da177e4SLinus Torvalds cp.length = ir->length; 21581da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 215942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 21601da177e4SLinus Torvalds } 21611da177e4SLinus Torvalds 21623e13fa1eSAndre Guedes static int wait_inquiry(void *word) 21633e13fa1eSAndre Guedes { 21643e13fa1eSAndre Guedes schedule(); 21653e13fa1eSAndre Guedes return signal_pending(current); 21663e13fa1eSAndre Guedes } 21673e13fa1eSAndre Guedes 21681da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 21691da177e4SLinus Torvalds { 21701da177e4SLinus Torvalds __u8 __user *ptr = arg; 21711da177e4SLinus Torvalds struct hci_inquiry_req ir; 21721da177e4SLinus Torvalds struct hci_dev *hdev; 21731da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 21741da177e4SLinus Torvalds long timeo; 21751da177e4SLinus Torvalds __u8 *buf; 21761da177e4SLinus Torvalds 21771da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 21781da177e4SLinus Torvalds return -EFAULT; 21791da177e4SLinus Torvalds 21805a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 21815a08ecceSAndrei Emeltchenko if (!hdev) 21821da177e4SLinus Torvalds return -ENODEV; 21831da177e4SLinus Torvalds 21840736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 21850736cfa8SMarcel Holtmann err = -EBUSY; 21860736cfa8SMarcel Holtmann goto done; 21870736cfa8SMarcel Holtmann } 21880736cfa8SMarcel Holtmann 21894a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2190fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2191fee746b0SMarcel Holtmann goto done; 2192fee746b0SMarcel Holtmann } 2193fee746b0SMarcel Holtmann 21945b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 21955b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 21965b69bef5SMarcel Holtmann goto done; 21975b69bef5SMarcel Holtmann } 21985b69bef5SMarcel Holtmann 219956f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 220056f87901SJohan Hedberg err = -EOPNOTSUPP; 220156f87901SJohan Hedberg goto done; 220256f87901SJohan Hedberg } 220356f87901SJohan Hedberg 220409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 22051da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 2206a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 22071f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 22081da177e4SLinus Torvalds do_inquiry = 1; 22091da177e4SLinus Torvalds } 221009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 22111da177e4SLinus Torvalds 221204837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 221370f23020SAndrei Emeltchenko 221470f23020SAndrei Emeltchenko if (do_inquiry) { 221501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 221601178cd4SJohan Hedberg timeo); 221770f23020SAndrei Emeltchenko if (err < 0) 22181da177e4SLinus Torvalds goto done; 22193e13fa1eSAndre Guedes 22203e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 22213e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 22223e13fa1eSAndre Guedes */ 22233e13fa1eSAndre Guedes if (wait_on_bit(&hdev->flags, HCI_INQUIRY, wait_inquiry, 22243e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 22253e13fa1eSAndre Guedes return -EINTR; 222670f23020SAndrei Emeltchenko } 22271da177e4SLinus Torvalds 22288fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 22298fc9ced3SGustavo Padovan * 255 entries 22308fc9ced3SGustavo Padovan */ 22311da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 22321da177e4SLinus Torvalds 22331da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 22341da177e4SLinus Torvalds * copy it to the user space. 22351da177e4SLinus Torvalds */ 223670f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 223770f23020SAndrei Emeltchenko if (!buf) { 22381da177e4SLinus Torvalds err = -ENOMEM; 22391da177e4SLinus Torvalds goto done; 22401da177e4SLinus Torvalds } 22411da177e4SLinus Torvalds 224209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 22431da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 224409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 22451da177e4SLinus Torvalds 22461da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 22471da177e4SLinus Torvalds 22481da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 22491da177e4SLinus Torvalds ptr += sizeof(ir); 22501da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 22511da177e4SLinus Torvalds ir.num_rsp)) 22521da177e4SLinus Torvalds err = -EFAULT; 22531da177e4SLinus Torvalds } else 22541da177e4SLinus Torvalds err = -EFAULT; 22551da177e4SLinus Torvalds 22561da177e4SLinus Torvalds kfree(buf); 22571da177e4SLinus Torvalds 22581da177e4SLinus Torvalds done: 22591da177e4SLinus Torvalds hci_dev_put(hdev); 22601da177e4SLinus Torvalds return err; 22611da177e4SLinus Torvalds } 22621da177e4SLinus Torvalds 2263cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 22641da177e4SLinus Torvalds { 22651da177e4SLinus Torvalds int ret = 0; 22661da177e4SLinus Torvalds 22671da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 22681da177e4SLinus Torvalds 22691da177e4SLinus Torvalds hci_req_lock(hdev); 22701da177e4SLinus Torvalds 227194324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 227294324962SJohan Hovold ret = -ENODEV; 227394324962SJohan Hovold goto done; 227494324962SJohan Hovold } 227594324962SJohan Hovold 2276d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2277d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 2278a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 2279a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 2280bf543036SJohan Hedberg */ 2281a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 2282611b30f7SMarcel Holtmann ret = -ERFKILL; 2283611b30f7SMarcel Holtmann goto done; 2284611b30f7SMarcel Holtmann } 2285611b30f7SMarcel Holtmann 2286a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 2287a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 2288a5c8f270SMarcel Holtmann * be able to determine if there is a public address 2289a5c8f270SMarcel Holtmann * or not. 2290a5c8f270SMarcel Holtmann * 2291c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 2292c6beca0eSMarcel Holtmann * if a public address or static random address is 2293c6beca0eSMarcel Holtmann * available. 2294c6beca0eSMarcel Holtmann * 2295a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 2296a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 2297a5c8f270SMarcel Holtmann */ 2298c6beca0eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 2299c6beca0eSMarcel Holtmann hdev->dev_type == HCI_BREDR && 2300a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2301a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 2302a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 2303a5c8f270SMarcel Holtmann goto done; 2304a5c8f270SMarcel Holtmann } 2305a5c8f270SMarcel Holtmann } 2306a5c8f270SMarcel Holtmann 23071da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 23081da177e4SLinus Torvalds ret = -EALREADY; 23091da177e4SLinus Torvalds goto done; 23101da177e4SLinus Torvalds } 23111da177e4SLinus Torvalds 23121da177e4SLinus Torvalds if (hdev->open(hdev)) { 23131da177e4SLinus Torvalds ret = -EIO; 23141da177e4SLinus Torvalds goto done; 23151da177e4SLinus Torvalds } 23161da177e4SLinus Torvalds 23171da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 23181da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 2319f41c70c4SMarcel Holtmann 2320af202f84SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 2321af202f84SMarcel Holtmann if (hdev->setup) 2322f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 2323f41c70c4SMarcel Holtmann 2324af202f84SMarcel Holtmann /* The transport driver can set these quirks before 2325af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 2326af202f84SMarcel Holtmann * 2327af202f84SMarcel Holtmann * In case any of them is set, the controller has to 2328af202f84SMarcel Holtmann * start up as unconfigured. 2329af202f84SMarcel Holtmann */ 2330eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 2331eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 233289bc22d2SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 23330ebca7d6SMarcel Holtmann 23340ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 23350ebca7d6SMarcel Holtmann * read at least the version information provided by 23360ebca7d6SMarcel Holtmann * the Read Local Version Information command. 23370ebca7d6SMarcel Holtmann * 23380ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 23390ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 23400ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 23410ebca7d6SMarcel Holtmann */ 23420ebca7d6SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 23430ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 234489bc22d2SMarcel Holtmann } 234589bc22d2SMarcel Holtmann 23469713c17bSMarcel Holtmann if (test_bit(HCI_CONFIG, &hdev->dev_flags)) { 23479713c17bSMarcel Holtmann /* If public address change is configured, ensure that 23489713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 23499713c17bSMarcel Holtmann * support changing the public address, fail the power 23509713c17bSMarcel Holtmann * on procedure. 235124c457e2SMarcel Holtmann */ 23529713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 23539713c17bSMarcel Holtmann hdev->set_bdaddr) 235424c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 235524c457e2SMarcel Holtmann else 235624c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 235724c457e2SMarcel Holtmann } 235824c457e2SMarcel Holtmann 2359f41c70c4SMarcel Holtmann if (!ret) { 23604a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 23610736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 23622177bab5SJohan Hedberg ret = __hci_init(hdev); 23631da177e4SLinus Torvalds } 23641da177e4SLinus Torvalds 2365f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 2366f41c70c4SMarcel Holtmann 23671da177e4SLinus Torvalds if (!ret) { 23681da177e4SLinus Torvalds hci_dev_hold(hdev); 2369d6bfd59cSJohan Hedberg set_bit(HCI_RPA_EXPIRED, &hdev->dev_flags); 23701da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 23711da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 2372bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2373d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags) && 23744a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 23750736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 23761514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 237709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2378744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 237909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 238056e5cb86SJohan Hedberg } 23811da177e4SLinus Torvalds } else { 23821da177e4SLinus Torvalds /* Init failed, cleanup */ 23833eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2384c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 2385b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 23861da177e4SLinus Torvalds 23871da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 23881da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 23891da177e4SLinus Torvalds 23901da177e4SLinus Torvalds if (hdev->flush) 23911da177e4SLinus Torvalds hdev->flush(hdev); 23921da177e4SLinus Torvalds 23931da177e4SLinus Torvalds if (hdev->sent_cmd) { 23941da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 23951da177e4SLinus Torvalds hdev->sent_cmd = NULL; 23961da177e4SLinus Torvalds } 23971da177e4SLinus Torvalds 23981da177e4SLinus Torvalds hdev->close(hdev); 2399fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 24001da177e4SLinus Torvalds } 24011da177e4SLinus Torvalds 24021da177e4SLinus Torvalds done: 24031da177e4SLinus Torvalds hci_req_unlock(hdev); 24041da177e4SLinus Torvalds return ret; 24051da177e4SLinus Torvalds } 24061da177e4SLinus Torvalds 2407cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 2408cbed0ca1SJohan Hedberg 2409cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 2410cbed0ca1SJohan Hedberg { 2411cbed0ca1SJohan Hedberg struct hci_dev *hdev; 2412cbed0ca1SJohan Hedberg int err; 2413cbed0ca1SJohan Hedberg 2414cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 2415cbed0ca1SJohan Hedberg if (!hdev) 2416cbed0ca1SJohan Hedberg return -ENODEV; 2417cbed0ca1SJohan Hedberg 24184a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 2419fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 2420fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 2421fee746b0SMarcel Holtmann * possible. 2422fee746b0SMarcel Holtmann * 2423fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 2424fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 2425fee746b0SMarcel Holtmann * open the device. 2426fee746b0SMarcel Holtmann */ 24274a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 2428fee746b0SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 2429fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2430fee746b0SMarcel Holtmann goto done; 2431fee746b0SMarcel Holtmann } 2432fee746b0SMarcel Holtmann 2433e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 2434e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 2435e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 2436e1d08f40SJohan Hedberg * completed. 2437e1d08f40SJohan Hedberg */ 2438e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 2439e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 2440e1d08f40SJohan Hedberg 2441a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 2442a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 2443a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 2444a5c8f270SMarcel Holtmann */ 2445e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 2446e1d08f40SJohan Hedberg 244712aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 244812aa4f0aSMarcel Holtmann * are brought up using legacy ioctl, set the HCI_PAIRABLE bit 244912aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 245012aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 245112aa4f0aSMarcel Holtmann * to explicitly enable it. 245212aa4f0aSMarcel Holtmann */ 245312aa4f0aSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 245412aa4f0aSMarcel Holtmann !test_bit(HCI_MGMT, &hdev->dev_flags)) 245512aa4f0aSMarcel Holtmann set_bit(HCI_PAIRABLE, &hdev->dev_flags); 245612aa4f0aSMarcel Holtmann 2457cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 2458cbed0ca1SJohan Hedberg 2459fee746b0SMarcel Holtmann done: 2460cbed0ca1SJohan Hedberg hci_dev_put(hdev); 2461cbed0ca1SJohan Hedberg return err; 2462cbed0ca1SJohan Hedberg } 2463cbed0ca1SJohan Hedberg 2464d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 2465d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 2466d7347f3cSJohan Hedberg { 2467d7347f3cSJohan Hedberg struct hci_conn_params *p; 2468d7347f3cSJohan Hedberg 2469d7347f3cSJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) 2470d7347f3cSJohan Hedberg list_del_init(&p->action); 2471d7347f3cSJohan Hedberg 2472d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 2473d7347f3cSJohan Hedberg } 2474d7347f3cSJohan Hedberg 24751da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 24761da177e4SLinus Torvalds { 24771da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 24781da177e4SLinus Torvalds 247978c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 248078c04c0bSVinicius Costa Gomes 24811da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 24821da177e4SLinus Torvalds hci_req_lock(hdev); 24831da177e4SLinus Torvalds 24841da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 248565cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 24861da177e4SLinus Torvalds hci_req_unlock(hdev); 24871da177e4SLinus Torvalds return 0; 24881da177e4SLinus Torvalds } 24891da177e4SLinus Torvalds 24903eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 24913eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2492b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 24931da177e4SLinus Torvalds 249416ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 2495e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 249616ab91abSJohan Hedberg hdev->discov_timeout = 0; 24975e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 2498310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 249916ab91abSJohan Hedberg } 250016ab91abSJohan Hedberg 2501a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 25027d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 25037d78525dSJohan Hedberg 25047ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 25054518bb0fSJohan Hedberg 25064518bb0fSJohan Hedberg if (test_bit(HCI_MGMT, &hdev->dev_flags)) 2507d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 25087ba8b4beSAndre Guedes 250909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 25101f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 25111da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 2512d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 251309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 25141da177e4SLinus Torvalds 25151da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 25161da177e4SLinus Torvalds 25171da177e4SLinus Torvalds if (hdev->flush) 25181da177e4SLinus Torvalds hdev->flush(hdev); 25191da177e4SLinus Torvalds 25201da177e4SLinus Torvalds /* Reset device */ 25211da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 25221da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 25234a964404SMarcel Holtmann if (!test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 25244a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 2525a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 25261da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 252701178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 25281da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 25291da177e4SLinus Torvalds } 25301da177e4SLinus Torvalds 2531c347b765SGustavo F. Padovan /* flush cmd work */ 2532c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 25331da177e4SLinus Torvalds 25341da177e4SLinus Torvalds /* Drop queues */ 25351da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 25361da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 25371da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 25381da177e4SLinus Torvalds 25391da177e4SLinus Torvalds /* Drop last sent command */ 25401da177e4SLinus Torvalds if (hdev->sent_cmd) { 254165cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 25421da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 25431da177e4SLinus Torvalds hdev->sent_cmd = NULL; 25441da177e4SLinus Torvalds } 25451da177e4SLinus Torvalds 2546b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 2547b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 2548b6ddb638SJohan Hedberg 25491da177e4SLinus Torvalds /* After this point our queues are empty 25501da177e4SLinus Torvalds * and no tasks are scheduled. */ 25511da177e4SLinus Torvalds hdev->close(hdev); 25521da177e4SLinus Torvalds 255335b973c9SJohan Hedberg /* Clear flags */ 2554fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 255535b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 255635b973c9SJohan Hedberg 255793c311a0SMarcel Holtmann if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 255893c311a0SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 255909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2560744cf19eSJohan Hedberg mgmt_powered(hdev, 0); 256109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 25628ee56540SMarcel Holtmann } 256393c311a0SMarcel Holtmann } 25645add6af8SJohan Hedberg 2565ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 2566536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 2567ced5c338SAndrei Emeltchenko 2568e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 256909b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 25707a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 2571e59fda8dSJohan Hedberg 25721da177e4SLinus Torvalds hci_req_unlock(hdev); 25731da177e4SLinus Torvalds 25741da177e4SLinus Torvalds hci_dev_put(hdev); 25751da177e4SLinus Torvalds return 0; 25761da177e4SLinus Torvalds } 25771da177e4SLinus Torvalds 25781da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 25791da177e4SLinus Torvalds { 25801da177e4SLinus Torvalds struct hci_dev *hdev; 25811da177e4SLinus Torvalds int err; 25821da177e4SLinus Torvalds 258370f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 258470f23020SAndrei Emeltchenko if (!hdev) 25851da177e4SLinus Torvalds return -ENODEV; 25868ee56540SMarcel Holtmann 25870736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 25880736cfa8SMarcel Holtmann err = -EBUSY; 25890736cfa8SMarcel Holtmann goto done; 25900736cfa8SMarcel Holtmann } 25910736cfa8SMarcel Holtmann 25928ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 25938ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 25948ee56540SMarcel Holtmann 25951da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 25968ee56540SMarcel Holtmann 25970736cfa8SMarcel Holtmann done: 25981da177e4SLinus Torvalds hci_dev_put(hdev); 25991da177e4SLinus Torvalds return err; 26001da177e4SLinus Torvalds } 26011da177e4SLinus Torvalds 26021da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 26031da177e4SLinus Torvalds { 26041da177e4SLinus Torvalds struct hci_dev *hdev; 26051da177e4SLinus Torvalds int ret = 0; 26061da177e4SLinus Torvalds 260770f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 260870f23020SAndrei Emeltchenko if (!hdev) 26091da177e4SLinus Torvalds return -ENODEV; 26101da177e4SLinus Torvalds 26111da177e4SLinus Torvalds hci_req_lock(hdev); 26121da177e4SLinus Torvalds 2613808a049eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 2614808a049eSMarcel Holtmann ret = -ENETDOWN; 26151da177e4SLinus Torvalds goto done; 2616808a049eSMarcel Holtmann } 26171da177e4SLinus Torvalds 26180736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 26190736cfa8SMarcel Holtmann ret = -EBUSY; 26200736cfa8SMarcel Holtmann goto done; 26210736cfa8SMarcel Holtmann } 26220736cfa8SMarcel Holtmann 26234a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2624fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2625fee746b0SMarcel Holtmann goto done; 2626fee746b0SMarcel Holtmann } 2627fee746b0SMarcel Holtmann 26281da177e4SLinus Torvalds /* Drop queues */ 26291da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 26301da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 26311da177e4SLinus Torvalds 263209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 26331f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 26341da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 263509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 26361da177e4SLinus Torvalds 26371da177e4SLinus Torvalds if (hdev->flush) 26381da177e4SLinus Torvalds hdev->flush(hdev); 26391da177e4SLinus Torvalds 26401da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 26416ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 26421da177e4SLinus Torvalds 264301178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 26441da177e4SLinus Torvalds 26451da177e4SLinus Torvalds done: 26461da177e4SLinus Torvalds hci_req_unlock(hdev); 26471da177e4SLinus Torvalds hci_dev_put(hdev); 26481da177e4SLinus Torvalds return ret; 26491da177e4SLinus Torvalds } 26501da177e4SLinus Torvalds 26511da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 26521da177e4SLinus Torvalds { 26531da177e4SLinus Torvalds struct hci_dev *hdev; 26541da177e4SLinus Torvalds int ret = 0; 26551da177e4SLinus Torvalds 265670f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 265770f23020SAndrei Emeltchenko if (!hdev) 26581da177e4SLinus Torvalds return -ENODEV; 26591da177e4SLinus Torvalds 26600736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 26610736cfa8SMarcel Holtmann ret = -EBUSY; 26620736cfa8SMarcel Holtmann goto done; 26630736cfa8SMarcel Holtmann } 26640736cfa8SMarcel Holtmann 26654a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2666fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2667fee746b0SMarcel Holtmann goto done; 2668fee746b0SMarcel Holtmann } 2669fee746b0SMarcel Holtmann 26701da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 26711da177e4SLinus Torvalds 26720736cfa8SMarcel Holtmann done: 26731da177e4SLinus Torvalds hci_dev_put(hdev); 26741da177e4SLinus Torvalds return ret; 26751da177e4SLinus Torvalds } 26761da177e4SLinus Torvalds 2677123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 2678123abc08SJohan Hedberg { 2679bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 2680123abc08SJohan Hedberg 2681123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 2682123abc08SJohan Hedberg 2683123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 2684123abc08SJohan Hedberg conn_changed = !test_and_set_bit(HCI_CONNECTABLE, 2685123abc08SJohan Hedberg &hdev->dev_flags); 2686123abc08SJohan Hedberg else 2687123abc08SJohan Hedberg conn_changed = test_and_clear_bit(HCI_CONNECTABLE, 2688123abc08SJohan Hedberg &hdev->dev_flags); 2689123abc08SJohan Hedberg 2690bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 2691bc6d2d04SJohan Hedberg discov_changed = !test_and_set_bit(HCI_DISCOVERABLE, 2692bc6d2d04SJohan Hedberg &hdev->dev_flags); 2693bc6d2d04SJohan Hedberg } else { 2694bc6d2d04SJohan Hedberg clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 2695bc6d2d04SJohan Hedberg discov_changed = test_and_clear_bit(HCI_DISCOVERABLE, 2696bc6d2d04SJohan Hedberg &hdev->dev_flags); 2697bc6d2d04SJohan Hedberg } 2698bc6d2d04SJohan Hedberg 2699123abc08SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 2700123abc08SJohan Hedberg return; 2701123abc08SJohan Hedberg 2702bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 2703bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 2704bc6d2d04SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 2705bc6d2d04SJohan Hedberg 2706bc6d2d04SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 2707bc6d2d04SJohan Hedberg mgmt_update_adv_data(hdev); 2708bc6d2d04SJohan Hedberg 2709123abc08SJohan Hedberg mgmt_new_settings(hdev); 2710123abc08SJohan Hedberg } 2711bc6d2d04SJohan Hedberg } 2712123abc08SJohan Hedberg 27131da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 27141da177e4SLinus Torvalds { 27151da177e4SLinus Torvalds struct hci_dev *hdev; 27161da177e4SLinus Torvalds struct hci_dev_req dr; 27171da177e4SLinus Torvalds int err = 0; 27181da177e4SLinus Torvalds 27191da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 27201da177e4SLinus Torvalds return -EFAULT; 27211da177e4SLinus Torvalds 272270f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 272370f23020SAndrei Emeltchenko if (!hdev) 27241da177e4SLinus Torvalds return -ENODEV; 27251da177e4SLinus Torvalds 27260736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 27270736cfa8SMarcel Holtmann err = -EBUSY; 27280736cfa8SMarcel Holtmann goto done; 27290736cfa8SMarcel Holtmann } 27300736cfa8SMarcel Holtmann 27314a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2732fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2733fee746b0SMarcel Holtmann goto done; 2734fee746b0SMarcel Holtmann } 2735fee746b0SMarcel Holtmann 27365b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 27375b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 27385b69bef5SMarcel Holtmann goto done; 27395b69bef5SMarcel Holtmann } 27405b69bef5SMarcel Holtmann 274156f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 274256f87901SJohan Hedberg err = -EOPNOTSUPP; 274356f87901SJohan Hedberg goto done; 274456f87901SJohan Hedberg } 274556f87901SJohan Hedberg 27461da177e4SLinus Torvalds switch (cmd) { 27471da177e4SLinus Torvalds case HCISETAUTH: 274801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 27495f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27501da177e4SLinus Torvalds break; 27511da177e4SLinus Torvalds 27521da177e4SLinus Torvalds case HCISETENCRYPT: 27531da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 27541da177e4SLinus Torvalds err = -EOPNOTSUPP; 27551da177e4SLinus Torvalds break; 27561da177e4SLinus Torvalds } 27571da177e4SLinus Torvalds 27581da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 27591da177e4SLinus Torvalds /* Auth must be enabled first */ 276001178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 27615f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27621da177e4SLinus Torvalds if (err) 27631da177e4SLinus Torvalds break; 27641da177e4SLinus Torvalds } 27651da177e4SLinus Torvalds 276601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 27675f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27681da177e4SLinus Torvalds break; 27691da177e4SLinus Torvalds 27701da177e4SLinus Torvalds case HCISETSCAN: 277101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 27725f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 277391a668b0SJohan Hedberg 2774bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 2775bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 277691a668b0SJohan Hedberg */ 2777123abc08SJohan Hedberg if (!err) 2778123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 27791da177e4SLinus Torvalds break; 27801da177e4SLinus Torvalds 27811da177e4SLinus Torvalds case HCISETLINKPOL: 278201178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 27835f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27841da177e4SLinus Torvalds break; 27851da177e4SLinus Torvalds 27861da177e4SLinus Torvalds case HCISETLINKMODE: 2787e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 2788e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 2789e4e8e37cSMarcel Holtmann break; 2790e4e8e37cSMarcel Holtmann 2791e4e8e37cSMarcel Holtmann case HCISETPTYPE: 2792e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 27931da177e4SLinus Torvalds break; 27941da177e4SLinus Torvalds 27951da177e4SLinus Torvalds case HCISETACLMTU: 27961da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 27971da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 27981da177e4SLinus Torvalds break; 27991da177e4SLinus Torvalds 28001da177e4SLinus Torvalds case HCISETSCOMTU: 28011da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 28021da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 28031da177e4SLinus Torvalds break; 28041da177e4SLinus Torvalds 28051da177e4SLinus Torvalds default: 28061da177e4SLinus Torvalds err = -EINVAL; 28071da177e4SLinus Torvalds break; 28081da177e4SLinus Torvalds } 2809e4e8e37cSMarcel Holtmann 28100736cfa8SMarcel Holtmann done: 28111da177e4SLinus Torvalds hci_dev_put(hdev); 28121da177e4SLinus Torvalds return err; 28131da177e4SLinus Torvalds } 28141da177e4SLinus Torvalds 28151da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 28161da177e4SLinus Torvalds { 28178035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 28181da177e4SLinus Torvalds struct hci_dev_list_req *dl; 28191da177e4SLinus Torvalds struct hci_dev_req *dr; 28201da177e4SLinus Torvalds int n = 0, size, err; 28211da177e4SLinus Torvalds __u16 dev_num; 28221da177e4SLinus Torvalds 28231da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 28241da177e4SLinus Torvalds return -EFAULT; 28251da177e4SLinus Torvalds 28261da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 28271da177e4SLinus Torvalds return -EINVAL; 28281da177e4SLinus Torvalds 28291da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 28301da177e4SLinus Torvalds 283170f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 283270f23020SAndrei Emeltchenko if (!dl) 28331da177e4SLinus Torvalds return -ENOMEM; 28341da177e4SLinus Torvalds 28351da177e4SLinus Torvalds dr = dl->dev_req; 28361da177e4SLinus Torvalds 2837f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 28388035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 28392e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 28402e84d8dbSMarcel Holtmann 28412e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 28422e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 28432e84d8dbSMarcel Holtmann * device is actually down. 28442e84d8dbSMarcel Holtmann */ 28452e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 28462e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 2847c542a06cSJohan Hedberg 28481da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 28492e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 2850c542a06cSJohan Hedberg 28511da177e4SLinus Torvalds if (++n >= dev_num) 28521da177e4SLinus Torvalds break; 28531da177e4SLinus Torvalds } 2854f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 28551da177e4SLinus Torvalds 28561da177e4SLinus Torvalds dl->dev_num = n; 28571da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 28581da177e4SLinus Torvalds 28591da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 28601da177e4SLinus Torvalds kfree(dl); 28611da177e4SLinus Torvalds 28621da177e4SLinus Torvalds return err ? -EFAULT : 0; 28631da177e4SLinus Torvalds } 28641da177e4SLinus Torvalds 28651da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 28661da177e4SLinus Torvalds { 28671da177e4SLinus Torvalds struct hci_dev *hdev; 28681da177e4SLinus Torvalds struct hci_dev_info di; 28692e84d8dbSMarcel Holtmann unsigned long flags; 28701da177e4SLinus Torvalds int err = 0; 28711da177e4SLinus Torvalds 28721da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 28731da177e4SLinus Torvalds return -EFAULT; 28741da177e4SLinus Torvalds 287570f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 287670f23020SAndrei Emeltchenko if (!hdev) 28771da177e4SLinus Torvalds return -ENODEV; 28781da177e4SLinus Torvalds 28792e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 28802e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 28812e84d8dbSMarcel Holtmann * device is actually down. 28822e84d8dbSMarcel Holtmann */ 28832e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 28842e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 28852e84d8dbSMarcel Holtmann else 28862e84d8dbSMarcel Holtmann flags = hdev->flags; 2887ab81cbf9SJohan Hedberg 28881da177e4SLinus Torvalds strcpy(di.name, hdev->name); 28891da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 289060f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 28912e84d8dbSMarcel Holtmann di.flags = flags; 28921da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2893572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 28941da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 28951da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 28961da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 28971da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2898572c7f84SJohan Hedberg } else { 2899572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2900572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2901572c7f84SJohan Hedberg di.sco_mtu = 0; 2902572c7f84SJohan Hedberg di.sco_pkts = 0; 2903572c7f84SJohan Hedberg } 29041da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 29051da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 29061da177e4SLinus Torvalds 29071da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 29081da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 29091da177e4SLinus Torvalds 29101da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 29111da177e4SLinus Torvalds err = -EFAULT; 29121da177e4SLinus Torvalds 29131da177e4SLinus Torvalds hci_dev_put(hdev); 29141da177e4SLinus Torvalds 29151da177e4SLinus Torvalds return err; 29161da177e4SLinus Torvalds } 29171da177e4SLinus Torvalds 29181da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 29191da177e4SLinus Torvalds 2920611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2921611b30f7SMarcel Holtmann { 2922611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2923611b30f7SMarcel Holtmann 2924611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2925611b30f7SMarcel Holtmann 29260736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 29270736cfa8SMarcel Holtmann return -EBUSY; 29280736cfa8SMarcel Holtmann 29295e130367SJohan Hedberg if (blocked) { 29305e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 2931d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2932d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) 2933611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 29345e130367SJohan Hedberg } else { 29355e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 29365e130367SJohan Hedberg } 2937611b30f7SMarcel Holtmann 2938611b30f7SMarcel Holtmann return 0; 2939611b30f7SMarcel Holtmann } 2940611b30f7SMarcel Holtmann 2941611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2942611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2943611b30f7SMarcel Holtmann }; 2944611b30f7SMarcel Holtmann 2945ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2946ab81cbf9SJohan Hedberg { 2947ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 294896570ffcSJohan Hedberg int err; 2949ab81cbf9SJohan Hedberg 2950ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2951ab81cbf9SJohan Hedberg 2952cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 295396570ffcSJohan Hedberg if (err < 0) { 295496570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 2955ab81cbf9SJohan Hedberg return; 295696570ffcSJohan Hedberg } 2957ab81cbf9SJohan Hedberg 2958a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2959a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2960a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2961a5c8f270SMarcel Holtmann */ 2962a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 29634a964404SMarcel Holtmann test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) || 2964a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 2965a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2966a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2967bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2968bf543036SJohan Hedberg hci_dev_do_close(hdev); 2969bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 297019202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 297119202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2972bf543036SJohan Hedberg } 2973ab81cbf9SJohan Hedberg 2974fee746b0SMarcel Holtmann if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) { 29754a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 29764a964404SMarcel Holtmann * so that userspace can easily identify them. 29774a964404SMarcel Holtmann */ 29784a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 29794a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 29800602a8adSMarcel Holtmann 29810602a8adSMarcel Holtmann /* For fully configured devices, this will send 29820602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 29830602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 29840602a8adSMarcel Holtmann * 29850602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 29860602a8adSMarcel Holtmann * and no event will be send. 29870602a8adSMarcel Holtmann */ 2988744cf19eSJohan Hedberg mgmt_index_added(hdev); 2989d603b76bSMarcel Holtmann } else if (test_and_clear_bit(HCI_CONFIG, &hdev->dev_flags)) { 29905ea234d3SMarcel Holtmann /* When the controller is now configured, then it 29915ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 29925ea234d3SMarcel Holtmann */ 29935ea234d3SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 29945ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 29955ea234d3SMarcel Holtmann 2996d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2997d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 2998d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 2999d603b76bSMarcel Holtmann */ 3000d603b76bSMarcel Holtmann mgmt_index_added(hdev); 3001ab81cbf9SJohan Hedberg } 3002fee746b0SMarcel Holtmann } 3003ab81cbf9SJohan Hedberg 3004ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 3005ab81cbf9SJohan Hedberg { 30063243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 30073243553fSJohan Hedberg power_off.work); 3008ab81cbf9SJohan Hedberg 3009ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 3010ab81cbf9SJohan Hedberg 30118ee56540SMarcel Holtmann hci_dev_do_close(hdev); 3012ab81cbf9SJohan Hedberg } 3013ab81cbf9SJohan Hedberg 301416ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 301516ab91abSJohan Hedberg { 301616ab91abSJohan Hedberg struct hci_dev *hdev; 301716ab91abSJohan Hedberg 301816ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 301916ab91abSJohan Hedberg 302016ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 302116ab91abSJohan Hedberg 3022d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 302316ab91abSJohan Hedberg } 302416ab91abSJohan Hedberg 302535f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 30262aeb9a1aSJohan Hedberg { 30274821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 30282aeb9a1aSJohan Hedberg 30294821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 30304821002cSJohan Hedberg list_del(&uuid->list); 30312aeb9a1aSJohan Hedberg kfree(uuid); 30322aeb9a1aSJohan Hedberg } 30332aeb9a1aSJohan Hedberg } 30342aeb9a1aSJohan Hedberg 303535f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 303655ed8ca1SJohan Hedberg { 303755ed8ca1SJohan Hedberg struct list_head *p, *n; 303855ed8ca1SJohan Hedberg 303955ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 304055ed8ca1SJohan Hedberg struct link_key *key; 304155ed8ca1SJohan Hedberg 304255ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 304355ed8ca1SJohan Hedberg 304455ed8ca1SJohan Hedberg list_del(p); 304555ed8ca1SJohan Hedberg kfree(key); 304655ed8ca1SJohan Hedberg } 304755ed8ca1SJohan Hedberg } 304855ed8ca1SJohan Hedberg 304935f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 3050b899efafSVinicius Costa Gomes { 3051b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 3052b899efafSVinicius Costa Gomes 3053b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 3054b899efafSVinicius Costa Gomes list_del(&k->list); 3055b899efafSVinicius Costa Gomes kfree(k); 3056b899efafSVinicius Costa Gomes } 3057b899efafSVinicius Costa Gomes } 3058b899efafSVinicius Costa Gomes 3059970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 3060970c4e46SJohan Hedberg { 3061970c4e46SJohan Hedberg struct smp_irk *k, *tmp; 3062970c4e46SJohan Hedberg 3063970c4e46SJohan Hedberg list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) { 3064970c4e46SJohan Hedberg list_del(&k->list); 3065970c4e46SJohan Hedberg kfree(k); 3066970c4e46SJohan Hedberg } 3067970c4e46SJohan Hedberg } 3068970c4e46SJohan Hedberg 306955ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 307055ed8ca1SJohan Hedberg { 307155ed8ca1SJohan Hedberg struct link_key *k; 307255ed8ca1SJohan Hedberg 30738035ded4SLuiz Augusto von Dentz list_for_each_entry(k, &hdev->link_keys, list) 307455ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 307555ed8ca1SJohan Hedberg return k; 307655ed8ca1SJohan Hedberg 307755ed8ca1SJohan Hedberg return NULL; 307855ed8ca1SJohan Hedberg } 307955ed8ca1SJohan Hedberg 3080745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 3081d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 3082d25e28abSJohan Hedberg { 3083d25e28abSJohan Hedberg /* Legacy key */ 3084d25e28abSJohan Hedberg if (key_type < 0x03) 3085745c0ce3SVishal Agarwal return true; 3086d25e28abSJohan Hedberg 3087d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 3088d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 3089745c0ce3SVishal Agarwal return false; 3090d25e28abSJohan Hedberg 3091d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 3092d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 3093745c0ce3SVishal Agarwal return false; 3094d25e28abSJohan Hedberg 3095d25e28abSJohan Hedberg /* Security mode 3 case */ 3096d25e28abSJohan Hedberg if (!conn) 3097745c0ce3SVishal Agarwal return true; 3098d25e28abSJohan Hedberg 3099d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 3100d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 3101745c0ce3SVishal Agarwal return true; 3102d25e28abSJohan Hedberg 3103d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 3104d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 3105745c0ce3SVishal Agarwal return true; 3106d25e28abSJohan Hedberg 3107d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 3108d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 3109745c0ce3SVishal Agarwal return true; 3110d25e28abSJohan Hedberg 3111d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 3112d25e28abSJohan Hedberg * persistently */ 3113745c0ce3SVishal Agarwal return false; 3114d25e28abSJohan Hedberg } 3115d25e28abSJohan Hedberg 311698a0b845SJohan Hedberg static bool ltk_type_master(u8 type) 311798a0b845SJohan Hedberg { 3118d97c9fb0SJohan Hedberg return (type == SMP_LTK); 311998a0b845SJohan Hedberg } 312098a0b845SJohan Hedberg 3121fe39c7b2SMarcel Holtmann struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, __le64 rand, 312298a0b845SJohan Hedberg bool master) 312375d262c2SVinicius Costa Gomes { 3124c9839a11SVinicius Costa Gomes struct smp_ltk *k; 312575d262c2SVinicius Costa Gomes 3126c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) { 3127fe39c7b2SMarcel Holtmann if (k->ediv != ediv || k->rand != rand) 312875d262c2SVinicius Costa Gomes continue; 312975d262c2SVinicius Costa Gomes 313098a0b845SJohan Hedberg if (ltk_type_master(k->type) != master) 313198a0b845SJohan Hedberg continue; 313298a0b845SJohan Hedberg 313375d262c2SVinicius Costa Gomes return k; 313475d262c2SVinicius Costa Gomes } 313575d262c2SVinicius Costa Gomes 313675d262c2SVinicius Costa Gomes return NULL; 313775d262c2SVinicius Costa Gomes } 313875d262c2SVinicius Costa Gomes 3139c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 314098a0b845SJohan Hedberg u8 addr_type, bool master) 314175d262c2SVinicius Costa Gomes { 3142c9839a11SVinicius Costa Gomes struct smp_ltk *k; 314375d262c2SVinicius Costa Gomes 3144c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) 3145c9839a11SVinicius Costa Gomes if (addr_type == k->bdaddr_type && 314698a0b845SJohan Hedberg bacmp(bdaddr, &k->bdaddr) == 0 && 314798a0b845SJohan Hedberg ltk_type_master(k->type) == master) 314875d262c2SVinicius Costa Gomes return k; 314975d262c2SVinicius Costa Gomes 315075d262c2SVinicius Costa Gomes return NULL; 315175d262c2SVinicius Costa Gomes } 315275d262c2SVinicius Costa Gomes 3153970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 3154970c4e46SJohan Hedberg { 3155970c4e46SJohan Hedberg struct smp_irk *irk; 3156970c4e46SJohan Hedberg 3157970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3158970c4e46SJohan Hedberg if (!bacmp(&irk->rpa, rpa)) 3159970c4e46SJohan Hedberg return irk; 3160970c4e46SJohan Hedberg } 3161970c4e46SJohan Hedberg 3162970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3163970c4e46SJohan Hedberg if (smp_irk_matches(hdev->tfm_aes, irk->val, rpa)) { 3164970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 3165970c4e46SJohan Hedberg return irk; 3166970c4e46SJohan Hedberg } 3167970c4e46SJohan Hedberg } 3168970c4e46SJohan Hedberg 3169970c4e46SJohan Hedberg return NULL; 3170970c4e46SJohan Hedberg } 3171970c4e46SJohan Hedberg 3172970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 3173970c4e46SJohan Hedberg u8 addr_type) 3174970c4e46SJohan Hedberg { 3175970c4e46SJohan Hedberg struct smp_irk *irk; 3176970c4e46SJohan Hedberg 31776cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 31786cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 31796cfc9988SJohan Hedberg return NULL; 31806cfc9988SJohan Hedberg 3181970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3182970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 3183970c4e46SJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) 3184970c4e46SJohan Hedberg return irk; 3185970c4e46SJohan Hedberg } 3186970c4e46SJohan Hedberg 3187970c4e46SJohan Hedberg return NULL; 3188970c4e46SJohan Hedberg } 3189970c4e46SJohan Hedberg 3190567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 31917652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 31927652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 319355ed8ca1SJohan Hedberg { 319455ed8ca1SJohan Hedberg struct link_key *key, *old_key; 3195745c0ce3SVishal Agarwal u8 old_key_type; 319655ed8ca1SJohan Hedberg 319755ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 319855ed8ca1SJohan Hedberg if (old_key) { 319955ed8ca1SJohan Hedberg old_key_type = old_key->type; 320055ed8ca1SJohan Hedberg key = old_key; 320155ed8ca1SJohan Hedberg } else { 320212adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 32030a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 320455ed8ca1SJohan Hedberg if (!key) 3205567fa2aaSJohan Hedberg return NULL; 320655ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 320755ed8ca1SJohan Hedberg } 320855ed8ca1SJohan Hedberg 32096ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 321055ed8ca1SJohan Hedberg 3211d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 3212d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 3213d25e28abSJohan Hedberg * previous key */ 3214d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 3215a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 3216d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 3217655fe6ecSJohan Hedberg if (conn) 3218655fe6ecSJohan Hedberg conn->key_type = type; 3219655fe6ecSJohan Hedberg } 3220d25e28abSJohan Hedberg 322155ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 32229b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 322355ed8ca1SJohan Hedberg key->pin_len = pin_len; 322455ed8ca1SJohan Hedberg 3225b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 322655ed8ca1SJohan Hedberg key->type = old_key_type; 32274748fed2SJohan Hedberg else 32284748fed2SJohan Hedberg key->type = type; 32294748fed2SJohan Hedberg 32307652ff6aSJohan Hedberg if (persistent) 32317652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 32327652ff6aSJohan Hedberg old_key_type); 323355ed8ca1SJohan Hedberg 3234567fa2aaSJohan Hedberg return key; 323555ed8ca1SJohan Hedberg } 323655ed8ca1SJohan Hedberg 3237ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 323835d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 3239fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 324075d262c2SVinicius Costa Gomes { 3241c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 324298a0b845SJohan Hedberg bool master = ltk_type_master(type); 324375d262c2SVinicius Costa Gomes 324498a0b845SJohan Hedberg old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type, master); 3245c9839a11SVinicius Costa Gomes if (old_key) 324675d262c2SVinicius Costa Gomes key = old_key; 3247c9839a11SVinicius Costa Gomes else { 32480a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 324975d262c2SVinicius Costa Gomes if (!key) 3250ca9142b8SJohan Hedberg return NULL; 3251c9839a11SVinicius Costa Gomes list_add(&key->list, &hdev->long_term_keys); 325275d262c2SVinicius Costa Gomes } 325375d262c2SVinicius Costa Gomes 325475d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 3255c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 3256c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 3257c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 3258c9839a11SVinicius Costa Gomes key->ediv = ediv; 3259fe39c7b2SMarcel Holtmann key->rand = rand; 3260c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 3261c9839a11SVinicius Costa Gomes key->type = type; 326275d262c2SVinicius Costa Gomes 3263ca9142b8SJohan Hedberg return key; 326475d262c2SVinicius Costa Gomes } 326575d262c2SVinicius Costa Gomes 3266ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 3267ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 3268970c4e46SJohan Hedberg { 3269970c4e46SJohan Hedberg struct smp_irk *irk; 3270970c4e46SJohan Hedberg 3271970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 3272970c4e46SJohan Hedberg if (!irk) { 3273970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 3274970c4e46SJohan Hedberg if (!irk) 3275ca9142b8SJohan Hedberg return NULL; 3276970c4e46SJohan Hedberg 3277970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 3278970c4e46SJohan Hedberg irk->addr_type = addr_type; 3279970c4e46SJohan Hedberg 3280970c4e46SJohan Hedberg list_add(&irk->list, &hdev->identity_resolving_keys); 3281970c4e46SJohan Hedberg } 3282970c4e46SJohan Hedberg 3283970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 3284970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 3285970c4e46SJohan Hedberg 3286ca9142b8SJohan Hedberg return irk; 3287970c4e46SJohan Hedberg } 3288970c4e46SJohan Hedberg 328955ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 329055ed8ca1SJohan Hedberg { 329155ed8ca1SJohan Hedberg struct link_key *key; 329255ed8ca1SJohan Hedberg 329355ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 329455ed8ca1SJohan Hedberg if (!key) 329555ed8ca1SJohan Hedberg return -ENOENT; 329655ed8ca1SJohan Hedberg 32976ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 329855ed8ca1SJohan Hedberg 329955ed8ca1SJohan Hedberg list_del(&key->list); 330055ed8ca1SJohan Hedberg kfree(key); 330155ed8ca1SJohan Hedberg 330255ed8ca1SJohan Hedberg return 0; 330355ed8ca1SJohan Hedberg } 330455ed8ca1SJohan Hedberg 3305e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 3306b899efafSVinicius Costa Gomes { 3307b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 3308c51ffa0bSJohan Hedberg int removed = 0; 3309b899efafSVinicius Costa Gomes 3310b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 3311e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 3312b899efafSVinicius Costa Gomes continue; 3313b899efafSVinicius Costa Gomes 33146ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3315b899efafSVinicius Costa Gomes 3316b899efafSVinicius Costa Gomes list_del(&k->list); 3317b899efafSVinicius Costa Gomes kfree(k); 3318c51ffa0bSJohan Hedberg removed++; 3319b899efafSVinicius Costa Gomes } 3320b899efafSVinicius Costa Gomes 3321c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 3322b899efafSVinicius Costa Gomes } 3323b899efafSVinicius Costa Gomes 3324a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 3325a7ec7338SJohan Hedberg { 3326a7ec7338SJohan Hedberg struct smp_irk *k, *tmp; 3327a7ec7338SJohan Hedberg 3328668b7b19SJohan Hedberg list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) { 3329a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 3330a7ec7338SJohan Hedberg continue; 3331a7ec7338SJohan Hedberg 3332a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3333a7ec7338SJohan Hedberg 3334a7ec7338SJohan Hedberg list_del(&k->list); 3335a7ec7338SJohan Hedberg kfree(k); 3336a7ec7338SJohan Hedberg } 3337a7ec7338SJohan Hedberg } 3338a7ec7338SJohan Hedberg 33396bd32326SVille Tervo /* HCI command timer function */ 334065cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 33416bd32326SVille Tervo { 334265cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 334365cc2b49SMarcel Holtmann cmd_timer.work); 33446bd32326SVille Tervo 3345bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 3346bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 3347bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 3348bda4f23aSAndrei Emeltchenko 3349bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 3350bda4f23aSAndrei Emeltchenko } else { 33516bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 3352bda4f23aSAndrei Emeltchenko } 3353bda4f23aSAndrei Emeltchenko 33546bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 3355c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 33566bd32326SVille Tervo } 33576bd32326SVille Tervo 33582763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 33592763eda6SSzymon Janc bdaddr_t *bdaddr) 33602763eda6SSzymon Janc { 33612763eda6SSzymon Janc struct oob_data *data; 33622763eda6SSzymon Janc 33632763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 33642763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 33652763eda6SSzymon Janc return data; 33662763eda6SSzymon Janc 33672763eda6SSzymon Janc return NULL; 33682763eda6SSzymon Janc } 33692763eda6SSzymon Janc 33702763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 33712763eda6SSzymon Janc { 33722763eda6SSzymon Janc struct oob_data *data; 33732763eda6SSzymon Janc 33742763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 33752763eda6SSzymon Janc if (!data) 33762763eda6SSzymon Janc return -ENOENT; 33772763eda6SSzymon Janc 33786ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 33792763eda6SSzymon Janc 33802763eda6SSzymon Janc list_del(&data->list); 33812763eda6SSzymon Janc kfree(data); 33822763eda6SSzymon Janc 33832763eda6SSzymon Janc return 0; 33842763eda6SSzymon Janc } 33852763eda6SSzymon Janc 338635f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 33872763eda6SSzymon Janc { 33882763eda6SSzymon Janc struct oob_data *data, *n; 33892763eda6SSzymon Janc 33902763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 33912763eda6SSzymon Janc list_del(&data->list); 33922763eda6SSzymon Janc kfree(data); 33932763eda6SSzymon Janc } 33942763eda6SSzymon Janc } 33952763eda6SSzymon Janc 33960798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 33970798872eSMarcel Holtmann u8 *hash, u8 *randomizer) 33982763eda6SSzymon Janc { 33992763eda6SSzymon Janc struct oob_data *data; 34002763eda6SSzymon Janc 34012763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 34022763eda6SSzymon Janc if (!data) { 34030a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 34042763eda6SSzymon Janc if (!data) 34052763eda6SSzymon Janc return -ENOMEM; 34062763eda6SSzymon Janc 34072763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 34082763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 34092763eda6SSzymon Janc } 34102763eda6SSzymon Janc 3411519ca9d0SMarcel Holtmann memcpy(data->hash192, hash, sizeof(data->hash192)); 3412519ca9d0SMarcel Holtmann memcpy(data->randomizer192, randomizer, sizeof(data->randomizer192)); 34132763eda6SSzymon Janc 34140798872eSMarcel Holtmann memset(data->hash256, 0, sizeof(data->hash256)); 34150798872eSMarcel Holtmann memset(data->randomizer256, 0, sizeof(data->randomizer256)); 34160798872eSMarcel Holtmann 34170798872eSMarcel Holtmann BT_DBG("%s for %pMR", hdev->name, bdaddr); 34180798872eSMarcel Holtmann 34190798872eSMarcel Holtmann return 0; 34200798872eSMarcel Holtmann } 34210798872eSMarcel Holtmann 34220798872eSMarcel Holtmann int hci_add_remote_oob_ext_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 34230798872eSMarcel Holtmann u8 *hash192, u8 *randomizer192, 34240798872eSMarcel Holtmann u8 *hash256, u8 *randomizer256) 34250798872eSMarcel Holtmann { 34260798872eSMarcel Holtmann struct oob_data *data; 34270798872eSMarcel Holtmann 34280798872eSMarcel Holtmann data = hci_find_remote_oob_data(hdev, bdaddr); 34290798872eSMarcel Holtmann if (!data) { 34300a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 34310798872eSMarcel Holtmann if (!data) 34320798872eSMarcel Holtmann return -ENOMEM; 34330798872eSMarcel Holtmann 34340798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 34350798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 34360798872eSMarcel Holtmann } 34370798872eSMarcel Holtmann 34380798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 34390798872eSMarcel Holtmann memcpy(data->randomizer192, randomizer192, sizeof(data->randomizer192)); 34400798872eSMarcel Holtmann 34410798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 34420798872eSMarcel Holtmann memcpy(data->randomizer256, randomizer256, sizeof(data->randomizer256)); 34430798872eSMarcel Holtmann 34446ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 34452763eda6SSzymon Janc 34462763eda6SSzymon Janc return 0; 34472763eda6SSzymon Janc } 34482763eda6SSzymon Janc 3449dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 3450b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 3451b2a66aadSAntti Julku { 3452b2a66aadSAntti Julku struct bdaddr_list *b; 3453b2a66aadSAntti Julku 3454dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 3455b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 3456b2a66aadSAntti Julku return b; 3457b9ee0a78SMarcel Holtmann } 3458b2a66aadSAntti Julku 3459b2a66aadSAntti Julku return NULL; 3460b2a66aadSAntti Julku } 3461b2a66aadSAntti Julku 3462dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 3463b2a66aadSAntti Julku { 3464b2a66aadSAntti Julku struct list_head *p, *n; 3465b2a66aadSAntti Julku 3466dcc36c16SJohan Hedberg list_for_each_safe(p, n, bdaddr_list) { 3467b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 3468b2a66aadSAntti Julku 3469b2a66aadSAntti Julku list_del(p); 3470b2a66aadSAntti Julku kfree(b); 3471b2a66aadSAntti Julku } 3472b2a66aadSAntti Julku } 3473b2a66aadSAntti Julku 3474dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3475b2a66aadSAntti Julku { 3476b2a66aadSAntti Julku struct bdaddr_list *entry; 3477b2a66aadSAntti Julku 3478b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 3479b2a66aadSAntti Julku return -EBADF; 3480b2a66aadSAntti Julku 3481dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 34825e762444SAntti Julku return -EEXIST; 3483b2a66aadSAntti Julku 3484b2a66aadSAntti Julku entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL); 34855e762444SAntti Julku if (!entry) 34865e762444SAntti Julku return -ENOMEM; 3487b2a66aadSAntti Julku 3488b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 3489b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 3490b2a66aadSAntti Julku 3491dcc36c16SJohan Hedberg list_add(&entry->list, list); 3492b2a66aadSAntti Julku 34932a8357f2SJohan Hedberg return 0; 3494b2a66aadSAntti Julku } 3495b2a66aadSAntti Julku 3496dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3497b2a66aadSAntti Julku { 3498b2a66aadSAntti Julku struct bdaddr_list *entry; 3499b2a66aadSAntti Julku 350035f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 3501dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 350235f7498aSJohan Hedberg return 0; 350335f7498aSJohan Hedberg } 3504b2a66aadSAntti Julku 3505dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 3506d2ab0ac1SMarcel Holtmann if (!entry) 3507d2ab0ac1SMarcel Holtmann return -ENOENT; 3508d2ab0ac1SMarcel Holtmann 3509d2ab0ac1SMarcel Holtmann list_del(&entry->list); 3510d2ab0ac1SMarcel Holtmann kfree(entry); 3511d2ab0ac1SMarcel Holtmann 3512d2ab0ac1SMarcel Holtmann return 0; 3513d2ab0ac1SMarcel Holtmann } 3514d2ab0ac1SMarcel Holtmann 351515819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 351615819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 351715819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 351815819a70SAndre Guedes { 351915819a70SAndre Guedes struct hci_conn_params *params; 352015819a70SAndre Guedes 3521738f6185SJohan Hedberg /* The conn params list only contains identity addresses */ 3522738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 3523738f6185SJohan Hedberg return NULL; 3524738f6185SJohan Hedberg 352515819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 352615819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 352715819a70SAndre Guedes params->addr_type == addr_type) { 352815819a70SAndre Guedes return params; 352915819a70SAndre Guedes } 353015819a70SAndre Guedes } 353115819a70SAndre Guedes 353215819a70SAndre Guedes return NULL; 353315819a70SAndre Guedes } 353415819a70SAndre Guedes 3535cef952ceSAndre Guedes static bool is_connected(struct hci_dev *hdev, bdaddr_t *addr, u8 type) 3536cef952ceSAndre Guedes { 3537cef952ceSAndre Guedes struct hci_conn *conn; 3538cef952ceSAndre Guedes 3539cef952ceSAndre Guedes conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, addr); 3540cef952ceSAndre Guedes if (!conn) 3541cef952ceSAndre Guedes return false; 3542cef952ceSAndre Guedes 3543cef952ceSAndre Guedes if (conn->dst_type != type) 3544cef952ceSAndre Guedes return false; 3545cef952ceSAndre Guedes 3546cef952ceSAndre Guedes if (conn->state != BT_CONNECTED) 3547cef952ceSAndre Guedes return false; 3548cef952ceSAndre Guedes 3549cef952ceSAndre Guedes return true; 3550cef952ceSAndre Guedes } 3551cef952ceSAndre Guedes 355215819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 3553501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 35544b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 35554b10966fSMarcel Holtmann { 3556912b42efSJohan Hedberg struct hci_conn_params *param; 35574b10966fSMarcel Holtmann 3558738f6185SJohan Hedberg /* The list only contains identity addresses */ 3559738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 3560738f6185SJohan Hedberg return NULL; 3561738f6185SJohan Hedberg 3562501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 3563912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 3564912b42efSJohan Hedberg param->addr_type == addr_type) 3565912b42efSJohan Hedberg return param; 35664b10966fSMarcel Holtmann } 35674b10966fSMarcel Holtmann 35684b10966fSMarcel Holtmann return NULL; 35694b10966fSMarcel Holtmann } 35704b10966fSMarcel Holtmann 35714b10966fSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 357251d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 357351d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 3574bf5b3c8bSMarcel Holtmann { 3575bf5b3c8bSMarcel Holtmann struct hci_conn_params *params; 3576bf5b3c8bSMarcel Holtmann 3577c46245b3SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 357851d167c0SMarcel Holtmann return NULL; 3579bf5b3c8bSMarcel Holtmann 3580bf5b3c8bSMarcel Holtmann params = hci_conn_params_lookup(hdev, addr, addr_type); 3581bf5b3c8bSMarcel Holtmann if (params) 358251d167c0SMarcel Holtmann return params; 3583bf5b3c8bSMarcel Holtmann 3584bf5b3c8bSMarcel Holtmann params = kzalloc(sizeof(*params), GFP_KERNEL); 3585bf5b3c8bSMarcel Holtmann if (!params) { 3586bf5b3c8bSMarcel Holtmann BT_ERR("Out of memory"); 358751d167c0SMarcel Holtmann return NULL; 3588bf5b3c8bSMarcel Holtmann } 3589bf5b3c8bSMarcel Holtmann 3590bf5b3c8bSMarcel Holtmann bacpy(¶ms->addr, addr); 3591bf5b3c8bSMarcel Holtmann params->addr_type = addr_type; 3592bf5b3c8bSMarcel Holtmann 3593bf5b3c8bSMarcel Holtmann list_add(¶ms->list, &hdev->le_conn_params); 359493450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 3595bf5b3c8bSMarcel Holtmann 3596bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 3597bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 3598bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 3599bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 3600bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 3601bf5b3c8bSMarcel Holtmann 3602bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 3603bf5b3c8bSMarcel Holtmann 360451d167c0SMarcel Holtmann return params; 3605bf5b3c8bSMarcel Holtmann } 3606bf5b3c8bSMarcel Holtmann 3607bf5b3c8bSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 3608bf5b3c8bSMarcel Holtmann int hci_conn_params_set(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type, 3609d06b50ceSMarcel Holtmann u8 auto_connect) 361015819a70SAndre Guedes { 361115819a70SAndre Guedes struct hci_conn_params *params; 361215819a70SAndre Guedes 36138c87aae1SMarcel Holtmann params = hci_conn_params_add(hdev, addr, addr_type); 36148c87aae1SMarcel Holtmann if (!params) 36158c87aae1SMarcel Holtmann return -EIO; 3616a9b0a04cSAndre Guedes 361742ce26deSJohan Hedberg if (params->auto_connect == auto_connect) 361842ce26deSJohan Hedberg return 0; 361942ce26deSJohan Hedberg 362066f8455aSJohan Hedberg list_del_init(¶ms->action); 362115819a70SAndre Guedes 3622cef952ceSAndre Guedes switch (auto_connect) { 3623cef952ceSAndre Guedes case HCI_AUTO_CONN_DISABLED: 3624cef952ceSAndre Guedes case HCI_AUTO_CONN_LINK_LOSS: 362595305baaSJohan Hedberg hci_update_background_scan(hdev); 3626cef952ceSAndre Guedes break; 3627851efca8SJohan Hedberg case HCI_AUTO_CONN_REPORT: 362895305baaSJohan Hedberg list_add(¶ms->action, &hdev->pend_le_reports); 362995305baaSJohan Hedberg hci_update_background_scan(hdev); 3630851efca8SJohan Hedberg break; 3631cef952ceSAndre Guedes case HCI_AUTO_CONN_ALWAYS: 363295305baaSJohan Hedberg if (!is_connected(hdev, addr, addr_type)) { 363395305baaSJohan Hedberg list_add(¶ms->action, &hdev->pend_le_conns); 363495305baaSJohan Hedberg hci_update_background_scan(hdev); 363595305baaSJohan Hedberg } 3636cef952ceSAndre Guedes break; 3637cef952ceSAndre Guedes } 363815819a70SAndre Guedes 3639851efca8SJohan Hedberg params->auto_connect = auto_connect; 3640851efca8SJohan Hedberg 3641d06b50ceSMarcel Holtmann BT_DBG("addr %pMR (type %u) auto_connect %u", addr, addr_type, 3642d06b50ceSMarcel Holtmann auto_connect); 3643a9b0a04cSAndre Guedes 3644a9b0a04cSAndre Guedes return 0; 364515819a70SAndre Guedes } 364615819a70SAndre Guedes 364715819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 364815819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 364915819a70SAndre Guedes { 365015819a70SAndre Guedes struct hci_conn_params *params; 365115819a70SAndre Guedes 365215819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 365315819a70SAndre Guedes if (!params) 365415819a70SAndre Guedes return; 365515819a70SAndre Guedes 365695305baaSJohan Hedberg list_del(¶ms->action); 365715819a70SAndre Guedes list_del(¶ms->list); 365815819a70SAndre Guedes kfree(params); 365915819a70SAndre Guedes 366095305baaSJohan Hedberg hci_update_background_scan(hdev); 366195305baaSJohan Hedberg 366215819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 366315819a70SAndre Guedes } 366415819a70SAndre Guedes 366515819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 366655af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 366755af49a8SJohan Hedberg { 366855af49a8SJohan Hedberg struct hci_conn_params *params, *tmp; 366955af49a8SJohan Hedberg 367055af49a8SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 367155af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 367255af49a8SJohan Hedberg continue; 367355af49a8SJohan Hedberg list_del(¶ms->list); 367455af49a8SJohan Hedberg kfree(params); 367555af49a8SJohan Hedberg } 367655af49a8SJohan Hedberg 367755af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 367855af49a8SJohan Hedberg } 367955af49a8SJohan Hedberg 368055af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 3681373110c5SJohan Hedberg void hci_conn_params_clear_all(struct hci_dev *hdev) 368215819a70SAndre Guedes { 368315819a70SAndre Guedes struct hci_conn_params *params, *tmp; 368415819a70SAndre Guedes 368515819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 3686a2f41a8fSJohan Hedberg list_del(¶ms->action); 368715819a70SAndre Guedes list_del(¶ms->list); 368815819a70SAndre Guedes kfree(params); 368915819a70SAndre Guedes } 369015819a70SAndre Guedes 3691a2f41a8fSJohan Hedberg hci_update_background_scan(hdev); 36921089b67dSMarcel Holtmann 369315819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 369415819a70SAndre Guedes } 369515819a70SAndre Guedes 36964c87eaabSAndre Guedes static void inquiry_complete(struct hci_dev *hdev, u8 status) 36977ba8b4beSAndre Guedes { 36984c87eaabSAndre Guedes if (status) { 36994c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 37007ba8b4beSAndre Guedes 37014c87eaabSAndre Guedes hci_dev_lock(hdev); 37024c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37034c87eaabSAndre Guedes hci_dev_unlock(hdev); 37044c87eaabSAndre Guedes return; 37054c87eaabSAndre Guedes } 37067ba8b4beSAndre Guedes } 37077ba8b4beSAndre Guedes 37084c87eaabSAndre Guedes static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status) 37097ba8b4beSAndre Guedes { 37104c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 37114c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 37124c87eaabSAndre Guedes struct hci_request req; 37134c87eaabSAndre Guedes struct hci_cp_inquiry cp; 37147ba8b4beSAndre Guedes int err; 37157ba8b4beSAndre Guedes 37164c87eaabSAndre Guedes if (status) { 37174c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 37184c87eaabSAndre Guedes return; 37197ba8b4beSAndre Guedes } 37207ba8b4beSAndre Guedes 37214c87eaabSAndre Guedes switch (hdev->discovery.type) { 37224c87eaabSAndre Guedes case DISCOV_TYPE_LE: 37234c87eaabSAndre Guedes hci_dev_lock(hdev); 37244c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37254c87eaabSAndre Guedes hci_dev_unlock(hdev); 37264c87eaabSAndre Guedes break; 37277dbfac1dSAndre Guedes 37284c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 37294c87eaabSAndre Guedes hci_req_init(&req, hdev); 37307dbfac1dSAndre Guedes 37317dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 37324c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 37334c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 37344c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 37354c87eaabSAndre Guedes 37364c87eaabSAndre Guedes hci_dev_lock(hdev); 37374c87eaabSAndre Guedes 37384c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 37394c87eaabSAndre Guedes 37404c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 37414c87eaabSAndre Guedes if (err) { 37424c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 37434c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37447dbfac1dSAndre Guedes } 37457dbfac1dSAndre Guedes 37464c87eaabSAndre Guedes hci_dev_unlock(hdev); 37474c87eaabSAndre Guedes break; 37484c87eaabSAndre Guedes } 37497dbfac1dSAndre Guedes } 37507dbfac1dSAndre Guedes 37517ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 37527ba8b4beSAndre Guedes { 37537ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 37547ba8b4beSAndre Guedes le_scan_disable.work); 37554c87eaabSAndre Guedes struct hci_request req; 37564c87eaabSAndre Guedes int err; 37577ba8b4beSAndre Guedes 37587ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 37597ba8b4beSAndre Guedes 37604c87eaabSAndre Guedes hci_req_init(&req, hdev); 37617ba8b4beSAndre Guedes 3762b1efcc28SAndre Guedes hci_req_add_le_scan_disable(&req); 37637ba8b4beSAndre Guedes 37644c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 37654c87eaabSAndre Guedes if (err) 37664c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 376728b75a89SAndre Guedes } 376828b75a89SAndre Guedes 37698d97250eSJohan Hedberg static void set_random_addr(struct hci_request *req, bdaddr_t *rpa) 37708d97250eSJohan Hedberg { 37718d97250eSJohan Hedberg struct hci_dev *hdev = req->hdev; 37728d97250eSJohan Hedberg 37738d97250eSJohan Hedberg /* If we're advertising or initiating an LE connection we can't 37748d97250eSJohan Hedberg * go ahead and change the random address at this time. This is 37758d97250eSJohan Hedberg * because the eventual initiator address used for the 37768d97250eSJohan Hedberg * subsequently created connection will be undefined (some 37778d97250eSJohan Hedberg * controllers use the new address and others the one we had 37788d97250eSJohan Hedberg * when the operation started). 37798d97250eSJohan Hedberg * 37808d97250eSJohan Hedberg * In this kind of scenario skip the update and let the random 37818d97250eSJohan Hedberg * address be updated at the next cycle. 37828d97250eSJohan Hedberg */ 37835ce194c4SJohan Hedberg if (test_bit(HCI_LE_ADV, &hdev->dev_flags) || 37848d97250eSJohan Hedberg hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT)) { 37858d97250eSJohan Hedberg BT_DBG("Deferring random address update"); 37868d97250eSJohan Hedberg return; 37878d97250eSJohan Hedberg } 37888d97250eSJohan Hedberg 37898d97250eSJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, rpa); 37908d97250eSJohan Hedberg } 37918d97250eSJohan Hedberg 379294b1fc92SMarcel Holtmann int hci_update_random_address(struct hci_request *req, bool require_privacy, 379394b1fc92SMarcel Holtmann u8 *own_addr_type) 3794ebd3a747SJohan Hedberg { 3795ebd3a747SJohan Hedberg struct hci_dev *hdev = req->hdev; 3796ebd3a747SJohan Hedberg int err; 3797ebd3a747SJohan Hedberg 3798ebd3a747SJohan Hedberg /* If privacy is enabled use a resolvable private address. If 37992b5224dcSMarcel Holtmann * current RPA has expired or there is something else than 38002b5224dcSMarcel Holtmann * the current RPA in use, then generate a new one. 3801ebd3a747SJohan Hedberg */ 3802ebd3a747SJohan Hedberg if (test_bit(HCI_PRIVACY, &hdev->dev_flags)) { 3803ebd3a747SJohan Hedberg int to; 3804ebd3a747SJohan Hedberg 3805ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3806ebd3a747SJohan Hedberg 3807ebd3a747SJohan Hedberg if (!test_and_clear_bit(HCI_RPA_EXPIRED, &hdev->dev_flags) && 38082b5224dcSMarcel Holtmann !bacmp(&hdev->random_addr, &hdev->rpa)) 3809ebd3a747SJohan Hedberg return 0; 3810ebd3a747SJohan Hedberg 38112b5224dcSMarcel Holtmann err = smp_generate_rpa(hdev->tfm_aes, hdev->irk, &hdev->rpa); 3812ebd3a747SJohan Hedberg if (err < 0) { 3813ebd3a747SJohan Hedberg BT_ERR("%s failed to generate new RPA", hdev->name); 3814ebd3a747SJohan Hedberg return err; 3815ebd3a747SJohan Hedberg } 3816ebd3a747SJohan Hedberg 38178d97250eSJohan Hedberg set_random_addr(req, &hdev->rpa); 3818ebd3a747SJohan Hedberg 3819ebd3a747SJohan Hedberg to = msecs_to_jiffies(hdev->rpa_timeout * 1000); 3820ebd3a747SJohan Hedberg queue_delayed_work(hdev->workqueue, &hdev->rpa_expired, to); 3821ebd3a747SJohan Hedberg 3822ebd3a747SJohan Hedberg return 0; 3823ebd3a747SJohan Hedberg } 3824ebd3a747SJohan Hedberg 382594b1fc92SMarcel Holtmann /* In case of required privacy without resolvable private address, 382694b1fc92SMarcel Holtmann * use an unresolvable private address. This is useful for active 382794b1fc92SMarcel Holtmann * scanning and non-connectable advertising. 382894b1fc92SMarcel Holtmann */ 382994b1fc92SMarcel Holtmann if (require_privacy) { 383094b1fc92SMarcel Holtmann bdaddr_t urpa; 383194b1fc92SMarcel Holtmann 383294b1fc92SMarcel Holtmann get_random_bytes(&urpa, 6); 383394b1fc92SMarcel Holtmann urpa.b[5] &= 0x3f; /* Clear two most significant bits */ 383494b1fc92SMarcel Holtmann 383594b1fc92SMarcel Holtmann *own_addr_type = ADDR_LE_DEV_RANDOM; 38368d97250eSJohan Hedberg set_random_addr(req, &urpa); 383794b1fc92SMarcel Holtmann return 0; 383894b1fc92SMarcel Holtmann } 383994b1fc92SMarcel Holtmann 3840ebd3a747SJohan Hedberg /* If forcing static address is in use or there is no public 3841ebd3a747SJohan Hedberg * address use the static address as random address (but skip 3842ebd3a747SJohan Hedberg * the HCI command if the current random address is already the 3843ebd3a747SJohan Hedberg * static one. 3844ebd3a747SJohan Hedberg */ 3845111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3846ebd3a747SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3847ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3848ebd3a747SJohan Hedberg if (bacmp(&hdev->static_addr, &hdev->random_addr)) 3849ebd3a747SJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, 3850ebd3a747SJohan Hedberg &hdev->static_addr); 3851ebd3a747SJohan Hedberg return 0; 3852ebd3a747SJohan Hedberg } 3853ebd3a747SJohan Hedberg 3854ebd3a747SJohan Hedberg /* Neither privacy nor static address is being used so use a 3855ebd3a747SJohan Hedberg * public address. 3856ebd3a747SJohan Hedberg */ 3857ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_PUBLIC; 3858ebd3a747SJohan Hedberg 3859ebd3a747SJohan Hedberg return 0; 3860ebd3a747SJohan Hedberg } 3861ebd3a747SJohan Hedberg 3862a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 3863a1f4c318SJohan Hedberg * 3864a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 3865a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 3866a1f4c318SJohan Hedberg * the static random address. 3867a1f4c318SJohan Hedberg * 3868a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 3869a1f4c318SJohan Hedberg * public address to use the static random address instead. 3870a1f4c318SJohan Hedberg */ 3871a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 3872a1f4c318SJohan Hedberg u8 *bdaddr_type) 3873a1f4c318SJohan Hedberg { 3874111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3875a1f4c318SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3876a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3877a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3878a1f4c318SJohan Hedberg } else { 3879a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3880a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3881a1f4c318SJohan Hedberg } 3882a1f4c318SJohan Hedberg } 3883a1f4c318SJohan Hedberg 38849be0dab7SDavid Herrmann /* Alloc HCI device */ 38859be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 38869be0dab7SDavid Herrmann { 38879be0dab7SDavid Herrmann struct hci_dev *hdev; 38889be0dab7SDavid Herrmann 38899be0dab7SDavid Herrmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 38909be0dab7SDavid Herrmann if (!hdev) 38919be0dab7SDavid Herrmann return NULL; 38929be0dab7SDavid Herrmann 3893b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3894b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3895b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3896b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3897b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 389896c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3899bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3900bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3901b1b813d4SDavid Herrmann 3902b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3903b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3904b1b813d4SDavid Herrmann 39053f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3906bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3907bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 39084e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 39094e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 391004fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 391104fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3912bef64738SMarcel Holtmann 3913d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3914b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 391531ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 391631ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3917d6bfd59cSJohan Hedberg 3918b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3919b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3920b1b813d4SDavid Herrmann 3921b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3922b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 39236659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 3924b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3925b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3926b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3927970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3928b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3929d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 393015819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 393177a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 393266f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 39336b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3934b1b813d4SDavid Herrmann 3935b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3936b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3937b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3938b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3939b1b813d4SDavid Herrmann 3940b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3941b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 3942b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 3943b1b813d4SDavid Herrmann 3944b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3945b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3946b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3947b1b813d4SDavid Herrmann 3948b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3949b1b813d4SDavid Herrmann 395065cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3951b1b813d4SDavid Herrmann 3952b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3953b1b813d4SDavid Herrmann discovery_init(hdev); 39549be0dab7SDavid Herrmann 39559be0dab7SDavid Herrmann return hdev; 39569be0dab7SDavid Herrmann } 39579be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 39589be0dab7SDavid Herrmann 39599be0dab7SDavid Herrmann /* Free HCI device */ 39609be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 39619be0dab7SDavid Herrmann { 39629be0dab7SDavid Herrmann /* will free via device release */ 39639be0dab7SDavid Herrmann put_device(&hdev->dev); 39649be0dab7SDavid Herrmann } 39659be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 39669be0dab7SDavid Herrmann 39671da177e4SLinus Torvalds /* Register HCI device */ 39681da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 39691da177e4SLinus Torvalds { 3970b1b813d4SDavid Herrmann int id, error; 39711da177e4SLinus Torvalds 397274292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 39731da177e4SLinus Torvalds return -EINVAL; 39741da177e4SLinus Torvalds 397508add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 397608add513SMat Martineau * so the index can be used as the AMP controller ID. 397708add513SMat Martineau */ 39783df92b31SSasha Levin switch (hdev->dev_type) { 39793df92b31SSasha Levin case HCI_BREDR: 39803df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 39811da177e4SLinus Torvalds break; 39823df92b31SSasha Levin case HCI_AMP: 39833df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 39843df92b31SSasha Levin break; 39853df92b31SSasha Levin default: 39863df92b31SSasha Levin return -EINVAL; 39871da177e4SLinus Torvalds } 39881da177e4SLinus Torvalds 39893df92b31SSasha Levin if (id < 0) 39903df92b31SSasha Levin return id; 39913df92b31SSasha Levin 39921da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 39931da177e4SLinus Torvalds hdev->id = id; 39942d8b3a11SAndrei Emeltchenko 39952d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 39962d8b3a11SAndrei Emeltchenko 3997d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3998d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 399933ca954dSDavid Herrmann if (!hdev->workqueue) { 400033ca954dSDavid Herrmann error = -ENOMEM; 400133ca954dSDavid Herrmann goto err; 400233ca954dSDavid Herrmann } 4003f48fd9c8SMarcel Holtmann 4004d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 4005d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 40066ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 40076ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 40086ead1bbcSJohan Hedberg error = -ENOMEM; 40096ead1bbcSJohan Hedberg goto err; 40106ead1bbcSJohan Hedberg } 40116ead1bbcSJohan Hedberg 40120153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 40130153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 40140153e2ecSMarcel Holtmann 4015bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 4016bdc3e0f1SMarcel Holtmann 401799780a7bSJohan Hedberg hdev->tfm_aes = crypto_alloc_blkcipher("ecb(aes)", 0, 401899780a7bSJohan Hedberg CRYPTO_ALG_ASYNC); 401999780a7bSJohan Hedberg if (IS_ERR(hdev->tfm_aes)) { 402099780a7bSJohan Hedberg BT_ERR("Unable to create crypto context"); 402199780a7bSJohan Hedberg error = PTR_ERR(hdev->tfm_aes); 402299780a7bSJohan Hedberg hdev->tfm_aes = NULL; 402399780a7bSJohan Hedberg goto err_wqueue; 402499780a7bSJohan Hedberg } 402599780a7bSJohan Hedberg 4026bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 402733ca954dSDavid Herrmann if (error < 0) 402899780a7bSJohan Hedberg goto err_tfm; 40291da177e4SLinus Torvalds 4030611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 4031a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 4032a8c5fb1aSGustavo Padovan hdev); 4033611b30f7SMarcel Holtmann if (hdev->rfkill) { 4034611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 4035611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 4036611b30f7SMarcel Holtmann hdev->rfkill = NULL; 4037611b30f7SMarcel Holtmann } 4038611b30f7SMarcel Holtmann } 4039611b30f7SMarcel Holtmann 40405e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 40415e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 40425e130367SJohan Hedberg 4043a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 4044004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 4045ce2be9acSAndrei Emeltchenko 404601cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 404756f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 404856f87901SJohan Hedberg * through reading supported features during init. 404956f87901SJohan Hedberg */ 405056f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 405156f87901SJohan Hedberg } 4052ce2be9acSAndrei Emeltchenko 4053fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 4054fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 4055fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 4056fcee3377SGustavo Padovan 40574a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 40584a964404SMarcel Holtmann * and should not be included in normal operation. 4059fee746b0SMarcel Holtmann */ 4060fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 40614a964404SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 4062fee746b0SMarcel Holtmann 40631da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 4064dc946bd8SDavid Herrmann hci_dev_hold(hdev); 40651da177e4SLinus Torvalds 406619202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 4067fbe96d6fSMarcel Holtmann 40681da177e4SLinus Torvalds return id; 4069f48fd9c8SMarcel Holtmann 407099780a7bSJohan Hedberg err_tfm: 407199780a7bSJohan Hedberg crypto_free_blkcipher(hdev->tfm_aes); 407233ca954dSDavid Herrmann err_wqueue: 407333ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 40746ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 407533ca954dSDavid Herrmann err: 40763df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 4077f48fd9c8SMarcel Holtmann 407833ca954dSDavid Herrmann return error; 40791da177e4SLinus Torvalds } 40801da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 40811da177e4SLinus Torvalds 40821da177e4SLinus Torvalds /* Unregister HCI device */ 408359735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 40841da177e4SLinus Torvalds { 40853df92b31SSasha Levin int i, id; 4086ef222013SMarcel Holtmann 4087c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 40881da177e4SLinus Torvalds 408994324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 409094324962SJohan Hovold 40913df92b31SSasha Levin id = hdev->id; 40923df92b31SSasha Levin 4093f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 40941da177e4SLinus Torvalds list_del(&hdev->list); 4095f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 40961da177e4SLinus Torvalds 40971da177e4SLinus Torvalds hci_dev_do_close(hdev); 40981da177e4SLinus Torvalds 4099cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 4100ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 4101ef222013SMarcel Holtmann 4102b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 4103b9b5ef18SGustavo Padovan 4104ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 4105d603b76bSMarcel Holtmann !test_bit(HCI_SETUP, &hdev->dev_flags) && 4106d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 410709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 4108744cf19eSJohan Hedberg mgmt_index_removed(hdev); 410909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 411056e5cb86SJohan Hedberg } 4111ab81cbf9SJohan Hedberg 41122e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 41132e58ef3eSJohan Hedberg * pending list */ 41142e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 41152e58ef3eSJohan Hedberg 41161da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 41171da177e4SLinus Torvalds 4118611b30f7SMarcel Holtmann if (hdev->rfkill) { 4119611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 4120611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 4121611b30f7SMarcel Holtmann } 4122611b30f7SMarcel Holtmann 412399780a7bSJohan Hedberg if (hdev->tfm_aes) 412499780a7bSJohan Hedberg crypto_free_blkcipher(hdev->tfm_aes); 412599780a7bSJohan Hedberg 4126bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 4127147e2d59SDave Young 41280153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 41290153e2ecSMarcel Holtmann 4130f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 41316ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 4132f48fd9c8SMarcel Holtmann 413309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 4134dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 41356659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 41362aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 413755ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 4138b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 4139970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 41402763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 4141dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 4142373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 414309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 4144e2e0cacbSJohan Hedberg 4145dc946bd8SDavid Herrmann hci_dev_put(hdev); 41463df92b31SSasha Levin 41473df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 41481da177e4SLinus Torvalds } 41491da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 41501da177e4SLinus Torvalds 41511da177e4SLinus Torvalds /* Suspend HCI device */ 41521da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 41531da177e4SLinus Torvalds { 41541da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 41551da177e4SLinus Torvalds return 0; 41561da177e4SLinus Torvalds } 41571da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 41581da177e4SLinus Torvalds 41591da177e4SLinus Torvalds /* Resume HCI device */ 41601da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 41611da177e4SLinus Torvalds { 41621da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 41631da177e4SLinus Torvalds return 0; 41641da177e4SLinus Torvalds } 41651da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 41661da177e4SLinus Torvalds 416776bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 4168e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 416976bca880SMarcel Holtmann { 417076bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 417176bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 417276bca880SMarcel Holtmann kfree_skb(skb); 417376bca880SMarcel Holtmann return -ENXIO; 417476bca880SMarcel Holtmann } 417576bca880SMarcel Holtmann 4176d82603c6SJorrit Schippers /* Incoming skb */ 417776bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 417876bca880SMarcel Holtmann 417976bca880SMarcel Holtmann /* Time stamp */ 418076bca880SMarcel Holtmann __net_timestamp(skb); 418176bca880SMarcel Holtmann 418276bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 4183b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 4184c78ae283SMarcel Holtmann 418576bca880SMarcel Holtmann return 0; 418676bca880SMarcel Holtmann } 418776bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 418876bca880SMarcel Holtmann 418933e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 41901e429f38SGustavo F. Padovan int count, __u8 index) 419133e882a5SSuraj Sumangala { 419233e882a5SSuraj Sumangala int len = 0; 419333e882a5SSuraj Sumangala int hlen = 0; 419433e882a5SSuraj Sumangala int remain = count; 419533e882a5SSuraj Sumangala struct sk_buff *skb; 419633e882a5SSuraj Sumangala struct bt_skb_cb *scb; 419733e882a5SSuraj Sumangala 419833e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 419933e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 420033e882a5SSuraj Sumangala return -EILSEQ; 420133e882a5SSuraj Sumangala 420233e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 420333e882a5SSuraj Sumangala 420433e882a5SSuraj Sumangala if (!skb) { 420533e882a5SSuraj Sumangala switch (type) { 420633e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 420733e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 420833e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 420933e882a5SSuraj Sumangala break; 421033e882a5SSuraj Sumangala case HCI_EVENT_PKT: 421133e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 421233e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 421333e882a5SSuraj Sumangala break; 421433e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 421533e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 421633e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 421733e882a5SSuraj Sumangala break; 421833e882a5SSuraj Sumangala } 421933e882a5SSuraj Sumangala 42201e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 422133e882a5SSuraj Sumangala if (!skb) 422233e882a5SSuraj Sumangala return -ENOMEM; 422333e882a5SSuraj Sumangala 422433e882a5SSuraj Sumangala scb = (void *) skb->cb; 422533e882a5SSuraj Sumangala scb->expect = hlen; 422633e882a5SSuraj Sumangala scb->pkt_type = type; 422733e882a5SSuraj Sumangala 422833e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 422933e882a5SSuraj Sumangala } 423033e882a5SSuraj Sumangala 423133e882a5SSuraj Sumangala while (count) { 423233e882a5SSuraj Sumangala scb = (void *) skb->cb; 423389bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 423433e882a5SSuraj Sumangala 423533e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 423633e882a5SSuraj Sumangala 423733e882a5SSuraj Sumangala count -= len; 423833e882a5SSuraj Sumangala data += len; 423933e882a5SSuraj Sumangala scb->expect -= len; 424033e882a5SSuraj Sumangala remain = count; 424133e882a5SSuraj Sumangala 424233e882a5SSuraj Sumangala switch (type) { 424333e882a5SSuraj Sumangala case HCI_EVENT_PKT: 424433e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 424533e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 424633e882a5SSuraj Sumangala scb->expect = h->plen; 424733e882a5SSuraj Sumangala 424833e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 424933e882a5SSuraj Sumangala kfree_skb(skb); 425033e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 425133e882a5SSuraj Sumangala return -ENOMEM; 425233e882a5SSuraj Sumangala } 425333e882a5SSuraj Sumangala } 425433e882a5SSuraj Sumangala break; 425533e882a5SSuraj Sumangala 425633e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 425733e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 425833e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 425933e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 426033e882a5SSuraj Sumangala 426133e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 426233e882a5SSuraj Sumangala kfree_skb(skb); 426333e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 426433e882a5SSuraj Sumangala return -ENOMEM; 426533e882a5SSuraj Sumangala } 426633e882a5SSuraj Sumangala } 426733e882a5SSuraj Sumangala break; 426833e882a5SSuraj Sumangala 426933e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 427033e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 427133e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 427233e882a5SSuraj Sumangala scb->expect = h->dlen; 427333e882a5SSuraj Sumangala 427433e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 427533e882a5SSuraj Sumangala kfree_skb(skb); 427633e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 427733e882a5SSuraj Sumangala return -ENOMEM; 427833e882a5SSuraj Sumangala } 427933e882a5SSuraj Sumangala } 428033e882a5SSuraj Sumangala break; 428133e882a5SSuraj Sumangala } 428233e882a5SSuraj Sumangala 428333e882a5SSuraj Sumangala if (scb->expect == 0) { 428433e882a5SSuraj Sumangala /* Complete frame */ 428533e882a5SSuraj Sumangala 428633e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 4287e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 428833e882a5SSuraj Sumangala 428933e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 429033e882a5SSuraj Sumangala return remain; 429133e882a5SSuraj Sumangala } 429233e882a5SSuraj Sumangala } 429333e882a5SSuraj Sumangala 429433e882a5SSuraj Sumangala return remain; 429533e882a5SSuraj Sumangala } 429633e882a5SSuraj Sumangala 4297ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 4298ef222013SMarcel Holtmann { 4299f39a3c06SSuraj Sumangala int rem = 0; 4300f39a3c06SSuraj Sumangala 4301ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 4302ef222013SMarcel Holtmann return -EILSEQ; 4303ef222013SMarcel Holtmann 4304da5f6c37SGustavo F. Padovan while (count) { 43051e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, type - 1); 4306f39a3c06SSuraj Sumangala if (rem < 0) 4307f39a3c06SSuraj Sumangala return rem; 4308ef222013SMarcel Holtmann 4309f39a3c06SSuraj Sumangala data += (count - rem); 4310f39a3c06SSuraj Sumangala count = rem; 4311f81c6224SJoe Perches } 4312ef222013SMarcel Holtmann 4313f39a3c06SSuraj Sumangala return rem; 4314ef222013SMarcel Holtmann } 4315ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 4316ef222013SMarcel Holtmann 431799811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 431899811510SSuraj Sumangala 431999811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 432099811510SSuraj Sumangala { 432199811510SSuraj Sumangala int type; 432299811510SSuraj Sumangala int rem = 0; 432399811510SSuraj Sumangala 4324da5f6c37SGustavo F. Padovan while (count) { 432599811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 432699811510SSuraj Sumangala 432799811510SSuraj Sumangala if (!skb) { 432899811510SSuraj Sumangala struct { char type; } *pkt; 432999811510SSuraj Sumangala 433099811510SSuraj Sumangala /* Start of the frame */ 433199811510SSuraj Sumangala pkt = data; 433299811510SSuraj Sumangala type = pkt->type; 433399811510SSuraj Sumangala 433499811510SSuraj Sumangala data++; 433599811510SSuraj Sumangala count--; 433699811510SSuraj Sumangala } else 433799811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 433899811510SSuraj Sumangala 43391e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 43401e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 434199811510SSuraj Sumangala if (rem < 0) 434299811510SSuraj Sumangala return rem; 434399811510SSuraj Sumangala 434499811510SSuraj Sumangala data += (count - rem); 434599811510SSuraj Sumangala count = rem; 4346f81c6224SJoe Perches } 434799811510SSuraj Sumangala 434899811510SSuraj Sumangala return rem; 434999811510SSuraj Sumangala } 435099811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 435199811510SSuraj Sumangala 43521da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 43531da177e4SLinus Torvalds 43541da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 43551da177e4SLinus Torvalds { 43561da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 43571da177e4SLinus Torvalds 4358f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 43591da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 4360f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 43611da177e4SLinus Torvalds 43621da177e4SLinus Torvalds return 0; 43631da177e4SLinus Torvalds } 43641da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 43651da177e4SLinus Torvalds 43661da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 43671da177e4SLinus Torvalds { 43681da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 43691da177e4SLinus Torvalds 4370f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 43711da177e4SLinus Torvalds list_del(&cb->list); 4372f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 43731da177e4SLinus Torvalds 43741da177e4SLinus Torvalds return 0; 43751da177e4SLinus Torvalds } 43761da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 43771da177e4SLinus Torvalds 437851086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 43791da177e4SLinus Torvalds { 4380cdc52faaSMarcel Holtmann int err; 4381cdc52faaSMarcel Holtmann 43820d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 43831da177e4SLinus Torvalds 43841da177e4SLinus Torvalds /* Time stamp */ 4385a61bbcf2SPatrick McHardy __net_timestamp(skb); 43861da177e4SLinus Torvalds 4387cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4388cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4389cd82e61cSMarcel Holtmann 4390cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 4391cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 4392470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 43931da177e4SLinus Torvalds } 43941da177e4SLinus Torvalds 43951da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 43961da177e4SLinus Torvalds skb_orphan(skb); 43971da177e4SLinus Torvalds 4398cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 4399cdc52faaSMarcel Holtmann if (err < 0) { 4400cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 4401cdc52faaSMarcel Holtmann kfree_skb(skb); 4402cdc52faaSMarcel Holtmann } 44031da177e4SLinus Torvalds } 44041da177e4SLinus Torvalds 44053119ae95SJohan Hedberg void hci_req_init(struct hci_request *req, struct hci_dev *hdev) 44063119ae95SJohan Hedberg { 44073119ae95SJohan Hedberg skb_queue_head_init(&req->cmd_q); 44083119ae95SJohan Hedberg req->hdev = hdev; 44095d73e034SAndre Guedes req->err = 0; 44103119ae95SJohan Hedberg } 44113119ae95SJohan Hedberg 44123119ae95SJohan Hedberg int hci_req_run(struct hci_request *req, hci_req_complete_t complete) 44133119ae95SJohan Hedberg { 44143119ae95SJohan Hedberg struct hci_dev *hdev = req->hdev; 44153119ae95SJohan Hedberg struct sk_buff *skb; 44163119ae95SJohan Hedberg unsigned long flags; 44173119ae95SJohan Hedberg 44183119ae95SJohan Hedberg BT_DBG("length %u", skb_queue_len(&req->cmd_q)); 44193119ae95SJohan Hedberg 44205d73e034SAndre Guedes /* If an error occured during request building, remove all HCI 44215d73e034SAndre Guedes * commands queued on the HCI request queue. 44225d73e034SAndre Guedes */ 44235d73e034SAndre Guedes if (req->err) { 44245d73e034SAndre Guedes skb_queue_purge(&req->cmd_q); 44255d73e034SAndre Guedes return req->err; 44265d73e034SAndre Guedes } 44275d73e034SAndre Guedes 44283119ae95SJohan Hedberg /* Do not allow empty requests */ 44293119ae95SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 4430382b0c39SAndre Guedes return -ENODATA; 44313119ae95SJohan Hedberg 44323119ae95SJohan Hedberg skb = skb_peek_tail(&req->cmd_q); 44333119ae95SJohan Hedberg bt_cb(skb)->req.complete = complete; 44343119ae95SJohan Hedberg 44353119ae95SJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 44363119ae95SJohan Hedberg skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q); 44373119ae95SJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 44383119ae95SJohan Hedberg 44393119ae95SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 44403119ae95SJohan Hedberg 44413119ae95SJohan Hedberg return 0; 44423119ae95SJohan Hedberg } 44433119ae95SJohan Hedberg 4444899de765SMarcel Holtmann bool hci_req_pending(struct hci_dev *hdev) 4445899de765SMarcel Holtmann { 4446899de765SMarcel Holtmann return (hdev->req_status == HCI_REQ_PEND); 4447899de765SMarcel Holtmann } 4448899de765SMarcel Holtmann 44491ca3a9d0SJohan Hedberg static struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, 445007dc93ddSJohan Hedberg u32 plen, const void *param) 44511da177e4SLinus Torvalds { 44521da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 44531da177e4SLinus Torvalds struct hci_command_hdr *hdr; 44541da177e4SLinus Torvalds struct sk_buff *skb; 44551da177e4SLinus Torvalds 44561da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 44571ca3a9d0SJohan Hedberg if (!skb) 44581ca3a9d0SJohan Hedberg return NULL; 44591da177e4SLinus Torvalds 44601da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 4461a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 44621da177e4SLinus Torvalds hdr->plen = plen; 44631da177e4SLinus Torvalds 44641da177e4SLinus Torvalds if (plen) 44651da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 44661da177e4SLinus Torvalds 44671da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 44681da177e4SLinus Torvalds 44690d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 4470c78ae283SMarcel Holtmann 44711ca3a9d0SJohan Hedberg return skb; 44721ca3a9d0SJohan Hedberg } 44731ca3a9d0SJohan Hedberg 44741ca3a9d0SJohan Hedberg /* Send HCI command */ 447507dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 447607dc93ddSJohan Hedberg const void *param) 44771ca3a9d0SJohan Hedberg { 44781ca3a9d0SJohan Hedberg struct sk_buff *skb; 44791ca3a9d0SJohan Hedberg 44801ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 44811ca3a9d0SJohan Hedberg 44821ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 44831ca3a9d0SJohan Hedberg if (!skb) { 44841ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 44851ca3a9d0SJohan Hedberg return -ENOMEM; 44861ca3a9d0SJohan Hedberg } 44871ca3a9d0SJohan Hedberg 448811714b3dSJohan Hedberg /* Stand-alone HCI commands must be flaged as 448911714b3dSJohan Hedberg * single-command requests. 449011714b3dSJohan Hedberg */ 449111714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 449211714b3dSJohan Hedberg 44931da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 4494c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 44951da177e4SLinus Torvalds 44961da177e4SLinus Torvalds return 0; 44971da177e4SLinus Torvalds } 44981da177e4SLinus Torvalds 449971c76a17SJohan Hedberg /* Queue a command to an asynchronous HCI request */ 450007dc93ddSJohan Hedberg void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen, 450107dc93ddSJohan Hedberg const void *param, u8 event) 450271c76a17SJohan Hedberg { 450371c76a17SJohan Hedberg struct hci_dev *hdev = req->hdev; 450471c76a17SJohan Hedberg struct sk_buff *skb; 450571c76a17SJohan Hedberg 450671c76a17SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 450771c76a17SJohan Hedberg 450834739c1eSAndre Guedes /* If an error occured during request building, there is no point in 450934739c1eSAndre Guedes * queueing the HCI command. We can simply return. 451034739c1eSAndre Guedes */ 451134739c1eSAndre Guedes if (req->err) 451234739c1eSAndre Guedes return; 451334739c1eSAndre Guedes 451471c76a17SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 451571c76a17SJohan Hedberg if (!skb) { 45165d73e034SAndre Guedes BT_ERR("%s no memory for command (opcode 0x%4.4x)", 45175d73e034SAndre Guedes hdev->name, opcode); 45185d73e034SAndre Guedes req->err = -ENOMEM; 4519e348fe6bSAndre Guedes return; 452071c76a17SJohan Hedberg } 452171c76a17SJohan Hedberg 452271c76a17SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 452371c76a17SJohan Hedberg bt_cb(skb)->req.start = true; 452471c76a17SJohan Hedberg 452502350a72SJohan Hedberg bt_cb(skb)->req.event = event; 452602350a72SJohan Hedberg 452771c76a17SJohan Hedberg skb_queue_tail(&req->cmd_q, skb); 452871c76a17SJohan Hedberg } 452971c76a17SJohan Hedberg 453007dc93ddSJohan Hedberg void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, 453107dc93ddSJohan Hedberg const void *param) 453202350a72SJohan Hedberg { 453302350a72SJohan Hedberg hci_req_add_ev(req, opcode, plen, param, 0); 453402350a72SJohan Hedberg } 453502350a72SJohan Hedberg 45361da177e4SLinus Torvalds /* Get data from the previously sent command */ 4537a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 45381da177e4SLinus Torvalds { 45391da177e4SLinus Torvalds struct hci_command_hdr *hdr; 45401da177e4SLinus Torvalds 45411da177e4SLinus Torvalds if (!hdev->sent_cmd) 45421da177e4SLinus Torvalds return NULL; 45431da177e4SLinus Torvalds 45441da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 45451da177e4SLinus Torvalds 4546a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 45471da177e4SLinus Torvalds return NULL; 45481da177e4SLinus Torvalds 4549f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 45501da177e4SLinus Torvalds 45511da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 45521da177e4SLinus Torvalds } 45531da177e4SLinus Torvalds 45541da177e4SLinus Torvalds /* Send ACL data */ 45551da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 45561da177e4SLinus Torvalds { 45571da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 45581da177e4SLinus Torvalds int len = skb->len; 45591da177e4SLinus Torvalds 4560badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 4561badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 45629c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 4563aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 4564aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 45651da177e4SLinus Torvalds } 45661da177e4SLinus Torvalds 4567ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 456873d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 45691da177e4SLinus Torvalds { 4570ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 45711da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 45721da177e4SLinus Torvalds struct sk_buff *list; 45731da177e4SLinus Torvalds 4574087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 4575087bfd99SGustavo Padovan skb->data_len = 0; 4576087bfd99SGustavo Padovan 4577087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4578204a6e54SAndrei Emeltchenko 4579204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 4580204a6e54SAndrei Emeltchenko case HCI_BREDR: 4581087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 4582204a6e54SAndrei Emeltchenko break; 4583204a6e54SAndrei Emeltchenko case HCI_AMP: 4584204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 4585204a6e54SAndrei Emeltchenko break; 4586204a6e54SAndrei Emeltchenko default: 4587204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 4588204a6e54SAndrei Emeltchenko return; 4589204a6e54SAndrei Emeltchenko } 4590087bfd99SGustavo Padovan 459170f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 459270f23020SAndrei Emeltchenko if (!list) { 45931da177e4SLinus Torvalds /* Non fragmented */ 45941da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 45951da177e4SLinus Torvalds 459673d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 45971da177e4SLinus Torvalds } else { 45981da177e4SLinus Torvalds /* Fragmented */ 45991da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 46001da177e4SLinus Torvalds 46011da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 46021da177e4SLinus Torvalds 46031da177e4SLinus Torvalds /* Queue all fragments atomically */ 4604af3e6359SGustavo F. Padovan spin_lock(&queue->lock); 46051da177e4SLinus Torvalds 460673d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 4607e702112fSAndrei Emeltchenko 4608e702112fSAndrei Emeltchenko flags &= ~ACL_START; 4609e702112fSAndrei Emeltchenko flags |= ACL_CONT; 46101da177e4SLinus Torvalds do { 46111da177e4SLinus Torvalds skb = list; list = list->next; 46121da177e4SLinus Torvalds 46130d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4614e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 46151da177e4SLinus Torvalds 46161da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 46171da177e4SLinus Torvalds 461873d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 46191da177e4SLinus Torvalds } while (list); 46201da177e4SLinus Torvalds 4621af3e6359SGustavo F. Padovan spin_unlock(&queue->lock); 46221da177e4SLinus Torvalds } 462373d80debSLuiz Augusto von Dentz } 462473d80debSLuiz Augusto von Dentz 462573d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 462673d80debSLuiz Augusto von Dentz { 4627ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 462873d80debSLuiz Augusto von Dentz 4629f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 463073d80debSLuiz Augusto von Dentz 4631ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 46321da177e4SLinus Torvalds 46333eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 46341da177e4SLinus Torvalds } 46351da177e4SLinus Torvalds 46361da177e4SLinus Torvalds /* Send SCO data */ 46370d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 46381da177e4SLinus Torvalds { 46391da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 46401da177e4SLinus Torvalds struct hci_sco_hdr hdr; 46411da177e4SLinus Torvalds 46421da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 46431da177e4SLinus Torvalds 4644aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 46451da177e4SLinus Torvalds hdr.dlen = skb->len; 46461da177e4SLinus Torvalds 4647badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 4648badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 46499c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 46501da177e4SLinus Torvalds 46510d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 4652c78ae283SMarcel Holtmann 46531da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 46543eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 46551da177e4SLinus Torvalds } 46561da177e4SLinus Torvalds 46571da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 46581da177e4SLinus Torvalds 46591da177e4SLinus Torvalds /* HCI Connection scheduler */ 46606039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 4661a8c5fb1aSGustavo Padovan int *quote) 46621da177e4SLinus Torvalds { 46631da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 46648035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 4665abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 46661da177e4SLinus Torvalds 46671da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 46681da177e4SLinus Torvalds * added and removed with TX task disabled. */ 4669bf4c6325SGustavo F. Padovan 4670bf4c6325SGustavo F. Padovan rcu_read_lock(); 4671bf4c6325SGustavo F. Padovan 4672bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4673769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 46741da177e4SLinus Torvalds continue; 4675769be974SMarcel Holtmann 4676769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 4677769be974SMarcel Holtmann continue; 4678769be974SMarcel Holtmann 46791da177e4SLinus Torvalds num++; 46801da177e4SLinus Torvalds 46811da177e4SLinus Torvalds if (c->sent < min) { 46821da177e4SLinus Torvalds min = c->sent; 46831da177e4SLinus Torvalds conn = c; 46841da177e4SLinus Torvalds } 468552087a79SLuiz Augusto von Dentz 468652087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 468752087a79SLuiz Augusto von Dentz break; 46881da177e4SLinus Torvalds } 46891da177e4SLinus Torvalds 4690bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4691bf4c6325SGustavo F. Padovan 46921da177e4SLinus Torvalds if (conn) { 46936ed58ec5SVille Tervo int cnt, q; 46946ed58ec5SVille Tervo 46956ed58ec5SVille Tervo switch (conn->type) { 46966ed58ec5SVille Tervo case ACL_LINK: 46976ed58ec5SVille Tervo cnt = hdev->acl_cnt; 46986ed58ec5SVille Tervo break; 46996ed58ec5SVille Tervo case SCO_LINK: 47006ed58ec5SVille Tervo case ESCO_LINK: 47016ed58ec5SVille Tervo cnt = hdev->sco_cnt; 47026ed58ec5SVille Tervo break; 47036ed58ec5SVille Tervo case LE_LINK: 47046ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 47056ed58ec5SVille Tervo break; 47066ed58ec5SVille Tervo default: 47076ed58ec5SVille Tervo cnt = 0; 47086ed58ec5SVille Tervo BT_ERR("Unknown link type"); 47096ed58ec5SVille Tervo } 47106ed58ec5SVille Tervo 47116ed58ec5SVille Tervo q = cnt / num; 47121da177e4SLinus Torvalds *quote = q ? q : 1; 47131da177e4SLinus Torvalds } else 47141da177e4SLinus Torvalds *quote = 0; 47151da177e4SLinus Torvalds 47161da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 47171da177e4SLinus Torvalds return conn; 47181da177e4SLinus Torvalds } 47191da177e4SLinus Torvalds 47206039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 47211da177e4SLinus Torvalds { 47221da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 47231da177e4SLinus Torvalds struct hci_conn *c; 47241da177e4SLinus Torvalds 4725bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 47261da177e4SLinus Torvalds 4727bf4c6325SGustavo F. Padovan rcu_read_lock(); 4728bf4c6325SGustavo F. Padovan 47291da177e4SLinus Torvalds /* Kill stalled connections */ 4730bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4731bae1f5d9SVille Tervo if (c->type == type && c->sent) { 47326ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 47336ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 4734bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 47351da177e4SLinus Torvalds } 47361da177e4SLinus Torvalds } 4737bf4c6325SGustavo F. Padovan 4738bf4c6325SGustavo F. Padovan rcu_read_unlock(); 47391da177e4SLinus Torvalds } 47401da177e4SLinus Torvalds 47416039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 474273d80debSLuiz Augusto von Dentz int *quote) 474373d80debSLuiz Augusto von Dentz { 474473d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 474573d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 4746abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 474773d80debSLuiz Augusto von Dentz struct hci_conn *conn; 474873d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 474973d80debSLuiz Augusto von Dentz 475073d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 475173d80debSLuiz Augusto von Dentz 4752bf4c6325SGustavo F. Padovan rcu_read_lock(); 4753bf4c6325SGustavo F. Padovan 4754bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 475573d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 475673d80debSLuiz Augusto von Dentz 475773d80debSLuiz Augusto von Dentz if (conn->type != type) 475873d80debSLuiz Augusto von Dentz continue; 475973d80debSLuiz Augusto von Dentz 476073d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 476173d80debSLuiz Augusto von Dentz continue; 476273d80debSLuiz Augusto von Dentz 476373d80debSLuiz Augusto von Dentz conn_num++; 476473d80debSLuiz Augusto von Dentz 47658192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 476673d80debSLuiz Augusto von Dentz struct sk_buff *skb; 476773d80debSLuiz Augusto von Dentz 476873d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 476973d80debSLuiz Augusto von Dentz continue; 477073d80debSLuiz Augusto von Dentz 477173d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 477273d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 477373d80debSLuiz Augusto von Dentz continue; 477473d80debSLuiz Augusto von Dentz 477573d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 477673d80debSLuiz Augusto von Dentz num = 0; 477773d80debSLuiz Augusto von Dentz min = ~0; 477873d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 477973d80debSLuiz Augusto von Dentz } 478073d80debSLuiz Augusto von Dentz 478173d80debSLuiz Augusto von Dentz num++; 478273d80debSLuiz Augusto von Dentz 478373d80debSLuiz Augusto von Dentz if (conn->sent < min) { 478473d80debSLuiz Augusto von Dentz min = conn->sent; 478573d80debSLuiz Augusto von Dentz chan = tmp; 478673d80debSLuiz Augusto von Dentz } 478773d80debSLuiz Augusto von Dentz } 478873d80debSLuiz Augusto von Dentz 478973d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 479073d80debSLuiz Augusto von Dentz break; 479173d80debSLuiz Augusto von Dentz } 479273d80debSLuiz Augusto von Dentz 4793bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4794bf4c6325SGustavo F. Padovan 479573d80debSLuiz Augusto von Dentz if (!chan) 479673d80debSLuiz Augusto von Dentz return NULL; 479773d80debSLuiz Augusto von Dentz 479873d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 479973d80debSLuiz Augusto von Dentz case ACL_LINK: 480073d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 480173d80debSLuiz Augusto von Dentz break; 4802bd1eb66bSAndrei Emeltchenko case AMP_LINK: 4803bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 4804bd1eb66bSAndrei Emeltchenko break; 480573d80debSLuiz Augusto von Dentz case SCO_LINK: 480673d80debSLuiz Augusto von Dentz case ESCO_LINK: 480773d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 480873d80debSLuiz Augusto von Dentz break; 480973d80debSLuiz Augusto von Dentz case LE_LINK: 481073d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 481173d80debSLuiz Augusto von Dentz break; 481273d80debSLuiz Augusto von Dentz default: 481373d80debSLuiz Augusto von Dentz cnt = 0; 481473d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 481573d80debSLuiz Augusto von Dentz } 481673d80debSLuiz Augusto von Dentz 481773d80debSLuiz Augusto von Dentz q = cnt / num; 481873d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 481973d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 482073d80debSLuiz Augusto von Dentz return chan; 482173d80debSLuiz Augusto von Dentz } 482273d80debSLuiz Augusto von Dentz 482302b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 482402b20f0bSLuiz Augusto von Dentz { 482502b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 482602b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 482702b20f0bSLuiz Augusto von Dentz int num = 0; 482802b20f0bSLuiz Augusto von Dentz 482902b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 483002b20f0bSLuiz Augusto von Dentz 4831bf4c6325SGustavo F. Padovan rcu_read_lock(); 4832bf4c6325SGustavo F. Padovan 4833bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 483402b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 483502b20f0bSLuiz Augusto von Dentz 483602b20f0bSLuiz Augusto von Dentz if (conn->type != type) 483702b20f0bSLuiz Augusto von Dentz continue; 483802b20f0bSLuiz Augusto von Dentz 483902b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 484002b20f0bSLuiz Augusto von Dentz continue; 484102b20f0bSLuiz Augusto von Dentz 484202b20f0bSLuiz Augusto von Dentz num++; 484302b20f0bSLuiz Augusto von Dentz 48448192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 484502b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 484602b20f0bSLuiz Augusto von Dentz 484702b20f0bSLuiz Augusto von Dentz if (chan->sent) { 484802b20f0bSLuiz Augusto von Dentz chan->sent = 0; 484902b20f0bSLuiz Augusto von Dentz continue; 485002b20f0bSLuiz Augusto von Dentz } 485102b20f0bSLuiz Augusto von Dentz 485202b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 485302b20f0bSLuiz Augusto von Dentz continue; 485402b20f0bSLuiz Augusto von Dentz 485502b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 485602b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 485702b20f0bSLuiz Augusto von Dentz continue; 485802b20f0bSLuiz Augusto von Dentz 485902b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 486002b20f0bSLuiz Augusto von Dentz 486102b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 486202b20f0bSLuiz Augusto von Dentz skb->priority); 486302b20f0bSLuiz Augusto von Dentz } 486402b20f0bSLuiz Augusto von Dentz 486502b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 486602b20f0bSLuiz Augusto von Dentz break; 486702b20f0bSLuiz Augusto von Dentz } 4868bf4c6325SGustavo F. Padovan 4869bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4870bf4c6325SGustavo F. Padovan 487102b20f0bSLuiz Augusto von Dentz } 487202b20f0bSLuiz Augusto von Dentz 4873b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 4874b71d385aSAndrei Emeltchenko { 4875b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 4876b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 4877b71d385aSAndrei Emeltchenko } 4878b71d385aSAndrei Emeltchenko 48796039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 48801da177e4SLinus Torvalds { 48814a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 48821da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 48831da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 488463d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 48855f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 4886bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 48871da177e4SLinus Torvalds } 488863d2bc1bSAndrei Emeltchenko } 48891da177e4SLinus Torvalds 48906039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 489163d2bc1bSAndrei Emeltchenko { 489263d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 489363d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 489463d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 489563d2bc1bSAndrei Emeltchenko int quote; 489663d2bc1bSAndrei Emeltchenko 489763d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 489804837f64SMarcel Holtmann 489973d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 490073d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 4901ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4902ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 490373d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 490473d80debSLuiz Augusto von Dentz skb->len, skb->priority); 490573d80debSLuiz Augusto von Dentz 4906ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4907ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4908ec1cce24SLuiz Augusto von Dentz break; 4909ec1cce24SLuiz Augusto von Dentz 4910ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4911ec1cce24SLuiz Augusto von Dentz 491273d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 491373d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 491404837f64SMarcel Holtmann 491557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 49161da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 49171da177e4SLinus Torvalds 49181da177e4SLinus Torvalds hdev->acl_cnt--; 491973d80debSLuiz Augusto von Dentz chan->sent++; 492073d80debSLuiz Augusto von Dentz chan->conn->sent++; 49211da177e4SLinus Torvalds } 49221da177e4SLinus Torvalds } 492302b20f0bSLuiz Augusto von Dentz 492402b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 492502b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 49261da177e4SLinus Torvalds } 49271da177e4SLinus Torvalds 49286039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 4929b71d385aSAndrei Emeltchenko { 493063d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 4931b71d385aSAndrei Emeltchenko struct hci_chan *chan; 4932b71d385aSAndrei Emeltchenko struct sk_buff *skb; 4933b71d385aSAndrei Emeltchenko int quote; 4934bd1eb66bSAndrei Emeltchenko u8 type; 4935b71d385aSAndrei Emeltchenko 493663d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 4937b71d385aSAndrei Emeltchenko 4938bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4939bd1eb66bSAndrei Emeltchenko 4940bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 4941bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 4942bd1eb66bSAndrei Emeltchenko else 4943bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 4944bd1eb66bSAndrei Emeltchenko 4945b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 4946bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 4947b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 4948b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 4949b71d385aSAndrei Emeltchenko int blocks; 4950b71d385aSAndrei Emeltchenko 4951b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 4952b71d385aSAndrei Emeltchenko skb->len, skb->priority); 4953b71d385aSAndrei Emeltchenko 4954b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 4955b71d385aSAndrei Emeltchenko if (skb->priority < priority) 4956b71d385aSAndrei Emeltchenko break; 4957b71d385aSAndrei Emeltchenko 4958b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 4959b71d385aSAndrei Emeltchenko 4960b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 4961b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 4962b71d385aSAndrei Emeltchenko return; 4963b71d385aSAndrei Emeltchenko 4964b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 4965b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 4966b71d385aSAndrei Emeltchenko 496757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4968b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 4969b71d385aSAndrei Emeltchenko 4970b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 4971b71d385aSAndrei Emeltchenko quote -= blocks; 4972b71d385aSAndrei Emeltchenko 4973b71d385aSAndrei Emeltchenko chan->sent += blocks; 4974b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 4975b71d385aSAndrei Emeltchenko } 4976b71d385aSAndrei Emeltchenko } 4977b71d385aSAndrei Emeltchenko 4978b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 4979bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 4980b71d385aSAndrei Emeltchenko } 4981b71d385aSAndrei Emeltchenko 49826039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 4983b71d385aSAndrei Emeltchenko { 4984b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4985b71d385aSAndrei Emeltchenko 4986bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 4987bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 4988bd1eb66bSAndrei Emeltchenko return; 4989bd1eb66bSAndrei Emeltchenko 4990bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 4991bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 4992b71d385aSAndrei Emeltchenko return; 4993b71d385aSAndrei Emeltchenko 4994b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 4995b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 4996b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 4997b71d385aSAndrei Emeltchenko break; 4998b71d385aSAndrei Emeltchenko 4999b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 5000b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 5001b71d385aSAndrei Emeltchenko break; 5002b71d385aSAndrei Emeltchenko } 5003b71d385aSAndrei Emeltchenko } 5004b71d385aSAndrei Emeltchenko 50051da177e4SLinus Torvalds /* Schedule SCO */ 50066039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 50071da177e4SLinus Torvalds { 50081da177e4SLinus Torvalds struct hci_conn *conn; 50091da177e4SLinus Torvalds struct sk_buff *skb; 50101da177e4SLinus Torvalds int quote; 50111da177e4SLinus Torvalds 50121da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 50131da177e4SLinus Torvalds 501452087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 501552087a79SLuiz Augusto von Dentz return; 501652087a79SLuiz Augusto von Dentz 50171da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 50181da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 50191da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 502057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 50211da177e4SLinus Torvalds 50221da177e4SLinus Torvalds conn->sent++; 50231da177e4SLinus Torvalds if (conn->sent == ~0) 50241da177e4SLinus Torvalds conn->sent = 0; 50251da177e4SLinus Torvalds } 50261da177e4SLinus Torvalds } 50271da177e4SLinus Torvalds } 50281da177e4SLinus Torvalds 50296039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 5030b6a0dc82SMarcel Holtmann { 5031b6a0dc82SMarcel Holtmann struct hci_conn *conn; 5032b6a0dc82SMarcel Holtmann struct sk_buff *skb; 5033b6a0dc82SMarcel Holtmann int quote; 5034b6a0dc82SMarcel Holtmann 5035b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 5036b6a0dc82SMarcel Holtmann 503752087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 503852087a79SLuiz Augusto von Dentz return; 503952087a79SLuiz Augusto von Dentz 50408fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 50418fc9ced3SGustavo Padovan "e))) { 5042b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 5043b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 504457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 5045b6a0dc82SMarcel Holtmann 5046b6a0dc82SMarcel Holtmann conn->sent++; 5047b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 5048b6a0dc82SMarcel Holtmann conn->sent = 0; 5049b6a0dc82SMarcel Holtmann } 5050b6a0dc82SMarcel Holtmann } 5051b6a0dc82SMarcel Holtmann } 5052b6a0dc82SMarcel Holtmann 50536039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 50546ed58ec5SVille Tervo { 505573d80debSLuiz Augusto von Dentz struct hci_chan *chan; 50566ed58ec5SVille Tervo struct sk_buff *skb; 505702b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 50586ed58ec5SVille Tervo 50596ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 50606ed58ec5SVille Tervo 506152087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 506252087a79SLuiz Augusto von Dentz return; 506352087a79SLuiz Augusto von Dentz 50644a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 50656ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 50666ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 5067bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 50686ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 5069bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 50706ed58ec5SVille Tervo } 50716ed58ec5SVille Tervo 50726ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 507302b20f0bSLuiz Augusto von Dentz tmp = cnt; 507473d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 5075ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 5076ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 507773d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 507873d80debSLuiz Augusto von Dentz skb->len, skb->priority); 50796ed58ec5SVille Tervo 5080ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 5081ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 5082ec1cce24SLuiz Augusto von Dentz break; 5083ec1cce24SLuiz Augusto von Dentz 5084ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 5085ec1cce24SLuiz Augusto von Dentz 508657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 50876ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 50886ed58ec5SVille Tervo 50896ed58ec5SVille Tervo cnt--; 509073d80debSLuiz Augusto von Dentz chan->sent++; 509173d80debSLuiz Augusto von Dentz chan->conn->sent++; 50926ed58ec5SVille Tervo } 50936ed58ec5SVille Tervo } 509473d80debSLuiz Augusto von Dentz 50956ed58ec5SVille Tervo if (hdev->le_pkts) 50966ed58ec5SVille Tervo hdev->le_cnt = cnt; 50976ed58ec5SVille Tervo else 50986ed58ec5SVille Tervo hdev->acl_cnt = cnt; 509902b20f0bSLuiz Augusto von Dentz 510002b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 510102b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 51026ed58ec5SVille Tervo } 51036ed58ec5SVille Tervo 51043eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 51051da177e4SLinus Torvalds { 51063eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 51071da177e4SLinus Torvalds struct sk_buff *skb; 51081da177e4SLinus Torvalds 51096ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 51106ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 51111da177e4SLinus Torvalds 511252de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 51131da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 51141da177e4SLinus Torvalds hci_sched_acl(hdev); 51151da177e4SLinus Torvalds hci_sched_sco(hdev); 5116b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 51176ed58ec5SVille Tervo hci_sched_le(hdev); 511852de599eSMarcel Holtmann } 51196ed58ec5SVille Tervo 51201da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 51211da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 512257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 51231da177e4SLinus Torvalds } 51241da177e4SLinus Torvalds 512525985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 51261da177e4SLinus Torvalds 51271da177e4SLinus Torvalds /* ACL data packet */ 51286039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 51291da177e4SLinus Torvalds { 51301da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 51311da177e4SLinus Torvalds struct hci_conn *conn; 51321da177e4SLinus Torvalds __u16 handle, flags; 51331da177e4SLinus Torvalds 51341da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 51351da177e4SLinus Torvalds 51361da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 51371da177e4SLinus Torvalds flags = hci_flags(handle); 51381da177e4SLinus Torvalds handle = hci_handle(handle); 51391da177e4SLinus Torvalds 5140f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 5141a8c5fb1aSGustavo Padovan handle, flags); 51421da177e4SLinus Torvalds 51431da177e4SLinus Torvalds hdev->stat.acl_rx++; 51441da177e4SLinus Torvalds 51451da177e4SLinus Torvalds hci_dev_lock(hdev); 51461da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 51471da177e4SLinus Torvalds hci_dev_unlock(hdev); 51481da177e4SLinus Torvalds 51491da177e4SLinus Torvalds if (conn) { 515065983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 515104837f64SMarcel Holtmann 51521da177e4SLinus Torvalds /* Send to upper protocol */ 5153686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 51541da177e4SLinus Torvalds return; 51551da177e4SLinus Torvalds } else { 51561da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 51571da177e4SLinus Torvalds hdev->name, handle); 51581da177e4SLinus Torvalds } 51591da177e4SLinus Torvalds 51601da177e4SLinus Torvalds kfree_skb(skb); 51611da177e4SLinus Torvalds } 51621da177e4SLinus Torvalds 51631da177e4SLinus Torvalds /* SCO data packet */ 51646039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 51651da177e4SLinus Torvalds { 51661da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 51671da177e4SLinus Torvalds struct hci_conn *conn; 51681da177e4SLinus Torvalds __u16 handle; 51691da177e4SLinus Torvalds 51701da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 51711da177e4SLinus Torvalds 51721da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 51731da177e4SLinus Torvalds 5174f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 51751da177e4SLinus Torvalds 51761da177e4SLinus Torvalds hdev->stat.sco_rx++; 51771da177e4SLinus Torvalds 51781da177e4SLinus Torvalds hci_dev_lock(hdev); 51791da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 51801da177e4SLinus Torvalds hci_dev_unlock(hdev); 51811da177e4SLinus Torvalds 51821da177e4SLinus Torvalds if (conn) { 51831da177e4SLinus Torvalds /* Send to upper protocol */ 5184686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 51851da177e4SLinus Torvalds return; 51861da177e4SLinus Torvalds } else { 51871da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 51881da177e4SLinus Torvalds hdev->name, handle); 51891da177e4SLinus Torvalds } 51901da177e4SLinus Torvalds 51911da177e4SLinus Torvalds kfree_skb(skb); 51921da177e4SLinus Torvalds } 51931da177e4SLinus Torvalds 51949238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 51959238f36aSJohan Hedberg { 51969238f36aSJohan Hedberg struct sk_buff *skb; 51979238f36aSJohan Hedberg 51989238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 51999238f36aSJohan Hedberg if (!skb) 52009238f36aSJohan Hedberg return true; 52019238f36aSJohan Hedberg 52029238f36aSJohan Hedberg return bt_cb(skb)->req.start; 52039238f36aSJohan Hedberg } 52049238f36aSJohan Hedberg 520542c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 520642c6b129SJohan Hedberg { 520742c6b129SJohan Hedberg struct hci_command_hdr *sent; 520842c6b129SJohan Hedberg struct sk_buff *skb; 520942c6b129SJohan Hedberg u16 opcode; 521042c6b129SJohan Hedberg 521142c6b129SJohan Hedberg if (!hdev->sent_cmd) 521242c6b129SJohan Hedberg return; 521342c6b129SJohan Hedberg 521442c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 521542c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 521642c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 521742c6b129SJohan Hedberg return; 521842c6b129SJohan Hedberg 521942c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 522042c6b129SJohan Hedberg if (!skb) 522142c6b129SJohan Hedberg return; 522242c6b129SJohan Hedberg 522342c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 522442c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 522542c6b129SJohan Hedberg } 522642c6b129SJohan Hedberg 52279238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 52289238f36aSJohan Hedberg { 52299238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 52309238f36aSJohan Hedberg struct sk_buff *skb; 52319238f36aSJohan Hedberg unsigned long flags; 52329238f36aSJohan Hedberg 52339238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 52349238f36aSJohan Hedberg 523542c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 523642c6b129SJohan Hedberg * sent we need to do special handling of it. 52379238f36aSJohan Hedberg */ 523842c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 523942c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 524042c6b129SJohan Hedberg * reset complete event during init and any pending 524142c6b129SJohan Hedberg * command will never be completed. In such a case we 524242c6b129SJohan Hedberg * need to resend whatever was the last sent 524342c6b129SJohan Hedberg * command. 524442c6b129SJohan Hedberg */ 524542c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 524642c6b129SJohan Hedberg hci_resend_last(hdev); 524742c6b129SJohan Hedberg 52489238f36aSJohan Hedberg return; 524942c6b129SJohan Hedberg } 52509238f36aSJohan Hedberg 52519238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 52529238f36aSJohan Hedberg * this request the request is not yet complete. 52539238f36aSJohan Hedberg */ 52549238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 52559238f36aSJohan Hedberg return; 52569238f36aSJohan Hedberg 52579238f36aSJohan Hedberg /* If this was the last command in a request the complete 52589238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 52599238f36aSJohan Hedberg * command queue (hdev->cmd_q). 52609238f36aSJohan Hedberg */ 52619238f36aSJohan Hedberg if (hdev->sent_cmd) { 52629238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 526353e21fbcSJohan Hedberg 526453e21fbcSJohan Hedberg if (req_complete) { 526553e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 526653e21fbcSJohan Hedberg * avoid calling the callback more than once if 526753e21fbcSJohan Hedberg * this function gets called again. 526853e21fbcSJohan Hedberg */ 526953e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 527053e21fbcSJohan Hedberg 52719238f36aSJohan Hedberg goto call_complete; 52729238f36aSJohan Hedberg } 527353e21fbcSJohan Hedberg } 52749238f36aSJohan Hedberg 52759238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 52769238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 52779238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 52789238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 52799238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 52809238f36aSJohan Hedberg break; 52819238f36aSJohan Hedberg } 52829238f36aSJohan Hedberg 52839238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 52849238f36aSJohan Hedberg kfree_skb(skb); 52859238f36aSJohan Hedberg } 52869238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 52879238f36aSJohan Hedberg 52889238f36aSJohan Hedberg call_complete: 52899238f36aSJohan Hedberg if (req_complete) 52909238f36aSJohan Hedberg req_complete(hdev, status); 52919238f36aSJohan Hedberg } 52929238f36aSJohan Hedberg 5293b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 52941da177e4SLinus Torvalds { 5295b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 52961da177e4SLinus Torvalds struct sk_buff *skb; 52971da177e4SLinus Torvalds 52981da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 52991da177e4SLinus Torvalds 53001da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 5301cd82e61cSMarcel Holtmann /* Send copy to monitor */ 5302cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 5303cd82e61cSMarcel Holtmann 53041da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 53051da177e4SLinus Torvalds /* Send copy to the sockets */ 5306470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 53071da177e4SLinus Torvalds } 53081da177e4SLinus Torvalds 5309fee746b0SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 53101da177e4SLinus Torvalds kfree_skb(skb); 53111da177e4SLinus Torvalds continue; 53121da177e4SLinus Torvalds } 53131da177e4SLinus Torvalds 53141da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 53151da177e4SLinus Torvalds /* Don't process data packets in this states. */ 53160d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 53171da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 53181da177e4SLinus Torvalds case HCI_SCODATA_PKT: 53191da177e4SLinus Torvalds kfree_skb(skb); 53201da177e4SLinus Torvalds continue; 53213ff50b79SStephen Hemminger } 53221da177e4SLinus Torvalds } 53231da177e4SLinus Torvalds 53241da177e4SLinus Torvalds /* Process frame */ 53250d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 53261da177e4SLinus Torvalds case HCI_EVENT_PKT: 5327b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 53281da177e4SLinus Torvalds hci_event_packet(hdev, skb); 53291da177e4SLinus Torvalds break; 53301da177e4SLinus Torvalds 53311da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 53321da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 53331da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 53341da177e4SLinus Torvalds break; 53351da177e4SLinus Torvalds 53361da177e4SLinus Torvalds case HCI_SCODATA_PKT: 53371da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 53381da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 53391da177e4SLinus Torvalds break; 53401da177e4SLinus Torvalds 53411da177e4SLinus Torvalds default: 53421da177e4SLinus Torvalds kfree_skb(skb); 53431da177e4SLinus Torvalds break; 53441da177e4SLinus Torvalds } 53451da177e4SLinus Torvalds } 53461da177e4SLinus Torvalds } 53471da177e4SLinus Torvalds 5348c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 53491da177e4SLinus Torvalds { 5350c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 53511da177e4SLinus Torvalds struct sk_buff *skb; 53521da177e4SLinus Torvalds 53532104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 53542104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 53551da177e4SLinus Torvalds 53561da177e4SLinus Torvalds /* Send queued commands */ 53575a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 53585a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 53595a08ecceSAndrei Emeltchenko if (!skb) 53605a08ecceSAndrei Emeltchenko return; 53615a08ecceSAndrei Emeltchenko 53621da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 53631da177e4SLinus Torvalds 5364a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 536570f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 53661da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 536757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 53687bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 536965cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 53707bdb8a5cSSzymon Janc else 537165cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 537265cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 53731da177e4SLinus Torvalds } else { 53741da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 5375c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 53761da177e4SLinus Torvalds } 53771da177e4SLinus Torvalds } 53781da177e4SLinus Torvalds } 5379b1efcc28SAndre Guedes 5380b1efcc28SAndre Guedes void hci_req_add_le_scan_disable(struct hci_request *req) 5381b1efcc28SAndre Guedes { 5382b1efcc28SAndre Guedes struct hci_cp_le_set_scan_enable cp; 5383b1efcc28SAndre Guedes 5384b1efcc28SAndre Guedes memset(&cp, 0, sizeof(cp)); 5385b1efcc28SAndre Guedes cp.enable = LE_SCAN_DISABLE; 5386b1efcc28SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 5387b1efcc28SAndre Guedes } 5388a4790dbdSAndre Guedes 53898ef30fd3SAndre Guedes void hci_req_add_le_passive_scan(struct hci_request *req) 53908ef30fd3SAndre Guedes { 53918ef30fd3SAndre Guedes struct hci_cp_le_set_scan_param param_cp; 53928ef30fd3SAndre Guedes struct hci_cp_le_set_scan_enable enable_cp; 53938ef30fd3SAndre Guedes struct hci_dev *hdev = req->hdev; 53948ef30fd3SAndre Guedes u8 own_addr_type; 53958ef30fd3SAndre Guedes 53966ab535a7SMarcel Holtmann /* Set require_privacy to false since no SCAN_REQ are send 53976ab535a7SMarcel Holtmann * during passive scanning. Not using an unresolvable address 53986ab535a7SMarcel Holtmann * here is important so that peer devices using direct 53996ab535a7SMarcel Holtmann * advertising with our address will be correctly reported 54006ab535a7SMarcel Holtmann * by the controller. 54018ef30fd3SAndre Guedes */ 54026ab535a7SMarcel Holtmann if (hci_update_random_address(req, false, &own_addr_type)) 54038ef30fd3SAndre Guedes return; 54048ef30fd3SAndre Guedes 54058ef30fd3SAndre Guedes memset(¶m_cp, 0, sizeof(param_cp)); 54068ef30fd3SAndre Guedes param_cp.type = LE_SCAN_PASSIVE; 54078ef30fd3SAndre Guedes param_cp.interval = cpu_to_le16(hdev->le_scan_interval); 54088ef30fd3SAndre Guedes param_cp.window = cpu_to_le16(hdev->le_scan_window); 54098ef30fd3SAndre Guedes param_cp.own_address_type = own_addr_type; 54108ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_PARAM, sizeof(param_cp), 54118ef30fd3SAndre Guedes ¶m_cp); 54128ef30fd3SAndre Guedes 54138ef30fd3SAndre Guedes memset(&enable_cp, 0, sizeof(enable_cp)); 54148ef30fd3SAndre Guedes enable_cp.enable = LE_SCAN_ENABLE; 54154340a124SAndre Guedes enable_cp.filter_dup = LE_SCAN_FILTER_DUP_ENABLE; 54168ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(enable_cp), 54178ef30fd3SAndre Guedes &enable_cp); 54188ef30fd3SAndre Guedes } 54198ef30fd3SAndre Guedes 5420a4790dbdSAndre Guedes static void update_background_scan_complete(struct hci_dev *hdev, u8 status) 5421a4790dbdSAndre Guedes { 5422a4790dbdSAndre Guedes if (status) 5423a4790dbdSAndre Guedes BT_DBG("HCI request failed to update background scanning: " 5424a4790dbdSAndre Guedes "status 0x%2.2x", status); 5425a4790dbdSAndre Guedes } 5426a4790dbdSAndre Guedes 5427a4790dbdSAndre Guedes /* This function controls the background scanning based on hdev->pend_le_conns 5428a4790dbdSAndre Guedes * list. If there are pending LE connection we start the background scanning, 5429a4790dbdSAndre Guedes * otherwise we stop it. 5430a4790dbdSAndre Guedes * 5431a4790dbdSAndre Guedes * This function requires the caller holds hdev->lock. 5432a4790dbdSAndre Guedes */ 5433a4790dbdSAndre Guedes void hci_update_background_scan(struct hci_dev *hdev) 5434a4790dbdSAndre Guedes { 5435a4790dbdSAndre Guedes struct hci_request req; 5436a4790dbdSAndre Guedes struct hci_conn *conn; 5437a4790dbdSAndre Guedes int err; 5438a4790dbdSAndre Guedes 5439c20c02d5SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags) || 5440c20c02d5SMarcel Holtmann test_bit(HCI_INIT, &hdev->flags) || 5441c20c02d5SMarcel Holtmann test_bit(HCI_SETUP, &hdev->dev_flags) || 5442d603b76bSMarcel Holtmann test_bit(HCI_CONFIG, &hdev->dev_flags) || 5443b8221770SMarcel Holtmann test_bit(HCI_AUTO_OFF, &hdev->dev_flags) || 5444c20c02d5SMarcel Holtmann test_bit(HCI_UNREGISTER, &hdev->dev_flags)) 54451c1697c0SMarcel Holtmann return; 54461c1697c0SMarcel Holtmann 5447a70f4b5fSJohan Hedberg /* No point in doing scanning if LE support hasn't been enabled */ 5448a70f4b5fSJohan Hedberg if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 5449a70f4b5fSJohan Hedberg return; 5450a70f4b5fSJohan Hedberg 5451ae23ada4SJohan Hedberg /* If discovery is active don't interfere with it */ 5452ae23ada4SJohan Hedberg if (hdev->discovery.state != DISCOVERY_STOPPED) 5453ae23ada4SJohan Hedberg return; 5454ae23ada4SJohan Hedberg 5455a4790dbdSAndre Guedes hci_req_init(&req, hdev); 5456a4790dbdSAndre Guedes 54572b7be33eSJohan Hedberg if (!test_bit(HCI_CONNECTABLE, &hdev->dev_flags) && 54582b7be33eSJohan Hedberg list_empty(&hdev->pend_le_conns) && 545966f8455aSJohan Hedberg list_empty(&hdev->pend_le_reports)) { 54600d2bf134SJohan Hedberg /* If there is no pending LE connections or devices 54610d2bf134SJohan Hedberg * to be scanned for, we should stop the background 54620d2bf134SJohan Hedberg * scanning. 5463a4790dbdSAndre Guedes */ 5464a4790dbdSAndre Guedes 5465a4790dbdSAndre Guedes /* If controller is not scanning we are done. */ 5466a4790dbdSAndre Guedes if (!test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 5467a4790dbdSAndre Guedes return; 5468a4790dbdSAndre Guedes 5469a4790dbdSAndre Guedes hci_req_add_le_scan_disable(&req); 5470a4790dbdSAndre Guedes 5471a4790dbdSAndre Guedes BT_DBG("%s stopping background scanning", hdev->name); 5472a4790dbdSAndre Guedes } else { 5473a4790dbdSAndre Guedes /* If there is at least one pending LE connection, we should 5474a4790dbdSAndre Guedes * keep the background scan running. 5475a4790dbdSAndre Guedes */ 5476a4790dbdSAndre Guedes 5477a4790dbdSAndre Guedes /* If controller is connecting, we should not start scanning 5478a4790dbdSAndre Guedes * since some controllers are not able to scan and connect at 5479a4790dbdSAndre Guedes * the same time. 5480a4790dbdSAndre Guedes */ 5481a4790dbdSAndre Guedes conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT); 5482a4790dbdSAndre Guedes if (conn) 5483a4790dbdSAndre Guedes return; 5484a4790dbdSAndre Guedes 54854340a124SAndre Guedes /* If controller is currently scanning, we stop it to ensure we 54864340a124SAndre Guedes * don't miss any advertising (due to duplicates filter). 54874340a124SAndre Guedes */ 54884340a124SAndre Guedes if (test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 54894340a124SAndre Guedes hci_req_add_le_scan_disable(&req); 54904340a124SAndre Guedes 54918ef30fd3SAndre Guedes hci_req_add_le_passive_scan(&req); 5492a4790dbdSAndre Guedes 5493a4790dbdSAndre Guedes BT_DBG("%s starting background scanning", hdev->name); 5494a4790dbdSAndre Guedes } 5495a4790dbdSAndre Guedes 5496a4790dbdSAndre Guedes err = hci_req_run(&req, update_background_scan_complete); 5497a4790dbdSAndre Guedes if (err) 5498a4790dbdSAndre Guedes BT_ERR("Failed to run HCI request: err %d", err); 5499a4790dbdSAndre Guedes } 5500