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 White List Size */ 135242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 0, NULL); 13532177bab5SJohan Hedberg 1354747d3f03SMarcel Holtmann /* Clear LE White List */ 1355747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 1356c73eee91SJohan Hedberg 1357c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 1358c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1359c73eee91SJohan Hedberg set_bit(HCI_LE_ENABLED, &hdev->dev_flags); 13602177bab5SJohan Hedberg } 13612177bab5SJohan Hedberg 13622177bab5SJohan Hedberg static u8 hci_get_inquiry_mode(struct hci_dev *hdev) 13632177bab5SJohan Hedberg { 13642177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 13652177bab5SJohan Hedberg return 0x02; 13662177bab5SJohan Hedberg 13672177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 13682177bab5SJohan Hedberg return 0x01; 13692177bab5SJohan Hedberg 13702177bab5SJohan Hedberg if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 && 13712177bab5SJohan Hedberg hdev->lmp_subver == 0x0757) 13722177bab5SJohan Hedberg return 0x01; 13732177bab5SJohan Hedberg 13742177bab5SJohan Hedberg if (hdev->manufacturer == 15) { 13752177bab5SJohan Hedberg if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963) 13762177bab5SJohan Hedberg return 0x01; 13772177bab5SJohan Hedberg if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963) 13782177bab5SJohan Hedberg return 0x01; 13792177bab5SJohan Hedberg if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965) 13802177bab5SJohan Hedberg return 0x01; 13812177bab5SJohan Hedberg } 13822177bab5SJohan Hedberg 13832177bab5SJohan Hedberg if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 && 13842177bab5SJohan Hedberg hdev->lmp_subver == 0x1805) 13852177bab5SJohan Hedberg return 0x01; 13862177bab5SJohan Hedberg 13872177bab5SJohan Hedberg return 0x00; 13882177bab5SJohan Hedberg } 13892177bab5SJohan Hedberg 139042c6b129SJohan Hedberg static void hci_setup_inquiry_mode(struct hci_request *req) 13912177bab5SJohan Hedberg { 13922177bab5SJohan Hedberg u8 mode; 13932177bab5SJohan Hedberg 139442c6b129SJohan Hedberg mode = hci_get_inquiry_mode(req->hdev); 13952177bab5SJohan Hedberg 139642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 13972177bab5SJohan Hedberg } 13982177bab5SJohan Hedberg 139942c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 14002177bab5SJohan Hedberg { 140142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 140242c6b129SJohan Hedberg 14032177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 14042177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 14052177bab5SJohan Hedberg * command otherwise. 14062177bab5SJohan Hedberg */ 14072177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 14082177bab5SJohan Hedberg 14092177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 14102177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 14112177bab5SJohan Hedberg */ 14122177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 14132177bab5SJohan Hedberg return; 14142177bab5SJohan Hedberg 14152177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 14162177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 14172177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 14182177bab5SJohan Hedberg events[4] |= 0x04; /* Read Remote Extended Features Complete */ 14192177bab5SJohan Hedberg events[5] |= 0x08; /* Synchronous Connection Complete */ 14202177bab5SJohan Hedberg events[5] |= 0x10; /* Synchronous Connection Changed */ 1421c7882cbdSMarcel Holtmann } else { 1422c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 1423c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 1424c7882cbdSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 1425c7882cbdSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 1426c7882cbdSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information Complete */ 1427c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 1428c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 1429c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 1430c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 1431c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 1432c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 14332177bab5SJohan Hedberg } 14342177bab5SJohan Hedberg 14352177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 14362177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 14372177bab5SJohan Hedberg 14382177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 14392177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 14402177bab5SJohan Hedberg 14412177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 14422177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 14432177bab5SJohan Hedberg 14442177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 14452177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 14462177bab5SJohan Hedberg 14472177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 14482177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 14492177bab5SJohan Hedberg 14502177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 14512177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 14522177bab5SJohan Hedberg 14532177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 14542177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 14552177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 14562177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 14572177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 14582177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 14592177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 14602177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 14612177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 14622177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 14632177bab5SJohan Hedberg * Features Notification 14642177bab5SJohan Hedberg */ 14652177bab5SJohan Hedberg } 14662177bab5SJohan Hedberg 14672177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 14682177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 14692177bab5SJohan Hedberg 147042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 14712177bab5SJohan Hedberg } 14722177bab5SJohan Hedberg 147342c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 14742177bab5SJohan Hedberg { 147542c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 147642c6b129SJohan Hedberg 14772177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 147842c6b129SJohan Hedberg bredr_setup(req); 147956f87901SJohan Hedberg else 148056f87901SJohan Hedberg clear_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 14812177bab5SJohan Hedberg 14822177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 148342c6b129SJohan Hedberg le_setup(req); 14842177bab5SJohan Hedberg 148542c6b129SJohan Hedberg hci_setup_event_mask(req); 14862177bab5SJohan Hedberg 14873f8e2d75SJohan Hedberg /* AVM Berlin (31), aka "BlueFRITZ!", doesn't support the read 14883f8e2d75SJohan Hedberg * local supported commands HCI command. 14893f8e2d75SJohan Hedberg */ 14903f8e2d75SJohan Hedberg if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) 149142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 14922177bab5SJohan Hedberg 14932177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 149457af75a8SMarcel Holtmann /* When SSP is available, then the host features page 149557af75a8SMarcel Holtmann * should also be available as well. However some 149657af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 149757af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 149857af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 149957af75a8SMarcel Holtmann */ 150057af75a8SMarcel Holtmann hdev->max_page = 0x01; 150157af75a8SMarcel Holtmann 15022177bab5SJohan Hedberg if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) { 15032177bab5SJohan Hedberg u8 mode = 0x01; 150442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 15052177bab5SJohan Hedberg sizeof(mode), &mode); 15062177bab5SJohan Hedberg } else { 15072177bab5SJohan Hedberg struct hci_cp_write_eir cp; 15082177bab5SJohan Hedberg 15092177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 15102177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 15112177bab5SJohan Hedberg 151242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 15132177bab5SJohan Hedberg } 15142177bab5SJohan Hedberg } 15152177bab5SJohan Hedberg 15162177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 151742c6b129SJohan Hedberg hci_setup_inquiry_mode(req); 15182177bab5SJohan Hedberg 15192177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 152042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 15212177bab5SJohan Hedberg 15222177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 15232177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 15242177bab5SJohan Hedberg 15252177bab5SJohan Hedberg cp.page = 0x01; 152642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 152742c6b129SJohan Hedberg sizeof(cp), &cp); 15282177bab5SJohan Hedberg } 15292177bab5SJohan Hedberg 15302177bab5SJohan Hedberg if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) { 15312177bab5SJohan Hedberg u8 enable = 1; 153242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 15332177bab5SJohan Hedberg &enable); 15342177bab5SJohan Hedberg } 15352177bab5SJohan Hedberg } 15362177bab5SJohan Hedberg 153742c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 15382177bab5SJohan Hedberg { 153942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 15402177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 15412177bab5SJohan Hedberg u16 link_policy = 0; 15422177bab5SJohan Hedberg 15432177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 15442177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 15452177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 15462177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 15472177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 15482177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 15492177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 15502177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 15512177bab5SJohan Hedberg 15522177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 155342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 15542177bab5SJohan Hedberg } 15552177bab5SJohan Hedberg 155642c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 15572177bab5SJohan Hedberg { 155842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 15592177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 15602177bab5SJohan Hedberg 1561c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 1562c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1563c73eee91SJohan Hedberg return; 1564c73eee91SJohan Hedberg 15652177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 15662177bab5SJohan Hedberg 15672177bab5SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) { 15682177bab5SJohan Hedberg cp.le = 0x01; 15692177bab5SJohan Hedberg cp.simul = lmp_le_br_capable(hdev); 15702177bab5SJohan Hedberg } 15712177bab5SJohan Hedberg 15722177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 157342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 15742177bab5SJohan Hedberg &cp); 15752177bab5SJohan Hedberg } 15762177bab5SJohan Hedberg 1577d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 1578d62e6d67SJohan Hedberg { 1579d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 1580d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 1581d62e6d67SJohan Hedberg 1582d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 1583d62e6d67SJohan Hedberg * enable all necessary events for it. 1584d62e6d67SJohan Hedberg */ 158553b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 1586d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 1587d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 1588d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 1589d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 1590d62e6d67SJohan Hedberg } 1591d62e6d67SJohan Hedberg 1592d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 1593d62e6d67SJohan Hedberg * enable all necessary events for it. 1594d62e6d67SJohan Hedberg */ 159553b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 1596d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 1597d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 1598d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 1599d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 1600d62e6d67SJohan Hedberg } 1601d62e6d67SJohan Hedberg 160240c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 1603cd7ca0ecSMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) 160440c59fcbSMarcel Holtmann events[2] |= 0x80; 160540c59fcbSMarcel Holtmann 1606d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 1607d62e6d67SJohan Hedberg } 1608d62e6d67SJohan Hedberg 160942c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 16102177bab5SJohan Hedberg { 161142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 1612d2c5d77fSJohan Hedberg u8 p; 161342c6b129SJohan Hedberg 1614b8f4e068SGustavo Padovan /* Some Broadcom based Bluetooth controllers do not support the 1615b8f4e068SGustavo Padovan * Delete Stored Link Key command. They are clearly indicating its 1616b8f4e068SGustavo Padovan * absence in the bit mask of supported commands. 1617b8f4e068SGustavo Padovan * 1618b8f4e068SGustavo Padovan * Check the supported commands and only if the the command is marked 1619b8f4e068SGustavo Padovan * as supported send it. If not supported assume that the controller 1620b8f4e068SGustavo Padovan * does not have actual support for stored link keys which makes this 1621b8f4e068SGustavo Padovan * command redundant anyway. 1622f9f462faSMarcel Holtmann * 1623f9f462faSMarcel Holtmann * Some controllers indicate that they support handling deleting 1624f9f462faSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 1625f9f462faSMarcel Holtmann * just disable this command. 1626b8f4e068SGustavo Padovan */ 1627f9f462faSMarcel Holtmann if (hdev->commands[6] & 0x80 && 1628f9f462faSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 162959f45d57SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 163059f45d57SJohan Hedberg 163159f45d57SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 163259f45d57SJohan Hedberg cp.delete_all = 0x01; 163359f45d57SJohan Hedberg hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 163459f45d57SJohan Hedberg sizeof(cp), &cp); 163559f45d57SJohan Hedberg } 163659f45d57SJohan Hedberg 16372177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 163842c6b129SJohan Hedberg hci_setup_link_policy(req); 16392177bab5SJohan Hedberg 16409193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 16419193c6e8SAndre Guedes u8 events[8]; 16429193c6e8SAndre Guedes 16439193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 16449193c6e8SAndre Guedes events[0] = 0x1f; 1645662bc2e6SAndre Guedes 1646662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 1647662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 1648662bc2e6SAndre Guedes */ 1649662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 1650662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 1651662bc2e6SAndre Guedes * Parameter Request 1652662bc2e6SAndre Guedes */ 1653662bc2e6SAndre Guedes 16549193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 16559193c6e8SAndre Guedes events); 16569193c6e8SAndre Guedes 165715a49ccaSMarcel Holtmann if (hdev->commands[25] & 0x40) { 165815a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 165915a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 166015a49ccaSMarcel Holtmann } 166115a49ccaSMarcel Holtmann 166242c6b129SJohan Hedberg hci_set_le_support(req); 16639193c6e8SAndre Guedes } 1664d2c5d77fSJohan Hedberg 1665d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 1666d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 1667d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 1668d2c5d77fSJohan Hedberg 1669d2c5d77fSJohan Hedberg cp.page = p; 1670d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 1671d2c5d77fSJohan Hedberg sizeof(cp), &cp); 1672d2c5d77fSJohan Hedberg } 16732177bab5SJohan Hedberg } 16742177bab5SJohan Hedberg 16755d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 16765d4e7e8dSJohan Hedberg { 16775d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 16785d4e7e8dSJohan Hedberg 1679d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 1680d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 1681d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 1682d62e6d67SJohan Hedberg 16835d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 168453b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 16855d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 1686a6d0d690SMarcel Holtmann 1687a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 16885afeac14SMarcel Holtmann if ((lmp_sc_capable(hdev) || 1689111902f7SMarcel Holtmann test_bit(HCI_FORCE_SC, &hdev->dbg_flags)) && 1690a6d0d690SMarcel Holtmann test_bit(HCI_SC_ENABLED, &hdev->dev_flags)) { 1691a6d0d690SMarcel Holtmann u8 support = 0x01; 1692a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 1693a6d0d690SMarcel Holtmann sizeof(support), &support); 1694a6d0d690SMarcel Holtmann } 16955d4e7e8dSJohan Hedberg } 16965d4e7e8dSJohan Hedberg 16972177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 16982177bab5SJohan Hedberg { 16992177bab5SJohan Hedberg int err; 17002177bab5SJohan Hedberg 17012177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 17022177bab5SJohan Hedberg if (err < 0) 17032177bab5SJohan Hedberg return err; 17042177bab5SJohan Hedberg 17054b4148e9SMarcel Holtmann /* The Device Under Test (DUT) mode is special and available for 17064b4148e9SMarcel Holtmann * all controller types. So just create it early on. 17074b4148e9SMarcel Holtmann */ 17084b4148e9SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 17094b4148e9SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 17104b4148e9SMarcel Holtmann &dut_mode_fops); 17114b4148e9SMarcel Holtmann } 17124b4148e9SMarcel Holtmann 17132177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 17142177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 17152177bab5SJohan Hedberg * first stage init. 17162177bab5SJohan Hedberg */ 17172177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 17182177bab5SJohan Hedberg return 0; 17192177bab5SJohan Hedberg 17202177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 17212177bab5SJohan Hedberg if (err < 0) 17222177bab5SJohan Hedberg return err; 17232177bab5SJohan Hedberg 17245d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 17255d4e7e8dSJohan Hedberg if (err < 0) 17265d4e7e8dSJohan Hedberg return err; 17275d4e7e8dSJohan Hedberg 1728baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 1729baf27f6eSMarcel Holtmann if (err < 0) 1730baf27f6eSMarcel Holtmann return err; 1731baf27f6eSMarcel Holtmann 1732baf27f6eSMarcel Holtmann /* Only create debugfs entries during the initial setup 1733baf27f6eSMarcel Holtmann * phase and not every time the controller gets powered on. 1734baf27f6eSMarcel Holtmann */ 1735baf27f6eSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 1736baf27f6eSMarcel Holtmann return 0; 1737baf27f6eSMarcel Holtmann 1738dfb826a8SMarcel Holtmann debugfs_create_file("features", 0444, hdev->debugfs, hdev, 1739dfb826a8SMarcel Holtmann &features_fops); 1740ceeb3bc0SMarcel Holtmann debugfs_create_u16("manufacturer", 0444, hdev->debugfs, 1741ceeb3bc0SMarcel Holtmann &hdev->manufacturer); 1742ceeb3bc0SMarcel Holtmann debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver); 1743ceeb3bc0SMarcel Holtmann debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev); 174470afe0b8SMarcel Holtmann debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev, 174570afe0b8SMarcel Holtmann &blacklist_fops); 17466659358eSJohan Hedberg debugfs_create_file("whitelist", 0444, hdev->debugfs, hdev, 17476659358eSJohan Hedberg &whitelist_fops); 174847219839SMarcel Holtmann debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 174947219839SMarcel Holtmann 175031ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev, 175131ad1691SAndrzej Kaczmarek &conn_info_min_age_fops); 175231ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev, 175331ad1691SAndrzej Kaczmarek &conn_info_max_age_fops); 175431ad1691SAndrzej Kaczmarek 1755baf27f6eSMarcel Holtmann if (lmp_bredr_capable(hdev)) { 1756baf27f6eSMarcel Holtmann debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, 1757baf27f6eSMarcel Holtmann hdev, &inquiry_cache_fops); 175802d08d15SMarcel Holtmann debugfs_create_file("link_keys", 0400, hdev->debugfs, 175902d08d15SMarcel Holtmann hdev, &link_keys_fops); 1760babdbb3cSMarcel Holtmann debugfs_create_file("dev_class", 0444, hdev->debugfs, 1761babdbb3cSMarcel Holtmann hdev, &dev_class_fops); 1762041000b9SMarcel Holtmann debugfs_create_file("voice_setting", 0444, hdev->debugfs, 1763041000b9SMarcel Holtmann hdev, &voice_setting_fops); 1764baf27f6eSMarcel Holtmann } 1765baf27f6eSMarcel Holtmann 176606f5b778SMarcel Holtmann if (lmp_ssp_capable(hdev)) { 1767ebd1e33bSMarcel Holtmann debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 1768ebd1e33bSMarcel Holtmann hdev, &auto_accept_delay_fops); 17695afeac14SMarcel Holtmann debugfs_create_file("force_sc_support", 0644, hdev->debugfs, 17705afeac14SMarcel Holtmann hdev, &force_sc_support_fops); 1771134c2a89SMarcel Holtmann debugfs_create_file("sc_only_mode", 0444, hdev->debugfs, 1772134c2a89SMarcel Holtmann hdev, &sc_only_mode_fops); 177306f5b778SMarcel Holtmann } 1774ebd1e33bSMarcel Holtmann 17752bfa3531SMarcel Holtmann if (lmp_sniff_capable(hdev)) { 17762bfa3531SMarcel Holtmann debugfs_create_file("idle_timeout", 0644, hdev->debugfs, 17772bfa3531SMarcel Holtmann hdev, &idle_timeout_fops); 17782bfa3531SMarcel Holtmann debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs, 17792bfa3531SMarcel Holtmann hdev, &sniff_min_interval_fops); 17802bfa3531SMarcel Holtmann debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs, 17812bfa3531SMarcel Holtmann hdev, &sniff_max_interval_fops); 17822bfa3531SMarcel Holtmann } 17832bfa3531SMarcel Holtmann 1784d0f729b8SMarcel Holtmann if (lmp_le_capable(hdev)) { 1785ac345813SMarcel Holtmann debugfs_create_file("identity", 0400, hdev->debugfs, 1786ac345813SMarcel Holtmann hdev, &identity_fops); 1787ac345813SMarcel Holtmann debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, 1788ac345813SMarcel Holtmann hdev, &rpa_timeout_fops); 17897a4cd51dSMarcel Holtmann debugfs_create_file("random_address", 0444, hdev->debugfs, 17907a4cd51dSMarcel Holtmann hdev, &random_address_fops); 1791e7b8fc92SMarcel Holtmann debugfs_create_file("static_address", 0444, hdev->debugfs, 1792e7b8fc92SMarcel Holtmann hdev, &static_address_fops); 1793b32bba6cSMarcel Holtmann 1794b32bba6cSMarcel Holtmann /* For controllers with a public address, provide a debug 1795b32bba6cSMarcel Holtmann * option to force the usage of the configured static 1796b32bba6cSMarcel Holtmann * address. By default the public address is used. 1797b32bba6cSMarcel Holtmann */ 1798b32bba6cSMarcel Holtmann if (bacmp(&hdev->bdaddr, BDADDR_ANY)) 1799b32bba6cSMarcel Holtmann debugfs_create_file("force_static_address", 0644, 1800b32bba6cSMarcel Holtmann hdev->debugfs, hdev, 1801b32bba6cSMarcel Holtmann &force_static_address_fops); 1802b32bba6cSMarcel Holtmann 1803b32bba6cSMarcel Holtmann debugfs_create_u8("white_list_size", 0444, hdev->debugfs, 1804b32bba6cSMarcel Holtmann &hdev->le_white_list_size); 1805d2ab0ac1SMarcel Holtmann debugfs_create_file("white_list", 0444, hdev->debugfs, hdev, 1806d2ab0ac1SMarcel Holtmann &white_list_fops); 18073698d704SMarcel Holtmann debugfs_create_file("identity_resolving_keys", 0400, 18083698d704SMarcel Holtmann hdev->debugfs, hdev, 18093698d704SMarcel Holtmann &identity_resolving_keys_fops); 18108f8625cdSMarcel Holtmann debugfs_create_file("long_term_keys", 0400, hdev->debugfs, 18118f8625cdSMarcel Holtmann hdev, &long_term_keys_fops); 18124e70c7e7SMarcel Holtmann debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, 18134e70c7e7SMarcel Holtmann hdev, &conn_min_interval_fops); 18144e70c7e7SMarcel Holtmann debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, 18154e70c7e7SMarcel Holtmann hdev, &conn_max_interval_fops); 1816816a93d1SMarcel Holtmann debugfs_create_file("conn_latency", 0644, hdev->debugfs, 1817816a93d1SMarcel Holtmann hdev, &conn_latency_fops); 1818f1649577SMarcel Holtmann debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, 1819f1649577SMarcel Holtmann hdev, &supervision_timeout_fops); 18203f959d46SMarcel Holtmann debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, 18213f959d46SMarcel Holtmann hdev, &adv_channel_map_fops); 18220b3c7d37SMarcel Holtmann debugfs_create_file("device_list", 0444, hdev->debugfs, hdev, 18230b3c7d37SMarcel Holtmann &device_list_fops); 1824b9a7a61eSLukasz Rymanowski debugfs_create_u16("discov_interleaved_timeout", 0644, 1825b9a7a61eSLukasz Rymanowski hdev->debugfs, 1826b9a7a61eSLukasz Rymanowski &hdev->discov_interleaved_timeout); 1827d0f729b8SMarcel Holtmann } 1828e7b8fc92SMarcel Holtmann 1829baf27f6eSMarcel Holtmann return 0; 18302177bab5SJohan Hedberg } 18312177bab5SJohan Hedberg 18320ebca7d6SMarcel Holtmann static void hci_init0_req(struct hci_request *req, unsigned long opt) 18330ebca7d6SMarcel Holtmann { 18340ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 18350ebca7d6SMarcel Holtmann 18360ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 18370ebca7d6SMarcel Holtmann 18380ebca7d6SMarcel Holtmann /* Reset */ 18390ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 18400ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 18410ebca7d6SMarcel Holtmann 18420ebca7d6SMarcel Holtmann /* Read Local Version */ 18430ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 18440ebca7d6SMarcel Holtmann 18450ebca7d6SMarcel Holtmann /* Read BD Address */ 18460ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 18470ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 18480ebca7d6SMarcel Holtmann } 18490ebca7d6SMarcel Holtmann 18500ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 18510ebca7d6SMarcel Holtmann { 18520ebca7d6SMarcel Holtmann int err; 18530ebca7d6SMarcel Holtmann 1854cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 1855cc78b44bSMarcel Holtmann return 0; 1856cc78b44bSMarcel Holtmann 18570ebca7d6SMarcel Holtmann err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT); 18580ebca7d6SMarcel Holtmann if (err < 0) 18590ebca7d6SMarcel Holtmann return err; 18600ebca7d6SMarcel Holtmann 18610ebca7d6SMarcel Holtmann return 0; 18620ebca7d6SMarcel Holtmann } 18630ebca7d6SMarcel Holtmann 186442c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 18651da177e4SLinus Torvalds { 18661da177e4SLinus Torvalds __u8 scan = opt; 18671da177e4SLinus Torvalds 186842c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 18691da177e4SLinus Torvalds 18701da177e4SLinus Torvalds /* Inquiry and Page scans */ 187142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 18721da177e4SLinus Torvalds } 18731da177e4SLinus Torvalds 187442c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 18751da177e4SLinus Torvalds { 18761da177e4SLinus Torvalds __u8 auth = opt; 18771da177e4SLinus Torvalds 187842c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 18791da177e4SLinus Torvalds 18801da177e4SLinus Torvalds /* Authentication */ 188142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 18821da177e4SLinus Torvalds } 18831da177e4SLinus Torvalds 188442c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 18851da177e4SLinus Torvalds { 18861da177e4SLinus Torvalds __u8 encrypt = opt; 18871da177e4SLinus Torvalds 188842c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 18891da177e4SLinus Torvalds 1890e4e8e37cSMarcel Holtmann /* Encryption */ 189142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 18921da177e4SLinus Torvalds } 18931da177e4SLinus Torvalds 189442c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1895e4e8e37cSMarcel Holtmann { 1896e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1897e4e8e37cSMarcel Holtmann 189842c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1899e4e8e37cSMarcel Holtmann 1900e4e8e37cSMarcel Holtmann /* Default link policy */ 190142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1902e4e8e37cSMarcel Holtmann } 1903e4e8e37cSMarcel Holtmann 19041da177e4SLinus Torvalds /* Get HCI device by index. 19051da177e4SLinus Torvalds * Device is held on return. */ 19061da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 19071da177e4SLinus Torvalds { 19088035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 19091da177e4SLinus Torvalds 19101da177e4SLinus Torvalds BT_DBG("%d", index); 19111da177e4SLinus Torvalds 19121da177e4SLinus Torvalds if (index < 0) 19131da177e4SLinus Torvalds return NULL; 19141da177e4SLinus Torvalds 19151da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 19168035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 19171da177e4SLinus Torvalds if (d->id == index) { 19181da177e4SLinus Torvalds hdev = hci_dev_hold(d); 19191da177e4SLinus Torvalds break; 19201da177e4SLinus Torvalds } 19211da177e4SLinus Torvalds } 19221da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 19231da177e4SLinus Torvalds return hdev; 19241da177e4SLinus Torvalds } 19251da177e4SLinus Torvalds 19261da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1927ff9ef578SJohan Hedberg 192830dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 192930dc78e1SJohan Hedberg { 193030dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 193130dc78e1SJohan Hedberg 19326fbe195dSAndre Guedes switch (discov->state) { 1933343f935bSAndre Guedes case DISCOVERY_FINDING: 19346fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 193530dc78e1SJohan Hedberg return true; 193630dc78e1SJohan Hedberg 19376fbe195dSAndre Guedes default: 193830dc78e1SJohan Hedberg return false; 193930dc78e1SJohan Hedberg } 19406fbe195dSAndre Guedes } 194130dc78e1SJohan Hedberg 1942ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1943ff9ef578SJohan Hedberg { 1944bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 1945bb3e0a33SJohan Hedberg 1946ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1947ff9ef578SJohan Hedberg 1948bb3e0a33SJohan Hedberg if (old_state == state) 1949ff9ef578SJohan Hedberg return; 1950ff9ef578SJohan Hedberg 1951bb3e0a33SJohan Hedberg hdev->discovery.state = state; 1952bb3e0a33SJohan Hedberg 1953ff9ef578SJohan Hedberg switch (state) { 1954ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1955c54c3860SAndre Guedes hci_update_background_scan(hdev); 1956c54c3860SAndre Guedes 1957bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1958ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1959ff9ef578SJohan Hedberg break; 1960ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1961ff9ef578SJohan Hedberg break; 1962343f935bSAndre Guedes case DISCOVERY_FINDING: 1963ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1964ff9ef578SJohan Hedberg break; 196530dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 196630dc78e1SJohan Hedberg break; 1967ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1968ff9ef578SJohan Hedberg break; 1969ff9ef578SJohan Hedberg } 1970ff9ef578SJohan Hedberg } 1971ff9ef578SJohan Hedberg 19721f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 19731da177e4SLinus Torvalds { 197430883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1975b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 19761da177e4SLinus Torvalds 1977561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1978561aafbcSJohan Hedberg list_del(&p->all); 1979b57c1a56SJohan Hedberg kfree(p); 19801da177e4SLinus Torvalds } 1981561aafbcSJohan Hedberg 1982561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1983561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 19841da177e4SLinus Torvalds } 19851da177e4SLinus Torvalds 1986a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1987a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 19881da177e4SLinus Torvalds { 198930883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 19901da177e4SLinus Torvalds struct inquiry_entry *e; 19911da177e4SLinus Torvalds 19926ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 19931da177e4SLinus Torvalds 1994561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 19951da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 19961da177e4SLinus Torvalds return e; 19971da177e4SLinus Torvalds } 19981da177e4SLinus Torvalds 1999b57c1a56SJohan Hedberg return NULL; 2000b57c1a56SJohan Hedberg } 2001b57c1a56SJohan Hedberg 2002561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 2003561aafbcSJohan Hedberg bdaddr_t *bdaddr) 2004561aafbcSJohan Hedberg { 200530883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2006561aafbcSJohan Hedberg struct inquiry_entry *e; 2007561aafbcSJohan Hedberg 20086ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 2009561aafbcSJohan Hedberg 2010561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 2011561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 2012561aafbcSJohan Hedberg return e; 2013561aafbcSJohan Hedberg } 2014561aafbcSJohan Hedberg 2015561aafbcSJohan Hedberg return NULL; 2016561aafbcSJohan Hedberg } 2017561aafbcSJohan Hedberg 201830dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 201930dc78e1SJohan Hedberg bdaddr_t *bdaddr, 202030dc78e1SJohan Hedberg int state) 202130dc78e1SJohan Hedberg { 202230dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 202330dc78e1SJohan Hedberg struct inquiry_entry *e; 202430dc78e1SJohan Hedberg 20256ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 202630dc78e1SJohan Hedberg 202730dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 202830dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 202930dc78e1SJohan Hedberg return e; 203030dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 203130dc78e1SJohan Hedberg return e; 203230dc78e1SJohan Hedberg } 203330dc78e1SJohan Hedberg 203430dc78e1SJohan Hedberg return NULL; 203530dc78e1SJohan Hedberg } 203630dc78e1SJohan Hedberg 2037a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 2038a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 2039a3d4e20aSJohan Hedberg { 2040a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2041a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 2042a3d4e20aSJohan Hedberg struct inquiry_entry *p; 2043a3d4e20aSJohan Hedberg 2044a3d4e20aSJohan Hedberg list_del(&ie->list); 2045a3d4e20aSJohan Hedberg 2046a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 2047a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 2048a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 2049a3d4e20aSJohan Hedberg break; 2050a3d4e20aSJohan Hedberg pos = &p->list; 2051a3d4e20aSJohan Hedberg } 2052a3d4e20aSJohan Hedberg 2053a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 2054a3d4e20aSJohan Hedberg } 2055a3d4e20aSJohan Hedberg 2056af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 2057af58925cSMarcel Holtmann bool name_known) 20581da177e4SLinus Torvalds { 205930883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 206070f23020SAndrei Emeltchenko struct inquiry_entry *ie; 2061af58925cSMarcel Holtmann u32 flags = 0; 20621da177e4SLinus Torvalds 20636ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 20641da177e4SLinus Torvalds 20652b2fec4dSSzymon Janc hci_remove_remote_oob_data(hdev, &data->bdaddr); 20662b2fec4dSSzymon Janc 2067af58925cSMarcel Holtmann if (!data->ssp_mode) 2068af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 2069388fc8faSJohan Hedberg 207070f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 2071a3d4e20aSJohan Hedberg if (ie) { 2072af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 2073af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 2074388fc8faSJohan Hedberg 2075a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 2076a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 2077a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 2078a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 2079a3d4e20aSJohan Hedberg } 2080a3d4e20aSJohan Hedberg 2081561aafbcSJohan Hedberg goto update; 2082a3d4e20aSJohan Hedberg } 2083561aafbcSJohan Hedberg 20841da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 208570f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 2086af58925cSMarcel Holtmann if (!ie) { 2087af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 2088af58925cSMarcel Holtmann goto done; 2089af58925cSMarcel Holtmann } 209070f23020SAndrei Emeltchenko 2091561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 2092561aafbcSJohan Hedberg 2093561aafbcSJohan Hedberg if (name_known) { 2094561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2095561aafbcSJohan Hedberg } else { 2096561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 2097561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 2098561aafbcSJohan Hedberg } 2099561aafbcSJohan Hedberg 2100561aafbcSJohan Hedberg update: 2101561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 2102561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 2103561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2104561aafbcSJohan Hedberg list_del(&ie->list); 21051da177e4SLinus Torvalds } 21061da177e4SLinus Torvalds 210770f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 210870f23020SAndrei Emeltchenko ie->timestamp = jiffies; 21091da177e4SLinus Torvalds cache->timestamp = jiffies; 21103175405bSJohan Hedberg 21113175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 2112af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 21133175405bSJohan Hedberg 2114af58925cSMarcel Holtmann done: 2115af58925cSMarcel Holtmann return flags; 21161da177e4SLinus Torvalds } 21171da177e4SLinus Torvalds 21181da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 21191da177e4SLinus Torvalds { 212030883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 21211da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 21221da177e4SLinus Torvalds struct inquiry_entry *e; 21231da177e4SLinus Torvalds int copied = 0; 21241da177e4SLinus Torvalds 2125561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 21261da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 2127b57c1a56SJohan Hedberg 2128b57c1a56SJohan Hedberg if (copied >= num) 2129b57c1a56SJohan Hedberg break; 2130b57c1a56SJohan Hedberg 21311da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 21321da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 21331da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 21341da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 21351da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 21361da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 2137b57c1a56SJohan Hedberg 21381da177e4SLinus Torvalds info++; 2139b57c1a56SJohan Hedberg copied++; 21401da177e4SLinus Torvalds } 21411da177e4SLinus Torvalds 21421da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 21431da177e4SLinus Torvalds return copied; 21441da177e4SLinus Torvalds } 21451da177e4SLinus Torvalds 214642c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 21471da177e4SLinus Torvalds { 21481da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 214942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 21501da177e4SLinus Torvalds struct hci_cp_inquiry cp; 21511da177e4SLinus Torvalds 21521da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 21531da177e4SLinus Torvalds 21541da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 21551da177e4SLinus Torvalds return; 21561da177e4SLinus Torvalds 21571da177e4SLinus Torvalds /* Start Inquiry */ 21581da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 21591da177e4SLinus Torvalds cp.length = ir->length; 21601da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 216142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 21621da177e4SLinus Torvalds } 21631da177e4SLinus Torvalds 21643e13fa1eSAndre Guedes static int wait_inquiry(void *word) 21653e13fa1eSAndre Guedes { 21663e13fa1eSAndre Guedes schedule(); 21673e13fa1eSAndre Guedes return signal_pending(current); 21683e13fa1eSAndre Guedes } 21693e13fa1eSAndre Guedes 21701da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 21711da177e4SLinus Torvalds { 21721da177e4SLinus Torvalds __u8 __user *ptr = arg; 21731da177e4SLinus Torvalds struct hci_inquiry_req ir; 21741da177e4SLinus Torvalds struct hci_dev *hdev; 21751da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 21761da177e4SLinus Torvalds long timeo; 21771da177e4SLinus Torvalds __u8 *buf; 21781da177e4SLinus Torvalds 21791da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 21801da177e4SLinus Torvalds return -EFAULT; 21811da177e4SLinus Torvalds 21825a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 21835a08ecceSAndrei Emeltchenko if (!hdev) 21841da177e4SLinus Torvalds return -ENODEV; 21851da177e4SLinus Torvalds 21860736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 21870736cfa8SMarcel Holtmann err = -EBUSY; 21880736cfa8SMarcel Holtmann goto done; 21890736cfa8SMarcel Holtmann } 21900736cfa8SMarcel Holtmann 21914a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2192fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2193fee746b0SMarcel Holtmann goto done; 2194fee746b0SMarcel Holtmann } 2195fee746b0SMarcel Holtmann 21965b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 21975b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 21985b69bef5SMarcel Holtmann goto done; 21995b69bef5SMarcel Holtmann } 22005b69bef5SMarcel Holtmann 220156f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 220256f87901SJohan Hedberg err = -EOPNOTSUPP; 220356f87901SJohan Hedberg goto done; 220456f87901SJohan Hedberg } 220556f87901SJohan Hedberg 220609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 22071da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 2208a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 22091f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 22101da177e4SLinus Torvalds do_inquiry = 1; 22111da177e4SLinus Torvalds } 221209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 22131da177e4SLinus Torvalds 221404837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 221570f23020SAndrei Emeltchenko 221670f23020SAndrei Emeltchenko if (do_inquiry) { 221701178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 221801178cd4SJohan Hedberg timeo); 221970f23020SAndrei Emeltchenko if (err < 0) 22201da177e4SLinus Torvalds goto done; 22213e13fa1eSAndre Guedes 22223e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 22233e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 22243e13fa1eSAndre Guedes */ 22253e13fa1eSAndre Guedes if (wait_on_bit(&hdev->flags, HCI_INQUIRY, wait_inquiry, 22263e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 22273e13fa1eSAndre Guedes return -EINTR; 222870f23020SAndrei Emeltchenko } 22291da177e4SLinus Torvalds 22308fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 22318fc9ced3SGustavo Padovan * 255 entries 22328fc9ced3SGustavo Padovan */ 22331da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 22341da177e4SLinus Torvalds 22351da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 22361da177e4SLinus Torvalds * copy it to the user space. 22371da177e4SLinus Torvalds */ 223870f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 223970f23020SAndrei Emeltchenko if (!buf) { 22401da177e4SLinus Torvalds err = -ENOMEM; 22411da177e4SLinus Torvalds goto done; 22421da177e4SLinus Torvalds } 22431da177e4SLinus Torvalds 224409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 22451da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 224609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 22471da177e4SLinus Torvalds 22481da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 22491da177e4SLinus Torvalds 22501da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 22511da177e4SLinus Torvalds ptr += sizeof(ir); 22521da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 22531da177e4SLinus Torvalds ir.num_rsp)) 22541da177e4SLinus Torvalds err = -EFAULT; 22551da177e4SLinus Torvalds } else 22561da177e4SLinus Torvalds err = -EFAULT; 22571da177e4SLinus Torvalds 22581da177e4SLinus Torvalds kfree(buf); 22591da177e4SLinus Torvalds 22601da177e4SLinus Torvalds done: 22611da177e4SLinus Torvalds hci_dev_put(hdev); 22621da177e4SLinus Torvalds return err; 22631da177e4SLinus Torvalds } 22641da177e4SLinus Torvalds 2265cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 22661da177e4SLinus Torvalds { 22671da177e4SLinus Torvalds int ret = 0; 22681da177e4SLinus Torvalds 22691da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 22701da177e4SLinus Torvalds 22711da177e4SLinus Torvalds hci_req_lock(hdev); 22721da177e4SLinus Torvalds 227394324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 227494324962SJohan Hovold ret = -ENODEV; 227594324962SJohan Hovold goto done; 227694324962SJohan Hovold } 227794324962SJohan Hovold 2278d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2279d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 2280a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 2281a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 2282bf543036SJohan Hedberg */ 2283a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 2284611b30f7SMarcel Holtmann ret = -ERFKILL; 2285611b30f7SMarcel Holtmann goto done; 2286611b30f7SMarcel Holtmann } 2287611b30f7SMarcel Holtmann 2288a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 2289a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 2290a5c8f270SMarcel Holtmann * be able to determine if there is a public address 2291a5c8f270SMarcel Holtmann * or not. 2292a5c8f270SMarcel Holtmann * 2293c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 2294c6beca0eSMarcel Holtmann * if a public address or static random address is 2295c6beca0eSMarcel Holtmann * available. 2296c6beca0eSMarcel Holtmann * 2297a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 2298a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 2299a5c8f270SMarcel Holtmann */ 2300c6beca0eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 2301c6beca0eSMarcel Holtmann hdev->dev_type == HCI_BREDR && 2302a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2303a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 2304a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 2305a5c8f270SMarcel Holtmann goto done; 2306a5c8f270SMarcel Holtmann } 2307a5c8f270SMarcel Holtmann } 2308a5c8f270SMarcel Holtmann 23091da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 23101da177e4SLinus Torvalds ret = -EALREADY; 23111da177e4SLinus Torvalds goto done; 23121da177e4SLinus Torvalds } 23131da177e4SLinus Torvalds 23141da177e4SLinus Torvalds if (hdev->open(hdev)) { 23151da177e4SLinus Torvalds ret = -EIO; 23161da177e4SLinus Torvalds goto done; 23171da177e4SLinus Torvalds } 23181da177e4SLinus Torvalds 23191da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 23201da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 2321f41c70c4SMarcel Holtmann 2322af202f84SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 2323af202f84SMarcel Holtmann if (hdev->setup) 2324f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 2325f41c70c4SMarcel Holtmann 2326af202f84SMarcel Holtmann /* The transport driver can set these quirks before 2327af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 2328af202f84SMarcel Holtmann * 2329af202f84SMarcel Holtmann * In case any of them is set, the controller has to 2330af202f84SMarcel Holtmann * start up as unconfigured. 2331af202f84SMarcel Holtmann */ 2332eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 2333eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 233489bc22d2SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 23350ebca7d6SMarcel Holtmann 23360ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 23370ebca7d6SMarcel Holtmann * read at least the version information provided by 23380ebca7d6SMarcel Holtmann * the Read Local Version Information command. 23390ebca7d6SMarcel Holtmann * 23400ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 23410ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 23420ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 23430ebca7d6SMarcel Holtmann */ 23440ebca7d6SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 23450ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 234689bc22d2SMarcel Holtmann } 234789bc22d2SMarcel Holtmann 23489713c17bSMarcel Holtmann if (test_bit(HCI_CONFIG, &hdev->dev_flags)) { 23499713c17bSMarcel Holtmann /* If public address change is configured, ensure that 23509713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 23519713c17bSMarcel Holtmann * support changing the public address, fail the power 23529713c17bSMarcel Holtmann * on procedure. 235324c457e2SMarcel Holtmann */ 23549713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 23559713c17bSMarcel Holtmann hdev->set_bdaddr) 235624c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 235724c457e2SMarcel Holtmann else 235824c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 235924c457e2SMarcel Holtmann } 236024c457e2SMarcel Holtmann 2361f41c70c4SMarcel Holtmann if (!ret) { 23624a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 23630736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 23642177bab5SJohan Hedberg ret = __hci_init(hdev); 23651da177e4SLinus Torvalds } 23661da177e4SLinus Torvalds 2367f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 2368f41c70c4SMarcel Holtmann 23691da177e4SLinus Torvalds if (!ret) { 23701da177e4SLinus Torvalds hci_dev_hold(hdev); 2371d6bfd59cSJohan Hedberg set_bit(HCI_RPA_EXPIRED, &hdev->dev_flags); 23721da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 23731da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 2374bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2375d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags) && 23764a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 23770736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 23781514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 237909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2380744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 238109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 238256e5cb86SJohan Hedberg } 23831da177e4SLinus Torvalds } else { 23841da177e4SLinus Torvalds /* Init failed, cleanup */ 23853eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2386c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 2387b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 23881da177e4SLinus Torvalds 23891da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 23901da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 23911da177e4SLinus Torvalds 23921da177e4SLinus Torvalds if (hdev->flush) 23931da177e4SLinus Torvalds hdev->flush(hdev); 23941da177e4SLinus Torvalds 23951da177e4SLinus Torvalds if (hdev->sent_cmd) { 23961da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 23971da177e4SLinus Torvalds hdev->sent_cmd = NULL; 23981da177e4SLinus Torvalds } 23991da177e4SLinus Torvalds 24001da177e4SLinus Torvalds hdev->close(hdev); 2401fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 24021da177e4SLinus Torvalds } 24031da177e4SLinus Torvalds 24041da177e4SLinus Torvalds done: 24051da177e4SLinus Torvalds hci_req_unlock(hdev); 24061da177e4SLinus Torvalds return ret; 24071da177e4SLinus Torvalds } 24081da177e4SLinus Torvalds 2409cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 2410cbed0ca1SJohan Hedberg 2411cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 2412cbed0ca1SJohan Hedberg { 2413cbed0ca1SJohan Hedberg struct hci_dev *hdev; 2414cbed0ca1SJohan Hedberg int err; 2415cbed0ca1SJohan Hedberg 2416cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 2417cbed0ca1SJohan Hedberg if (!hdev) 2418cbed0ca1SJohan Hedberg return -ENODEV; 2419cbed0ca1SJohan Hedberg 24204a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 2421fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 2422fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 2423fee746b0SMarcel Holtmann * possible. 2424fee746b0SMarcel Holtmann * 2425fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 2426fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 2427fee746b0SMarcel Holtmann * open the device. 2428fee746b0SMarcel Holtmann */ 24294a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 2430fee746b0SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 2431fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2432fee746b0SMarcel Holtmann goto done; 2433fee746b0SMarcel Holtmann } 2434fee746b0SMarcel Holtmann 2435e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 2436e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 2437e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 2438e1d08f40SJohan Hedberg * completed. 2439e1d08f40SJohan Hedberg */ 2440e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 2441e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 2442e1d08f40SJohan Hedberg 2443a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 2444a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 2445a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 2446a5c8f270SMarcel Holtmann */ 2447e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 2448e1d08f40SJohan Hedberg 244912aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 245012aa4f0aSMarcel Holtmann * are brought up using legacy ioctl, set the HCI_PAIRABLE bit 245112aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 245212aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 245312aa4f0aSMarcel Holtmann * to explicitly enable it. 245412aa4f0aSMarcel Holtmann */ 245512aa4f0aSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 245612aa4f0aSMarcel Holtmann !test_bit(HCI_MGMT, &hdev->dev_flags)) 245712aa4f0aSMarcel Holtmann set_bit(HCI_PAIRABLE, &hdev->dev_flags); 245812aa4f0aSMarcel Holtmann 2459cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 2460cbed0ca1SJohan Hedberg 2461fee746b0SMarcel Holtmann done: 2462cbed0ca1SJohan Hedberg hci_dev_put(hdev); 2463cbed0ca1SJohan Hedberg return err; 2464cbed0ca1SJohan Hedberg } 2465cbed0ca1SJohan Hedberg 2466d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 2467d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 2468d7347f3cSJohan Hedberg { 2469d7347f3cSJohan Hedberg struct hci_conn_params *p; 2470d7347f3cSJohan Hedberg 2471d7347f3cSJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) 2472d7347f3cSJohan Hedberg list_del_init(&p->action); 2473d7347f3cSJohan Hedberg 2474d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 2475d7347f3cSJohan Hedberg } 2476d7347f3cSJohan Hedberg 24771da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 24781da177e4SLinus Torvalds { 24791da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 24801da177e4SLinus Torvalds 248178c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 248278c04c0bSVinicius Costa Gomes 24831da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 24841da177e4SLinus Torvalds hci_req_lock(hdev); 24851da177e4SLinus Torvalds 24861da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 248765cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 24881da177e4SLinus Torvalds hci_req_unlock(hdev); 24891da177e4SLinus Torvalds return 0; 24901da177e4SLinus Torvalds } 24911da177e4SLinus Torvalds 24923eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 24933eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2494b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 24951da177e4SLinus Torvalds 249616ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 2497e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 249816ab91abSJohan Hedberg hdev->discov_timeout = 0; 24995e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 2500310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 250116ab91abSJohan Hedberg } 250216ab91abSJohan Hedberg 2503a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 25047d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 25057d78525dSJohan Hedberg 25067ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 25074518bb0fSJohan Hedberg 25084518bb0fSJohan Hedberg if (test_bit(HCI_MGMT, &hdev->dev_flags)) 2509d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 25107ba8b4beSAndre Guedes 251109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 25121f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 25131da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 2514d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 251509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 25161da177e4SLinus Torvalds 25171da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 25181da177e4SLinus Torvalds 25191da177e4SLinus Torvalds if (hdev->flush) 25201da177e4SLinus Torvalds hdev->flush(hdev); 25211da177e4SLinus Torvalds 25221da177e4SLinus Torvalds /* Reset device */ 25231da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 25241da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 25254a964404SMarcel Holtmann if (!test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 25264a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 2527a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 25281da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 252901178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 25301da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 25311da177e4SLinus Torvalds } 25321da177e4SLinus Torvalds 2533c347b765SGustavo F. Padovan /* flush cmd work */ 2534c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 25351da177e4SLinus Torvalds 25361da177e4SLinus Torvalds /* Drop queues */ 25371da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 25381da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 25391da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 25401da177e4SLinus Torvalds 25411da177e4SLinus Torvalds /* Drop last sent command */ 25421da177e4SLinus Torvalds if (hdev->sent_cmd) { 254365cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 25441da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 25451da177e4SLinus Torvalds hdev->sent_cmd = NULL; 25461da177e4SLinus Torvalds } 25471da177e4SLinus Torvalds 2548b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 2549b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 2550b6ddb638SJohan Hedberg 25511da177e4SLinus Torvalds /* After this point our queues are empty 25521da177e4SLinus Torvalds * and no tasks are scheduled. */ 25531da177e4SLinus Torvalds hdev->close(hdev); 25541da177e4SLinus Torvalds 255535b973c9SJohan Hedberg /* Clear flags */ 2556fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 255735b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 255835b973c9SJohan Hedberg 255993c311a0SMarcel Holtmann if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 256093c311a0SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 256109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2562744cf19eSJohan Hedberg mgmt_powered(hdev, 0); 256309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 25648ee56540SMarcel Holtmann } 256593c311a0SMarcel Holtmann } 25665add6af8SJohan Hedberg 2567ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 2568536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 2569ced5c338SAndrei Emeltchenko 2570e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 257109b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 25727a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 2573e59fda8dSJohan Hedberg 25741da177e4SLinus Torvalds hci_req_unlock(hdev); 25751da177e4SLinus Torvalds 25761da177e4SLinus Torvalds hci_dev_put(hdev); 25771da177e4SLinus Torvalds return 0; 25781da177e4SLinus Torvalds } 25791da177e4SLinus Torvalds 25801da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 25811da177e4SLinus Torvalds { 25821da177e4SLinus Torvalds struct hci_dev *hdev; 25831da177e4SLinus Torvalds int err; 25841da177e4SLinus Torvalds 258570f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 258670f23020SAndrei Emeltchenko if (!hdev) 25871da177e4SLinus Torvalds return -ENODEV; 25888ee56540SMarcel Holtmann 25890736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 25900736cfa8SMarcel Holtmann err = -EBUSY; 25910736cfa8SMarcel Holtmann goto done; 25920736cfa8SMarcel Holtmann } 25930736cfa8SMarcel Holtmann 25948ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 25958ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 25968ee56540SMarcel Holtmann 25971da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 25988ee56540SMarcel Holtmann 25990736cfa8SMarcel Holtmann done: 26001da177e4SLinus Torvalds hci_dev_put(hdev); 26011da177e4SLinus Torvalds return err; 26021da177e4SLinus Torvalds } 26031da177e4SLinus Torvalds 26041da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 26051da177e4SLinus Torvalds { 26061da177e4SLinus Torvalds struct hci_dev *hdev; 26071da177e4SLinus Torvalds int ret = 0; 26081da177e4SLinus Torvalds 260970f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 261070f23020SAndrei Emeltchenko if (!hdev) 26111da177e4SLinus Torvalds return -ENODEV; 26121da177e4SLinus Torvalds 26131da177e4SLinus Torvalds hci_req_lock(hdev); 26141da177e4SLinus Torvalds 2615808a049eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 2616808a049eSMarcel Holtmann ret = -ENETDOWN; 26171da177e4SLinus Torvalds goto done; 2618808a049eSMarcel Holtmann } 26191da177e4SLinus Torvalds 26200736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 26210736cfa8SMarcel Holtmann ret = -EBUSY; 26220736cfa8SMarcel Holtmann goto done; 26230736cfa8SMarcel Holtmann } 26240736cfa8SMarcel Holtmann 26254a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2626fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2627fee746b0SMarcel Holtmann goto done; 2628fee746b0SMarcel Holtmann } 2629fee746b0SMarcel Holtmann 26301da177e4SLinus Torvalds /* Drop queues */ 26311da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 26321da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 26331da177e4SLinus Torvalds 263409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 26351f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 26361da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 263709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 26381da177e4SLinus Torvalds 26391da177e4SLinus Torvalds if (hdev->flush) 26401da177e4SLinus Torvalds hdev->flush(hdev); 26411da177e4SLinus Torvalds 26421da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 26436ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 26441da177e4SLinus Torvalds 264501178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 26461da177e4SLinus Torvalds 26471da177e4SLinus Torvalds done: 26481da177e4SLinus Torvalds hci_req_unlock(hdev); 26491da177e4SLinus Torvalds hci_dev_put(hdev); 26501da177e4SLinus Torvalds return ret; 26511da177e4SLinus Torvalds } 26521da177e4SLinus Torvalds 26531da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 26541da177e4SLinus Torvalds { 26551da177e4SLinus Torvalds struct hci_dev *hdev; 26561da177e4SLinus Torvalds int ret = 0; 26571da177e4SLinus Torvalds 265870f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 265970f23020SAndrei Emeltchenko if (!hdev) 26601da177e4SLinus Torvalds return -ENODEV; 26611da177e4SLinus Torvalds 26620736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 26630736cfa8SMarcel Holtmann ret = -EBUSY; 26640736cfa8SMarcel Holtmann goto done; 26650736cfa8SMarcel Holtmann } 26660736cfa8SMarcel Holtmann 26674a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2668fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2669fee746b0SMarcel Holtmann goto done; 2670fee746b0SMarcel Holtmann } 2671fee746b0SMarcel Holtmann 26721da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 26731da177e4SLinus Torvalds 26740736cfa8SMarcel Holtmann done: 26751da177e4SLinus Torvalds hci_dev_put(hdev); 26761da177e4SLinus Torvalds return ret; 26771da177e4SLinus Torvalds } 26781da177e4SLinus Torvalds 2679123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 2680123abc08SJohan Hedberg { 2681bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 2682123abc08SJohan Hedberg 2683123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 2684123abc08SJohan Hedberg 2685123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 2686123abc08SJohan Hedberg conn_changed = !test_and_set_bit(HCI_CONNECTABLE, 2687123abc08SJohan Hedberg &hdev->dev_flags); 2688123abc08SJohan Hedberg else 2689123abc08SJohan Hedberg conn_changed = test_and_clear_bit(HCI_CONNECTABLE, 2690123abc08SJohan Hedberg &hdev->dev_flags); 2691123abc08SJohan Hedberg 2692bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 2693bc6d2d04SJohan Hedberg discov_changed = !test_and_set_bit(HCI_DISCOVERABLE, 2694bc6d2d04SJohan Hedberg &hdev->dev_flags); 2695bc6d2d04SJohan Hedberg } else { 2696bc6d2d04SJohan Hedberg clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 2697bc6d2d04SJohan Hedberg discov_changed = test_and_clear_bit(HCI_DISCOVERABLE, 2698bc6d2d04SJohan Hedberg &hdev->dev_flags); 2699bc6d2d04SJohan Hedberg } 2700bc6d2d04SJohan Hedberg 2701123abc08SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 2702123abc08SJohan Hedberg return; 2703123abc08SJohan Hedberg 2704bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 2705bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 2706bc6d2d04SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 2707bc6d2d04SJohan Hedberg 2708bc6d2d04SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 2709bc6d2d04SJohan Hedberg mgmt_update_adv_data(hdev); 2710bc6d2d04SJohan Hedberg 2711123abc08SJohan Hedberg mgmt_new_settings(hdev); 2712123abc08SJohan Hedberg } 2713bc6d2d04SJohan Hedberg } 2714123abc08SJohan Hedberg 27151da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 27161da177e4SLinus Torvalds { 27171da177e4SLinus Torvalds struct hci_dev *hdev; 27181da177e4SLinus Torvalds struct hci_dev_req dr; 27191da177e4SLinus Torvalds int err = 0; 27201da177e4SLinus Torvalds 27211da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 27221da177e4SLinus Torvalds return -EFAULT; 27231da177e4SLinus Torvalds 272470f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 272570f23020SAndrei Emeltchenko if (!hdev) 27261da177e4SLinus Torvalds return -ENODEV; 27271da177e4SLinus Torvalds 27280736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 27290736cfa8SMarcel Holtmann err = -EBUSY; 27300736cfa8SMarcel Holtmann goto done; 27310736cfa8SMarcel Holtmann } 27320736cfa8SMarcel Holtmann 27334a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2734fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2735fee746b0SMarcel Holtmann goto done; 2736fee746b0SMarcel Holtmann } 2737fee746b0SMarcel Holtmann 27385b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 27395b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 27405b69bef5SMarcel Holtmann goto done; 27415b69bef5SMarcel Holtmann } 27425b69bef5SMarcel Holtmann 274356f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 274456f87901SJohan Hedberg err = -EOPNOTSUPP; 274556f87901SJohan Hedberg goto done; 274656f87901SJohan Hedberg } 274756f87901SJohan Hedberg 27481da177e4SLinus Torvalds switch (cmd) { 27491da177e4SLinus Torvalds case HCISETAUTH: 275001178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 27515f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27521da177e4SLinus Torvalds break; 27531da177e4SLinus Torvalds 27541da177e4SLinus Torvalds case HCISETENCRYPT: 27551da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 27561da177e4SLinus Torvalds err = -EOPNOTSUPP; 27571da177e4SLinus Torvalds break; 27581da177e4SLinus Torvalds } 27591da177e4SLinus Torvalds 27601da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 27611da177e4SLinus Torvalds /* Auth must be enabled first */ 276201178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 27635f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27641da177e4SLinus Torvalds if (err) 27651da177e4SLinus Torvalds break; 27661da177e4SLinus Torvalds } 27671da177e4SLinus Torvalds 276801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 27695f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27701da177e4SLinus Torvalds break; 27711da177e4SLinus Torvalds 27721da177e4SLinus Torvalds case HCISETSCAN: 277301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 27745f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 277591a668b0SJohan Hedberg 2776bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 2777bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 277891a668b0SJohan Hedberg */ 2779123abc08SJohan Hedberg if (!err) 2780123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 27811da177e4SLinus Torvalds break; 27821da177e4SLinus Torvalds 27831da177e4SLinus Torvalds case HCISETLINKPOL: 278401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 27855f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27861da177e4SLinus Torvalds break; 27871da177e4SLinus Torvalds 27881da177e4SLinus Torvalds case HCISETLINKMODE: 2789e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 2790e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 2791e4e8e37cSMarcel Holtmann break; 2792e4e8e37cSMarcel Holtmann 2793e4e8e37cSMarcel Holtmann case HCISETPTYPE: 2794e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 27951da177e4SLinus Torvalds break; 27961da177e4SLinus Torvalds 27971da177e4SLinus Torvalds case HCISETACLMTU: 27981da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 27991da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 28001da177e4SLinus Torvalds break; 28011da177e4SLinus Torvalds 28021da177e4SLinus Torvalds case HCISETSCOMTU: 28031da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 28041da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 28051da177e4SLinus Torvalds break; 28061da177e4SLinus Torvalds 28071da177e4SLinus Torvalds default: 28081da177e4SLinus Torvalds err = -EINVAL; 28091da177e4SLinus Torvalds break; 28101da177e4SLinus Torvalds } 2811e4e8e37cSMarcel Holtmann 28120736cfa8SMarcel Holtmann done: 28131da177e4SLinus Torvalds hci_dev_put(hdev); 28141da177e4SLinus Torvalds return err; 28151da177e4SLinus Torvalds } 28161da177e4SLinus Torvalds 28171da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 28181da177e4SLinus Torvalds { 28198035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 28201da177e4SLinus Torvalds struct hci_dev_list_req *dl; 28211da177e4SLinus Torvalds struct hci_dev_req *dr; 28221da177e4SLinus Torvalds int n = 0, size, err; 28231da177e4SLinus Torvalds __u16 dev_num; 28241da177e4SLinus Torvalds 28251da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 28261da177e4SLinus Torvalds return -EFAULT; 28271da177e4SLinus Torvalds 28281da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 28291da177e4SLinus Torvalds return -EINVAL; 28301da177e4SLinus Torvalds 28311da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 28321da177e4SLinus Torvalds 283370f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 283470f23020SAndrei Emeltchenko if (!dl) 28351da177e4SLinus Torvalds return -ENOMEM; 28361da177e4SLinus Torvalds 28371da177e4SLinus Torvalds dr = dl->dev_req; 28381da177e4SLinus Torvalds 2839f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 28408035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 28412e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 28422e84d8dbSMarcel Holtmann 28432e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 28442e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 28452e84d8dbSMarcel Holtmann * device is actually down. 28462e84d8dbSMarcel Holtmann */ 28472e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 28482e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 2849c542a06cSJohan Hedberg 28501da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 28512e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 2852c542a06cSJohan Hedberg 28531da177e4SLinus Torvalds if (++n >= dev_num) 28541da177e4SLinus Torvalds break; 28551da177e4SLinus Torvalds } 2856f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 28571da177e4SLinus Torvalds 28581da177e4SLinus Torvalds dl->dev_num = n; 28591da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 28601da177e4SLinus Torvalds 28611da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 28621da177e4SLinus Torvalds kfree(dl); 28631da177e4SLinus Torvalds 28641da177e4SLinus Torvalds return err ? -EFAULT : 0; 28651da177e4SLinus Torvalds } 28661da177e4SLinus Torvalds 28671da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 28681da177e4SLinus Torvalds { 28691da177e4SLinus Torvalds struct hci_dev *hdev; 28701da177e4SLinus Torvalds struct hci_dev_info di; 28712e84d8dbSMarcel Holtmann unsigned long flags; 28721da177e4SLinus Torvalds int err = 0; 28731da177e4SLinus Torvalds 28741da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 28751da177e4SLinus Torvalds return -EFAULT; 28761da177e4SLinus Torvalds 287770f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 287870f23020SAndrei Emeltchenko if (!hdev) 28791da177e4SLinus Torvalds return -ENODEV; 28801da177e4SLinus Torvalds 28812e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 28822e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 28832e84d8dbSMarcel Holtmann * device is actually down. 28842e84d8dbSMarcel Holtmann */ 28852e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 28862e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 28872e84d8dbSMarcel Holtmann else 28882e84d8dbSMarcel Holtmann flags = hdev->flags; 2889ab81cbf9SJohan Hedberg 28901da177e4SLinus Torvalds strcpy(di.name, hdev->name); 28911da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 289260f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 28932e84d8dbSMarcel Holtmann di.flags = flags; 28941da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2895572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 28961da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 28971da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 28981da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 28991da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2900572c7f84SJohan Hedberg } else { 2901572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2902572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2903572c7f84SJohan Hedberg di.sco_mtu = 0; 2904572c7f84SJohan Hedberg di.sco_pkts = 0; 2905572c7f84SJohan Hedberg } 29061da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 29071da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 29081da177e4SLinus Torvalds 29091da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 29101da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 29111da177e4SLinus Torvalds 29121da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 29131da177e4SLinus Torvalds err = -EFAULT; 29141da177e4SLinus Torvalds 29151da177e4SLinus Torvalds hci_dev_put(hdev); 29161da177e4SLinus Torvalds 29171da177e4SLinus Torvalds return err; 29181da177e4SLinus Torvalds } 29191da177e4SLinus Torvalds 29201da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 29211da177e4SLinus Torvalds 2922611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2923611b30f7SMarcel Holtmann { 2924611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2925611b30f7SMarcel Holtmann 2926611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2927611b30f7SMarcel Holtmann 29280736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 29290736cfa8SMarcel Holtmann return -EBUSY; 29300736cfa8SMarcel Holtmann 29315e130367SJohan Hedberg if (blocked) { 29325e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 2933d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2934d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) 2935611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 29365e130367SJohan Hedberg } else { 29375e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 29385e130367SJohan Hedberg } 2939611b30f7SMarcel Holtmann 2940611b30f7SMarcel Holtmann return 0; 2941611b30f7SMarcel Holtmann } 2942611b30f7SMarcel Holtmann 2943611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2944611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2945611b30f7SMarcel Holtmann }; 2946611b30f7SMarcel Holtmann 2947ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2948ab81cbf9SJohan Hedberg { 2949ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 295096570ffcSJohan Hedberg int err; 2951ab81cbf9SJohan Hedberg 2952ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2953ab81cbf9SJohan Hedberg 2954cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 295596570ffcSJohan Hedberg if (err < 0) { 295696570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 2957ab81cbf9SJohan Hedberg return; 295896570ffcSJohan Hedberg } 2959ab81cbf9SJohan Hedberg 2960a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2961a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2962a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2963a5c8f270SMarcel Holtmann */ 2964a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 29654a964404SMarcel Holtmann test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) || 2966a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 2967a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2968a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2969bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2970bf543036SJohan Hedberg hci_dev_do_close(hdev); 2971bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 297219202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 297319202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2974bf543036SJohan Hedberg } 2975ab81cbf9SJohan Hedberg 2976fee746b0SMarcel Holtmann if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) { 29774a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 29784a964404SMarcel Holtmann * so that userspace can easily identify them. 29794a964404SMarcel Holtmann */ 29804a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 29814a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 29820602a8adSMarcel Holtmann 29830602a8adSMarcel Holtmann /* For fully configured devices, this will send 29840602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 29850602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 29860602a8adSMarcel Holtmann * 29870602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 29880602a8adSMarcel Holtmann * and no event will be send. 29890602a8adSMarcel Holtmann */ 2990744cf19eSJohan Hedberg mgmt_index_added(hdev); 2991d603b76bSMarcel Holtmann } else if (test_and_clear_bit(HCI_CONFIG, &hdev->dev_flags)) { 29925ea234d3SMarcel Holtmann /* When the controller is now configured, then it 29935ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 29945ea234d3SMarcel Holtmann */ 29955ea234d3SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 29965ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 29975ea234d3SMarcel Holtmann 2998d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2999d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 3000d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 3001d603b76bSMarcel Holtmann */ 3002d603b76bSMarcel Holtmann mgmt_index_added(hdev); 3003ab81cbf9SJohan Hedberg } 3004fee746b0SMarcel Holtmann } 3005ab81cbf9SJohan Hedberg 3006ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 3007ab81cbf9SJohan Hedberg { 30083243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 30093243553fSJohan Hedberg power_off.work); 3010ab81cbf9SJohan Hedberg 3011ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 3012ab81cbf9SJohan Hedberg 30138ee56540SMarcel Holtmann hci_dev_do_close(hdev); 3014ab81cbf9SJohan Hedberg } 3015ab81cbf9SJohan Hedberg 301616ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 301716ab91abSJohan Hedberg { 301816ab91abSJohan Hedberg struct hci_dev *hdev; 301916ab91abSJohan Hedberg 302016ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 302116ab91abSJohan Hedberg 302216ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 302316ab91abSJohan Hedberg 3024d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 302516ab91abSJohan Hedberg } 302616ab91abSJohan Hedberg 302735f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 30282aeb9a1aSJohan Hedberg { 30294821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 30302aeb9a1aSJohan Hedberg 30314821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 30324821002cSJohan Hedberg list_del(&uuid->list); 30332aeb9a1aSJohan Hedberg kfree(uuid); 30342aeb9a1aSJohan Hedberg } 30352aeb9a1aSJohan Hedberg } 30362aeb9a1aSJohan Hedberg 303735f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 303855ed8ca1SJohan Hedberg { 303955ed8ca1SJohan Hedberg struct list_head *p, *n; 304055ed8ca1SJohan Hedberg 304155ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 304255ed8ca1SJohan Hedberg struct link_key *key; 304355ed8ca1SJohan Hedberg 304455ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 304555ed8ca1SJohan Hedberg 304655ed8ca1SJohan Hedberg list_del(p); 304755ed8ca1SJohan Hedberg kfree(key); 304855ed8ca1SJohan Hedberg } 304955ed8ca1SJohan Hedberg } 305055ed8ca1SJohan Hedberg 305135f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 3052b899efafSVinicius Costa Gomes { 3053b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 3054b899efafSVinicius Costa Gomes 3055b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 3056b899efafSVinicius Costa Gomes list_del(&k->list); 3057b899efafSVinicius Costa Gomes kfree(k); 3058b899efafSVinicius Costa Gomes } 3059b899efafSVinicius Costa Gomes } 3060b899efafSVinicius Costa Gomes 3061970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 3062970c4e46SJohan Hedberg { 3063970c4e46SJohan Hedberg struct smp_irk *k, *tmp; 3064970c4e46SJohan Hedberg 3065970c4e46SJohan Hedberg list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) { 3066970c4e46SJohan Hedberg list_del(&k->list); 3067970c4e46SJohan Hedberg kfree(k); 3068970c4e46SJohan Hedberg } 3069970c4e46SJohan Hedberg } 3070970c4e46SJohan Hedberg 307155ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 307255ed8ca1SJohan Hedberg { 307355ed8ca1SJohan Hedberg struct link_key *k; 307455ed8ca1SJohan Hedberg 30758035ded4SLuiz Augusto von Dentz list_for_each_entry(k, &hdev->link_keys, list) 307655ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 307755ed8ca1SJohan Hedberg return k; 307855ed8ca1SJohan Hedberg 307955ed8ca1SJohan Hedberg return NULL; 308055ed8ca1SJohan Hedberg } 308155ed8ca1SJohan Hedberg 3082745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 3083d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 3084d25e28abSJohan Hedberg { 3085d25e28abSJohan Hedberg /* Legacy key */ 3086d25e28abSJohan Hedberg if (key_type < 0x03) 3087745c0ce3SVishal Agarwal return true; 3088d25e28abSJohan Hedberg 3089d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 3090d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 3091745c0ce3SVishal Agarwal return false; 3092d25e28abSJohan Hedberg 3093d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 3094d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 3095745c0ce3SVishal Agarwal return false; 3096d25e28abSJohan Hedberg 3097d25e28abSJohan Hedberg /* Security mode 3 case */ 3098d25e28abSJohan Hedberg if (!conn) 3099745c0ce3SVishal Agarwal return true; 3100d25e28abSJohan Hedberg 3101d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 3102d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 3103745c0ce3SVishal Agarwal return true; 3104d25e28abSJohan Hedberg 3105d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 3106d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 3107745c0ce3SVishal Agarwal return true; 3108d25e28abSJohan Hedberg 3109d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 3110d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 3111745c0ce3SVishal Agarwal return true; 3112d25e28abSJohan Hedberg 3113d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 3114d25e28abSJohan Hedberg * persistently */ 3115745c0ce3SVishal Agarwal return false; 3116d25e28abSJohan Hedberg } 3117d25e28abSJohan Hedberg 311898a0b845SJohan Hedberg static bool ltk_type_master(u8 type) 311998a0b845SJohan Hedberg { 3120d97c9fb0SJohan Hedberg return (type == SMP_LTK); 312198a0b845SJohan Hedberg } 312298a0b845SJohan Hedberg 3123fe39c7b2SMarcel Holtmann struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, __le64 rand, 312498a0b845SJohan Hedberg bool master) 312575d262c2SVinicius Costa Gomes { 3126c9839a11SVinicius Costa Gomes struct smp_ltk *k; 312775d262c2SVinicius Costa Gomes 3128c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) { 3129fe39c7b2SMarcel Holtmann if (k->ediv != ediv || k->rand != rand) 313075d262c2SVinicius Costa Gomes continue; 313175d262c2SVinicius Costa Gomes 313298a0b845SJohan Hedberg if (ltk_type_master(k->type) != master) 313398a0b845SJohan Hedberg continue; 313498a0b845SJohan Hedberg 313575d262c2SVinicius Costa Gomes return k; 313675d262c2SVinicius Costa Gomes } 313775d262c2SVinicius Costa Gomes 313875d262c2SVinicius Costa Gomes return NULL; 313975d262c2SVinicius Costa Gomes } 314075d262c2SVinicius Costa Gomes 3141c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 314298a0b845SJohan Hedberg u8 addr_type, bool master) 314375d262c2SVinicius Costa Gomes { 3144c9839a11SVinicius Costa Gomes struct smp_ltk *k; 314575d262c2SVinicius Costa Gomes 3146c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) 3147c9839a11SVinicius Costa Gomes if (addr_type == k->bdaddr_type && 314898a0b845SJohan Hedberg bacmp(bdaddr, &k->bdaddr) == 0 && 314998a0b845SJohan Hedberg ltk_type_master(k->type) == master) 315075d262c2SVinicius Costa Gomes return k; 315175d262c2SVinicius Costa Gomes 315275d262c2SVinicius Costa Gomes return NULL; 315375d262c2SVinicius Costa Gomes } 315475d262c2SVinicius Costa Gomes 3155970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 3156970c4e46SJohan Hedberg { 3157970c4e46SJohan Hedberg struct smp_irk *irk; 3158970c4e46SJohan Hedberg 3159970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3160970c4e46SJohan Hedberg if (!bacmp(&irk->rpa, rpa)) 3161970c4e46SJohan Hedberg return irk; 3162970c4e46SJohan Hedberg } 3163970c4e46SJohan Hedberg 3164970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3165970c4e46SJohan Hedberg if (smp_irk_matches(hdev->tfm_aes, irk->val, rpa)) { 3166970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 3167970c4e46SJohan Hedberg return irk; 3168970c4e46SJohan Hedberg } 3169970c4e46SJohan Hedberg } 3170970c4e46SJohan Hedberg 3171970c4e46SJohan Hedberg return NULL; 3172970c4e46SJohan Hedberg } 3173970c4e46SJohan Hedberg 3174970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 3175970c4e46SJohan Hedberg u8 addr_type) 3176970c4e46SJohan Hedberg { 3177970c4e46SJohan Hedberg struct smp_irk *irk; 3178970c4e46SJohan Hedberg 31796cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 31806cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 31816cfc9988SJohan Hedberg return NULL; 31826cfc9988SJohan Hedberg 3183970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3184970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 3185970c4e46SJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) 3186970c4e46SJohan Hedberg return irk; 3187970c4e46SJohan Hedberg } 3188970c4e46SJohan Hedberg 3189970c4e46SJohan Hedberg return NULL; 3190970c4e46SJohan Hedberg } 3191970c4e46SJohan Hedberg 3192567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 31937652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 31947652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 319555ed8ca1SJohan Hedberg { 319655ed8ca1SJohan Hedberg struct link_key *key, *old_key; 3197745c0ce3SVishal Agarwal u8 old_key_type; 319855ed8ca1SJohan Hedberg 319955ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 320055ed8ca1SJohan Hedberg if (old_key) { 320155ed8ca1SJohan Hedberg old_key_type = old_key->type; 320255ed8ca1SJohan Hedberg key = old_key; 320355ed8ca1SJohan Hedberg } else { 320412adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 32050a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 320655ed8ca1SJohan Hedberg if (!key) 3207567fa2aaSJohan Hedberg return NULL; 320855ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 320955ed8ca1SJohan Hedberg } 321055ed8ca1SJohan Hedberg 32116ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 321255ed8ca1SJohan Hedberg 3213d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 3214d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 3215d25e28abSJohan Hedberg * previous key */ 3216d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 3217a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 3218d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 3219655fe6ecSJohan Hedberg if (conn) 3220655fe6ecSJohan Hedberg conn->key_type = type; 3221655fe6ecSJohan Hedberg } 3222d25e28abSJohan Hedberg 322355ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 32249b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 322555ed8ca1SJohan Hedberg key->pin_len = pin_len; 322655ed8ca1SJohan Hedberg 3227b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 322855ed8ca1SJohan Hedberg key->type = old_key_type; 32294748fed2SJohan Hedberg else 32304748fed2SJohan Hedberg key->type = type; 32314748fed2SJohan Hedberg 32327652ff6aSJohan Hedberg if (persistent) 32337652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 32347652ff6aSJohan Hedberg old_key_type); 323555ed8ca1SJohan Hedberg 3236567fa2aaSJohan Hedberg return key; 323755ed8ca1SJohan Hedberg } 323855ed8ca1SJohan Hedberg 3239ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 324035d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 3241fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 324275d262c2SVinicius Costa Gomes { 3243c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 324498a0b845SJohan Hedberg bool master = ltk_type_master(type); 324575d262c2SVinicius Costa Gomes 324698a0b845SJohan Hedberg old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type, master); 3247c9839a11SVinicius Costa Gomes if (old_key) 324875d262c2SVinicius Costa Gomes key = old_key; 3249c9839a11SVinicius Costa Gomes else { 32500a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 325175d262c2SVinicius Costa Gomes if (!key) 3252ca9142b8SJohan Hedberg return NULL; 3253c9839a11SVinicius Costa Gomes list_add(&key->list, &hdev->long_term_keys); 325475d262c2SVinicius Costa Gomes } 325575d262c2SVinicius Costa Gomes 325675d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 3257c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 3258c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 3259c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 3260c9839a11SVinicius Costa Gomes key->ediv = ediv; 3261fe39c7b2SMarcel Holtmann key->rand = rand; 3262c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 3263c9839a11SVinicius Costa Gomes key->type = type; 326475d262c2SVinicius Costa Gomes 3265ca9142b8SJohan Hedberg return key; 326675d262c2SVinicius Costa Gomes } 326775d262c2SVinicius Costa Gomes 3268ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 3269ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 3270970c4e46SJohan Hedberg { 3271970c4e46SJohan Hedberg struct smp_irk *irk; 3272970c4e46SJohan Hedberg 3273970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 3274970c4e46SJohan Hedberg if (!irk) { 3275970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 3276970c4e46SJohan Hedberg if (!irk) 3277ca9142b8SJohan Hedberg return NULL; 3278970c4e46SJohan Hedberg 3279970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 3280970c4e46SJohan Hedberg irk->addr_type = addr_type; 3281970c4e46SJohan Hedberg 3282970c4e46SJohan Hedberg list_add(&irk->list, &hdev->identity_resolving_keys); 3283970c4e46SJohan Hedberg } 3284970c4e46SJohan Hedberg 3285970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 3286970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 3287970c4e46SJohan Hedberg 3288ca9142b8SJohan Hedberg return irk; 3289970c4e46SJohan Hedberg } 3290970c4e46SJohan Hedberg 329155ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 329255ed8ca1SJohan Hedberg { 329355ed8ca1SJohan Hedberg struct link_key *key; 329455ed8ca1SJohan Hedberg 329555ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 329655ed8ca1SJohan Hedberg if (!key) 329755ed8ca1SJohan Hedberg return -ENOENT; 329855ed8ca1SJohan Hedberg 32996ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 330055ed8ca1SJohan Hedberg 330155ed8ca1SJohan Hedberg list_del(&key->list); 330255ed8ca1SJohan Hedberg kfree(key); 330355ed8ca1SJohan Hedberg 330455ed8ca1SJohan Hedberg return 0; 330555ed8ca1SJohan Hedberg } 330655ed8ca1SJohan Hedberg 3307e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 3308b899efafSVinicius Costa Gomes { 3309b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 3310c51ffa0bSJohan Hedberg int removed = 0; 3311b899efafSVinicius Costa Gomes 3312b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 3313e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 3314b899efafSVinicius Costa Gomes continue; 3315b899efafSVinicius Costa Gomes 33166ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3317b899efafSVinicius Costa Gomes 3318b899efafSVinicius Costa Gomes list_del(&k->list); 3319b899efafSVinicius Costa Gomes kfree(k); 3320c51ffa0bSJohan Hedberg removed++; 3321b899efafSVinicius Costa Gomes } 3322b899efafSVinicius Costa Gomes 3323c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 3324b899efafSVinicius Costa Gomes } 3325b899efafSVinicius Costa Gomes 3326a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 3327a7ec7338SJohan Hedberg { 3328a7ec7338SJohan Hedberg struct smp_irk *k, *tmp; 3329a7ec7338SJohan Hedberg 3330668b7b19SJohan Hedberg list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) { 3331a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 3332a7ec7338SJohan Hedberg continue; 3333a7ec7338SJohan Hedberg 3334a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3335a7ec7338SJohan Hedberg 3336a7ec7338SJohan Hedberg list_del(&k->list); 3337a7ec7338SJohan Hedberg kfree(k); 3338a7ec7338SJohan Hedberg } 3339a7ec7338SJohan Hedberg } 3340a7ec7338SJohan Hedberg 33416bd32326SVille Tervo /* HCI command timer function */ 334265cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 33436bd32326SVille Tervo { 334465cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 334565cc2b49SMarcel Holtmann cmd_timer.work); 33466bd32326SVille Tervo 3347bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 3348bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 3349bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 3350bda4f23aSAndrei Emeltchenko 3351bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 3352bda4f23aSAndrei Emeltchenko } else { 33536bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 3354bda4f23aSAndrei Emeltchenko } 3355bda4f23aSAndrei Emeltchenko 33566bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 3357c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 33586bd32326SVille Tervo } 33596bd32326SVille Tervo 33602763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 33612763eda6SSzymon Janc bdaddr_t *bdaddr) 33622763eda6SSzymon Janc { 33632763eda6SSzymon Janc struct oob_data *data; 33642763eda6SSzymon Janc 33652763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 33662763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 33672763eda6SSzymon Janc return data; 33682763eda6SSzymon Janc 33692763eda6SSzymon Janc return NULL; 33702763eda6SSzymon Janc } 33712763eda6SSzymon Janc 33722763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 33732763eda6SSzymon Janc { 33742763eda6SSzymon Janc struct oob_data *data; 33752763eda6SSzymon Janc 33762763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 33772763eda6SSzymon Janc if (!data) 33782763eda6SSzymon Janc return -ENOENT; 33792763eda6SSzymon Janc 33806ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 33812763eda6SSzymon Janc 33822763eda6SSzymon Janc list_del(&data->list); 33832763eda6SSzymon Janc kfree(data); 33842763eda6SSzymon Janc 33852763eda6SSzymon Janc return 0; 33862763eda6SSzymon Janc } 33872763eda6SSzymon Janc 338835f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 33892763eda6SSzymon Janc { 33902763eda6SSzymon Janc struct oob_data *data, *n; 33912763eda6SSzymon Janc 33922763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 33932763eda6SSzymon Janc list_del(&data->list); 33942763eda6SSzymon Janc kfree(data); 33952763eda6SSzymon Janc } 33962763eda6SSzymon Janc } 33972763eda6SSzymon Janc 33980798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 33990798872eSMarcel Holtmann u8 *hash, u8 *randomizer) 34002763eda6SSzymon Janc { 34012763eda6SSzymon Janc struct oob_data *data; 34022763eda6SSzymon Janc 34032763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 34042763eda6SSzymon Janc if (!data) { 34050a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 34062763eda6SSzymon Janc if (!data) 34072763eda6SSzymon Janc return -ENOMEM; 34082763eda6SSzymon Janc 34092763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 34102763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 34112763eda6SSzymon Janc } 34122763eda6SSzymon Janc 3413519ca9d0SMarcel Holtmann memcpy(data->hash192, hash, sizeof(data->hash192)); 3414519ca9d0SMarcel Holtmann memcpy(data->randomizer192, randomizer, sizeof(data->randomizer192)); 34152763eda6SSzymon Janc 34160798872eSMarcel Holtmann memset(data->hash256, 0, sizeof(data->hash256)); 34170798872eSMarcel Holtmann memset(data->randomizer256, 0, sizeof(data->randomizer256)); 34180798872eSMarcel Holtmann 34190798872eSMarcel Holtmann BT_DBG("%s for %pMR", hdev->name, bdaddr); 34200798872eSMarcel Holtmann 34210798872eSMarcel Holtmann return 0; 34220798872eSMarcel Holtmann } 34230798872eSMarcel Holtmann 34240798872eSMarcel Holtmann int hci_add_remote_oob_ext_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 34250798872eSMarcel Holtmann u8 *hash192, u8 *randomizer192, 34260798872eSMarcel Holtmann u8 *hash256, u8 *randomizer256) 34270798872eSMarcel Holtmann { 34280798872eSMarcel Holtmann struct oob_data *data; 34290798872eSMarcel Holtmann 34300798872eSMarcel Holtmann data = hci_find_remote_oob_data(hdev, bdaddr); 34310798872eSMarcel Holtmann if (!data) { 34320a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 34330798872eSMarcel Holtmann if (!data) 34340798872eSMarcel Holtmann return -ENOMEM; 34350798872eSMarcel Holtmann 34360798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 34370798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 34380798872eSMarcel Holtmann } 34390798872eSMarcel Holtmann 34400798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 34410798872eSMarcel Holtmann memcpy(data->randomizer192, randomizer192, sizeof(data->randomizer192)); 34420798872eSMarcel Holtmann 34430798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 34440798872eSMarcel Holtmann memcpy(data->randomizer256, randomizer256, sizeof(data->randomizer256)); 34450798872eSMarcel Holtmann 34466ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 34472763eda6SSzymon Janc 34482763eda6SSzymon Janc return 0; 34492763eda6SSzymon Janc } 34502763eda6SSzymon Janc 3451dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 3452b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 3453b2a66aadSAntti Julku { 3454b2a66aadSAntti Julku struct bdaddr_list *b; 3455b2a66aadSAntti Julku 3456dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 3457b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 3458b2a66aadSAntti Julku return b; 3459b9ee0a78SMarcel Holtmann } 3460b2a66aadSAntti Julku 3461b2a66aadSAntti Julku return NULL; 3462b2a66aadSAntti Julku } 3463b2a66aadSAntti Julku 3464dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 3465b2a66aadSAntti Julku { 3466b2a66aadSAntti Julku struct list_head *p, *n; 3467b2a66aadSAntti Julku 3468dcc36c16SJohan Hedberg list_for_each_safe(p, n, bdaddr_list) { 3469b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 3470b2a66aadSAntti Julku 3471b2a66aadSAntti Julku list_del(p); 3472b2a66aadSAntti Julku kfree(b); 3473b2a66aadSAntti Julku } 3474b2a66aadSAntti Julku } 3475b2a66aadSAntti Julku 3476dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3477b2a66aadSAntti Julku { 3478b2a66aadSAntti Julku struct bdaddr_list *entry; 3479b2a66aadSAntti Julku 3480b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 3481b2a66aadSAntti Julku return -EBADF; 3482b2a66aadSAntti Julku 3483dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 34845e762444SAntti Julku return -EEXIST; 3485b2a66aadSAntti Julku 3486b2a66aadSAntti Julku entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL); 34875e762444SAntti Julku if (!entry) 34885e762444SAntti Julku return -ENOMEM; 3489b2a66aadSAntti Julku 3490b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 3491b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 3492b2a66aadSAntti Julku 3493dcc36c16SJohan Hedberg list_add(&entry->list, list); 3494b2a66aadSAntti Julku 34952a8357f2SJohan Hedberg return 0; 3496b2a66aadSAntti Julku } 3497b2a66aadSAntti Julku 3498dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3499b2a66aadSAntti Julku { 3500b2a66aadSAntti Julku struct bdaddr_list *entry; 3501b2a66aadSAntti Julku 350235f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 3503dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 350435f7498aSJohan Hedberg return 0; 350535f7498aSJohan Hedberg } 3506b2a66aadSAntti Julku 3507dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 3508d2ab0ac1SMarcel Holtmann if (!entry) 3509d2ab0ac1SMarcel Holtmann return -ENOENT; 3510d2ab0ac1SMarcel Holtmann 3511d2ab0ac1SMarcel Holtmann list_del(&entry->list); 3512d2ab0ac1SMarcel Holtmann kfree(entry); 3513d2ab0ac1SMarcel Holtmann 3514d2ab0ac1SMarcel Holtmann return 0; 3515d2ab0ac1SMarcel Holtmann } 3516d2ab0ac1SMarcel Holtmann 351715819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 351815819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 351915819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 352015819a70SAndre Guedes { 352115819a70SAndre Guedes struct hci_conn_params *params; 352215819a70SAndre Guedes 3523738f6185SJohan Hedberg /* The conn params list only contains identity addresses */ 3524738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 3525738f6185SJohan Hedberg return NULL; 3526738f6185SJohan Hedberg 352715819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 352815819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 352915819a70SAndre Guedes params->addr_type == addr_type) { 353015819a70SAndre Guedes return params; 353115819a70SAndre Guedes } 353215819a70SAndre Guedes } 353315819a70SAndre Guedes 353415819a70SAndre Guedes return NULL; 353515819a70SAndre Guedes } 353615819a70SAndre Guedes 3537cef952ceSAndre Guedes static bool is_connected(struct hci_dev *hdev, bdaddr_t *addr, u8 type) 3538cef952ceSAndre Guedes { 3539cef952ceSAndre Guedes struct hci_conn *conn; 3540cef952ceSAndre Guedes 3541cef952ceSAndre Guedes conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, addr); 3542cef952ceSAndre Guedes if (!conn) 3543cef952ceSAndre Guedes return false; 3544cef952ceSAndre Guedes 3545cef952ceSAndre Guedes if (conn->dst_type != type) 3546cef952ceSAndre Guedes return false; 3547cef952ceSAndre Guedes 3548cef952ceSAndre Guedes if (conn->state != BT_CONNECTED) 3549cef952ceSAndre Guedes return false; 3550cef952ceSAndre Guedes 3551cef952ceSAndre Guedes return true; 3552cef952ceSAndre Guedes } 3553cef952ceSAndre Guedes 355415819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 3555501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 35564b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 35574b10966fSMarcel Holtmann { 3558912b42efSJohan Hedberg struct hci_conn_params *param; 35594b10966fSMarcel Holtmann 3560738f6185SJohan Hedberg /* The list only contains identity addresses */ 3561738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 3562738f6185SJohan Hedberg return NULL; 3563738f6185SJohan Hedberg 3564501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 3565912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 3566912b42efSJohan Hedberg param->addr_type == addr_type) 3567912b42efSJohan Hedberg return param; 35684b10966fSMarcel Holtmann } 35694b10966fSMarcel Holtmann 35704b10966fSMarcel Holtmann return NULL; 35714b10966fSMarcel Holtmann } 35724b10966fSMarcel Holtmann 35734b10966fSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 357451d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 357551d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 3576bf5b3c8bSMarcel Holtmann { 3577bf5b3c8bSMarcel Holtmann struct hci_conn_params *params; 3578bf5b3c8bSMarcel Holtmann 3579c46245b3SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 358051d167c0SMarcel Holtmann return NULL; 3581bf5b3c8bSMarcel Holtmann 3582bf5b3c8bSMarcel Holtmann params = hci_conn_params_lookup(hdev, addr, addr_type); 3583bf5b3c8bSMarcel Holtmann if (params) 358451d167c0SMarcel Holtmann return params; 3585bf5b3c8bSMarcel Holtmann 3586bf5b3c8bSMarcel Holtmann params = kzalloc(sizeof(*params), GFP_KERNEL); 3587bf5b3c8bSMarcel Holtmann if (!params) { 3588bf5b3c8bSMarcel Holtmann BT_ERR("Out of memory"); 358951d167c0SMarcel Holtmann return NULL; 3590bf5b3c8bSMarcel Holtmann } 3591bf5b3c8bSMarcel Holtmann 3592bf5b3c8bSMarcel Holtmann bacpy(¶ms->addr, addr); 3593bf5b3c8bSMarcel Holtmann params->addr_type = addr_type; 3594bf5b3c8bSMarcel Holtmann 3595bf5b3c8bSMarcel Holtmann list_add(¶ms->list, &hdev->le_conn_params); 359693450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 3597bf5b3c8bSMarcel Holtmann 3598bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 3599bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 3600bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 3601bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 3602bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 3603bf5b3c8bSMarcel Holtmann 3604bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 3605bf5b3c8bSMarcel Holtmann 360651d167c0SMarcel Holtmann return params; 3607bf5b3c8bSMarcel Holtmann } 3608bf5b3c8bSMarcel Holtmann 3609bf5b3c8bSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 3610bf5b3c8bSMarcel Holtmann int hci_conn_params_set(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type, 3611d06b50ceSMarcel Holtmann u8 auto_connect) 361215819a70SAndre Guedes { 361315819a70SAndre Guedes struct hci_conn_params *params; 361415819a70SAndre Guedes 36158c87aae1SMarcel Holtmann params = hci_conn_params_add(hdev, addr, addr_type); 36168c87aae1SMarcel Holtmann if (!params) 36178c87aae1SMarcel Holtmann return -EIO; 3618a9b0a04cSAndre Guedes 361942ce26deSJohan Hedberg if (params->auto_connect == auto_connect) 362042ce26deSJohan Hedberg return 0; 362142ce26deSJohan Hedberg 362266f8455aSJohan Hedberg list_del_init(¶ms->action); 362315819a70SAndre Guedes 3624cef952ceSAndre Guedes switch (auto_connect) { 3625cef952ceSAndre Guedes case HCI_AUTO_CONN_DISABLED: 3626cef952ceSAndre Guedes case HCI_AUTO_CONN_LINK_LOSS: 362795305baaSJohan Hedberg hci_update_background_scan(hdev); 3628cef952ceSAndre Guedes break; 3629851efca8SJohan Hedberg case HCI_AUTO_CONN_REPORT: 363095305baaSJohan Hedberg list_add(¶ms->action, &hdev->pend_le_reports); 363195305baaSJohan Hedberg hci_update_background_scan(hdev); 3632851efca8SJohan Hedberg break; 3633cef952ceSAndre Guedes case HCI_AUTO_CONN_ALWAYS: 363495305baaSJohan Hedberg if (!is_connected(hdev, addr, addr_type)) { 363595305baaSJohan Hedberg list_add(¶ms->action, &hdev->pend_le_conns); 363695305baaSJohan Hedberg hci_update_background_scan(hdev); 363795305baaSJohan Hedberg } 3638cef952ceSAndre Guedes break; 3639cef952ceSAndre Guedes } 364015819a70SAndre Guedes 3641851efca8SJohan Hedberg params->auto_connect = auto_connect; 3642851efca8SJohan Hedberg 3643d06b50ceSMarcel Holtmann BT_DBG("addr %pMR (type %u) auto_connect %u", addr, addr_type, 3644d06b50ceSMarcel Holtmann auto_connect); 3645a9b0a04cSAndre Guedes 3646a9b0a04cSAndre Guedes return 0; 364715819a70SAndre Guedes } 364815819a70SAndre Guedes 364915819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 365015819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 365115819a70SAndre Guedes { 365215819a70SAndre Guedes struct hci_conn_params *params; 365315819a70SAndre Guedes 365415819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 365515819a70SAndre Guedes if (!params) 365615819a70SAndre Guedes return; 365715819a70SAndre Guedes 365895305baaSJohan Hedberg list_del(¶ms->action); 365915819a70SAndre Guedes list_del(¶ms->list); 366015819a70SAndre Guedes kfree(params); 366115819a70SAndre Guedes 366295305baaSJohan Hedberg hci_update_background_scan(hdev); 366395305baaSJohan Hedberg 366415819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 366515819a70SAndre Guedes } 366615819a70SAndre Guedes 366715819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 366855af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 366955af49a8SJohan Hedberg { 367055af49a8SJohan Hedberg struct hci_conn_params *params, *tmp; 367155af49a8SJohan Hedberg 367255af49a8SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 367355af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 367455af49a8SJohan Hedberg continue; 367555af49a8SJohan Hedberg list_del(¶ms->list); 367655af49a8SJohan Hedberg kfree(params); 367755af49a8SJohan Hedberg } 367855af49a8SJohan Hedberg 367955af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 368055af49a8SJohan Hedberg } 368155af49a8SJohan Hedberg 368255af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 3683373110c5SJohan Hedberg void hci_conn_params_clear_all(struct hci_dev *hdev) 368415819a70SAndre Guedes { 368515819a70SAndre Guedes struct hci_conn_params *params, *tmp; 368615819a70SAndre Guedes 368715819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 3688a2f41a8fSJohan Hedberg list_del(¶ms->action); 368915819a70SAndre Guedes list_del(¶ms->list); 369015819a70SAndre Guedes kfree(params); 369115819a70SAndre Guedes } 369215819a70SAndre Guedes 3693a2f41a8fSJohan Hedberg hci_update_background_scan(hdev); 36941089b67dSMarcel Holtmann 369515819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 369615819a70SAndre Guedes } 369715819a70SAndre Guedes 36984c87eaabSAndre Guedes static void inquiry_complete(struct hci_dev *hdev, u8 status) 36997ba8b4beSAndre Guedes { 37004c87eaabSAndre Guedes if (status) { 37014c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 37027ba8b4beSAndre Guedes 37034c87eaabSAndre Guedes hci_dev_lock(hdev); 37044c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37054c87eaabSAndre Guedes hci_dev_unlock(hdev); 37064c87eaabSAndre Guedes return; 37074c87eaabSAndre Guedes } 37087ba8b4beSAndre Guedes } 37097ba8b4beSAndre Guedes 37104c87eaabSAndre Guedes static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status) 37117ba8b4beSAndre Guedes { 37124c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 37134c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 37144c87eaabSAndre Guedes struct hci_request req; 37154c87eaabSAndre Guedes struct hci_cp_inquiry cp; 37167ba8b4beSAndre Guedes int err; 37177ba8b4beSAndre Guedes 37184c87eaabSAndre Guedes if (status) { 37194c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 37204c87eaabSAndre Guedes return; 37217ba8b4beSAndre Guedes } 37227ba8b4beSAndre Guedes 37234c87eaabSAndre Guedes switch (hdev->discovery.type) { 37244c87eaabSAndre Guedes case DISCOV_TYPE_LE: 37254c87eaabSAndre Guedes hci_dev_lock(hdev); 37264c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37274c87eaabSAndre Guedes hci_dev_unlock(hdev); 37284c87eaabSAndre Guedes break; 37297dbfac1dSAndre Guedes 37304c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 37314c87eaabSAndre Guedes hci_req_init(&req, hdev); 37327dbfac1dSAndre Guedes 37337dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 37344c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 37354c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 37364c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 37374c87eaabSAndre Guedes 37384c87eaabSAndre Guedes hci_dev_lock(hdev); 37394c87eaabSAndre Guedes 37404c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 37414c87eaabSAndre Guedes 37424c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 37434c87eaabSAndre Guedes if (err) { 37444c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 37454c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37467dbfac1dSAndre Guedes } 37477dbfac1dSAndre Guedes 37484c87eaabSAndre Guedes hci_dev_unlock(hdev); 37494c87eaabSAndre Guedes break; 37504c87eaabSAndre Guedes } 37517dbfac1dSAndre Guedes } 37527dbfac1dSAndre Guedes 37537ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 37547ba8b4beSAndre Guedes { 37557ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 37567ba8b4beSAndre Guedes le_scan_disable.work); 37574c87eaabSAndre Guedes struct hci_request req; 37584c87eaabSAndre Guedes int err; 37597ba8b4beSAndre Guedes 37607ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 37617ba8b4beSAndre Guedes 37624c87eaabSAndre Guedes hci_req_init(&req, hdev); 37637ba8b4beSAndre Guedes 3764b1efcc28SAndre Guedes hci_req_add_le_scan_disable(&req); 37657ba8b4beSAndre Guedes 37664c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 37674c87eaabSAndre Guedes if (err) 37684c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 376928b75a89SAndre Guedes } 377028b75a89SAndre Guedes 37718d97250eSJohan Hedberg static void set_random_addr(struct hci_request *req, bdaddr_t *rpa) 37728d97250eSJohan Hedberg { 37738d97250eSJohan Hedberg struct hci_dev *hdev = req->hdev; 37748d97250eSJohan Hedberg 37758d97250eSJohan Hedberg /* If we're advertising or initiating an LE connection we can't 37768d97250eSJohan Hedberg * go ahead and change the random address at this time. This is 37778d97250eSJohan Hedberg * because the eventual initiator address used for the 37788d97250eSJohan Hedberg * subsequently created connection will be undefined (some 37798d97250eSJohan Hedberg * controllers use the new address and others the one we had 37808d97250eSJohan Hedberg * when the operation started). 37818d97250eSJohan Hedberg * 37828d97250eSJohan Hedberg * In this kind of scenario skip the update and let the random 37838d97250eSJohan Hedberg * address be updated at the next cycle. 37848d97250eSJohan Hedberg */ 37855ce194c4SJohan Hedberg if (test_bit(HCI_LE_ADV, &hdev->dev_flags) || 37868d97250eSJohan Hedberg hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT)) { 37878d97250eSJohan Hedberg BT_DBG("Deferring random address update"); 37888d97250eSJohan Hedberg return; 37898d97250eSJohan Hedberg } 37908d97250eSJohan Hedberg 37918d97250eSJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, rpa); 37928d97250eSJohan Hedberg } 37938d97250eSJohan Hedberg 379494b1fc92SMarcel Holtmann int hci_update_random_address(struct hci_request *req, bool require_privacy, 379594b1fc92SMarcel Holtmann u8 *own_addr_type) 3796ebd3a747SJohan Hedberg { 3797ebd3a747SJohan Hedberg struct hci_dev *hdev = req->hdev; 3798ebd3a747SJohan Hedberg int err; 3799ebd3a747SJohan Hedberg 3800ebd3a747SJohan Hedberg /* If privacy is enabled use a resolvable private address. If 38012b5224dcSMarcel Holtmann * current RPA has expired or there is something else than 38022b5224dcSMarcel Holtmann * the current RPA in use, then generate a new one. 3803ebd3a747SJohan Hedberg */ 3804ebd3a747SJohan Hedberg if (test_bit(HCI_PRIVACY, &hdev->dev_flags)) { 3805ebd3a747SJohan Hedberg int to; 3806ebd3a747SJohan Hedberg 3807ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3808ebd3a747SJohan Hedberg 3809ebd3a747SJohan Hedberg if (!test_and_clear_bit(HCI_RPA_EXPIRED, &hdev->dev_flags) && 38102b5224dcSMarcel Holtmann !bacmp(&hdev->random_addr, &hdev->rpa)) 3811ebd3a747SJohan Hedberg return 0; 3812ebd3a747SJohan Hedberg 38132b5224dcSMarcel Holtmann err = smp_generate_rpa(hdev->tfm_aes, hdev->irk, &hdev->rpa); 3814ebd3a747SJohan Hedberg if (err < 0) { 3815ebd3a747SJohan Hedberg BT_ERR("%s failed to generate new RPA", hdev->name); 3816ebd3a747SJohan Hedberg return err; 3817ebd3a747SJohan Hedberg } 3818ebd3a747SJohan Hedberg 38198d97250eSJohan Hedberg set_random_addr(req, &hdev->rpa); 3820ebd3a747SJohan Hedberg 3821ebd3a747SJohan Hedberg to = msecs_to_jiffies(hdev->rpa_timeout * 1000); 3822ebd3a747SJohan Hedberg queue_delayed_work(hdev->workqueue, &hdev->rpa_expired, to); 3823ebd3a747SJohan Hedberg 3824ebd3a747SJohan Hedberg return 0; 3825ebd3a747SJohan Hedberg } 3826ebd3a747SJohan Hedberg 382794b1fc92SMarcel Holtmann /* In case of required privacy without resolvable private address, 382894b1fc92SMarcel Holtmann * use an unresolvable private address. This is useful for active 382994b1fc92SMarcel Holtmann * scanning and non-connectable advertising. 383094b1fc92SMarcel Holtmann */ 383194b1fc92SMarcel Holtmann if (require_privacy) { 383294b1fc92SMarcel Holtmann bdaddr_t urpa; 383394b1fc92SMarcel Holtmann 383494b1fc92SMarcel Holtmann get_random_bytes(&urpa, 6); 383594b1fc92SMarcel Holtmann urpa.b[5] &= 0x3f; /* Clear two most significant bits */ 383694b1fc92SMarcel Holtmann 383794b1fc92SMarcel Holtmann *own_addr_type = ADDR_LE_DEV_RANDOM; 38388d97250eSJohan Hedberg set_random_addr(req, &urpa); 383994b1fc92SMarcel Holtmann return 0; 384094b1fc92SMarcel Holtmann } 384194b1fc92SMarcel Holtmann 3842ebd3a747SJohan Hedberg /* If forcing static address is in use or there is no public 3843ebd3a747SJohan Hedberg * address use the static address as random address (but skip 3844ebd3a747SJohan Hedberg * the HCI command if the current random address is already the 3845ebd3a747SJohan Hedberg * static one. 3846ebd3a747SJohan Hedberg */ 3847111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3848ebd3a747SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3849ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3850ebd3a747SJohan Hedberg if (bacmp(&hdev->static_addr, &hdev->random_addr)) 3851ebd3a747SJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, 3852ebd3a747SJohan Hedberg &hdev->static_addr); 3853ebd3a747SJohan Hedberg return 0; 3854ebd3a747SJohan Hedberg } 3855ebd3a747SJohan Hedberg 3856ebd3a747SJohan Hedberg /* Neither privacy nor static address is being used so use a 3857ebd3a747SJohan Hedberg * public address. 3858ebd3a747SJohan Hedberg */ 3859ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_PUBLIC; 3860ebd3a747SJohan Hedberg 3861ebd3a747SJohan Hedberg return 0; 3862ebd3a747SJohan Hedberg } 3863ebd3a747SJohan Hedberg 3864a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 3865a1f4c318SJohan Hedberg * 3866a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 3867a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 3868a1f4c318SJohan Hedberg * the static random address. 3869a1f4c318SJohan Hedberg * 3870a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 3871a1f4c318SJohan Hedberg * public address to use the static random address instead. 3872a1f4c318SJohan Hedberg */ 3873a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 3874a1f4c318SJohan Hedberg u8 *bdaddr_type) 3875a1f4c318SJohan Hedberg { 3876111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3877a1f4c318SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3878a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3879a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3880a1f4c318SJohan Hedberg } else { 3881a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3882a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3883a1f4c318SJohan Hedberg } 3884a1f4c318SJohan Hedberg } 3885a1f4c318SJohan Hedberg 38869be0dab7SDavid Herrmann /* Alloc HCI device */ 38879be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 38889be0dab7SDavid Herrmann { 38899be0dab7SDavid Herrmann struct hci_dev *hdev; 38909be0dab7SDavid Herrmann 38919be0dab7SDavid Herrmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 38929be0dab7SDavid Herrmann if (!hdev) 38939be0dab7SDavid Herrmann return NULL; 38949be0dab7SDavid Herrmann 3895b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3896b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3897b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3898b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3899b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 390096c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3901bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3902bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3903b1b813d4SDavid Herrmann 3904b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3905b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3906b1b813d4SDavid Herrmann 39073f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3908bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3909bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 39104e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 39114e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 391204fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 391304fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3914bef64738SMarcel Holtmann 3915d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3916b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 391731ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 391831ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3919d6bfd59cSJohan Hedberg 3920b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3921b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3922b1b813d4SDavid Herrmann 3923b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3924b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 39256659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 3926b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3927b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3928b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3929970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3930b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3931d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 393215819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 393377a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 393466f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 39356b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3936b1b813d4SDavid Herrmann 3937b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3938b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3939b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3940b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3941b1b813d4SDavid Herrmann 3942b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3943b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 3944b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 3945b1b813d4SDavid Herrmann 3946b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3947b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3948b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3949b1b813d4SDavid Herrmann 3950b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3951b1b813d4SDavid Herrmann 395265cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3953b1b813d4SDavid Herrmann 3954b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3955b1b813d4SDavid Herrmann discovery_init(hdev); 39569be0dab7SDavid Herrmann 39579be0dab7SDavid Herrmann return hdev; 39589be0dab7SDavid Herrmann } 39599be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 39609be0dab7SDavid Herrmann 39619be0dab7SDavid Herrmann /* Free HCI device */ 39629be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 39639be0dab7SDavid Herrmann { 39649be0dab7SDavid Herrmann /* will free via device release */ 39659be0dab7SDavid Herrmann put_device(&hdev->dev); 39669be0dab7SDavid Herrmann } 39679be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 39689be0dab7SDavid Herrmann 39691da177e4SLinus Torvalds /* Register HCI device */ 39701da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 39711da177e4SLinus Torvalds { 3972b1b813d4SDavid Herrmann int id, error; 39731da177e4SLinus Torvalds 397474292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 39751da177e4SLinus Torvalds return -EINVAL; 39761da177e4SLinus Torvalds 397708add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 397808add513SMat Martineau * so the index can be used as the AMP controller ID. 397908add513SMat Martineau */ 39803df92b31SSasha Levin switch (hdev->dev_type) { 39813df92b31SSasha Levin case HCI_BREDR: 39823df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 39831da177e4SLinus Torvalds break; 39843df92b31SSasha Levin case HCI_AMP: 39853df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 39863df92b31SSasha Levin break; 39873df92b31SSasha Levin default: 39883df92b31SSasha Levin return -EINVAL; 39891da177e4SLinus Torvalds } 39901da177e4SLinus Torvalds 39913df92b31SSasha Levin if (id < 0) 39923df92b31SSasha Levin return id; 39933df92b31SSasha Levin 39941da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 39951da177e4SLinus Torvalds hdev->id = id; 39962d8b3a11SAndrei Emeltchenko 39972d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 39982d8b3a11SAndrei Emeltchenko 3999d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 4000d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 400133ca954dSDavid Herrmann if (!hdev->workqueue) { 400233ca954dSDavid Herrmann error = -ENOMEM; 400333ca954dSDavid Herrmann goto err; 400433ca954dSDavid Herrmann } 4005f48fd9c8SMarcel Holtmann 4006d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 4007d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 40086ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 40096ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 40106ead1bbcSJohan Hedberg error = -ENOMEM; 40116ead1bbcSJohan Hedberg goto err; 40126ead1bbcSJohan Hedberg } 40136ead1bbcSJohan Hedberg 40140153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 40150153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 40160153e2ecSMarcel Holtmann 4017bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 4018bdc3e0f1SMarcel Holtmann 401999780a7bSJohan Hedberg hdev->tfm_aes = crypto_alloc_blkcipher("ecb(aes)", 0, 402099780a7bSJohan Hedberg CRYPTO_ALG_ASYNC); 402199780a7bSJohan Hedberg if (IS_ERR(hdev->tfm_aes)) { 402299780a7bSJohan Hedberg BT_ERR("Unable to create crypto context"); 402399780a7bSJohan Hedberg error = PTR_ERR(hdev->tfm_aes); 402499780a7bSJohan Hedberg hdev->tfm_aes = NULL; 402599780a7bSJohan Hedberg goto err_wqueue; 402699780a7bSJohan Hedberg } 402799780a7bSJohan Hedberg 4028bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 402933ca954dSDavid Herrmann if (error < 0) 403099780a7bSJohan Hedberg goto err_tfm; 40311da177e4SLinus Torvalds 4032611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 4033a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 4034a8c5fb1aSGustavo Padovan hdev); 4035611b30f7SMarcel Holtmann if (hdev->rfkill) { 4036611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 4037611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 4038611b30f7SMarcel Holtmann hdev->rfkill = NULL; 4039611b30f7SMarcel Holtmann } 4040611b30f7SMarcel Holtmann } 4041611b30f7SMarcel Holtmann 40425e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 40435e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 40445e130367SJohan Hedberg 4045a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 4046004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 4047ce2be9acSAndrei Emeltchenko 404801cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 404956f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 405056f87901SJohan Hedberg * through reading supported features during init. 405156f87901SJohan Hedberg */ 405256f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 405356f87901SJohan Hedberg } 4054ce2be9acSAndrei Emeltchenko 4055fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 4056fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 4057fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 4058fcee3377SGustavo Padovan 40594a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 40604a964404SMarcel Holtmann * and should not be included in normal operation. 4061fee746b0SMarcel Holtmann */ 4062fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 40634a964404SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 4064fee746b0SMarcel Holtmann 40651da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 4066dc946bd8SDavid Herrmann hci_dev_hold(hdev); 40671da177e4SLinus Torvalds 406819202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 4069fbe96d6fSMarcel Holtmann 40701da177e4SLinus Torvalds return id; 4071f48fd9c8SMarcel Holtmann 407299780a7bSJohan Hedberg err_tfm: 407399780a7bSJohan Hedberg crypto_free_blkcipher(hdev->tfm_aes); 407433ca954dSDavid Herrmann err_wqueue: 407533ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 40766ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 407733ca954dSDavid Herrmann err: 40783df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 4079f48fd9c8SMarcel Holtmann 408033ca954dSDavid Herrmann return error; 40811da177e4SLinus Torvalds } 40821da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 40831da177e4SLinus Torvalds 40841da177e4SLinus Torvalds /* Unregister HCI device */ 408559735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 40861da177e4SLinus Torvalds { 40873df92b31SSasha Levin int i, id; 4088ef222013SMarcel Holtmann 4089c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 40901da177e4SLinus Torvalds 409194324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 409294324962SJohan Hovold 40933df92b31SSasha Levin id = hdev->id; 40943df92b31SSasha Levin 4095f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 40961da177e4SLinus Torvalds list_del(&hdev->list); 4097f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 40981da177e4SLinus Torvalds 40991da177e4SLinus Torvalds hci_dev_do_close(hdev); 41001da177e4SLinus Torvalds 4101cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 4102ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 4103ef222013SMarcel Holtmann 4104b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 4105b9b5ef18SGustavo Padovan 4106ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 4107d603b76bSMarcel Holtmann !test_bit(HCI_SETUP, &hdev->dev_flags) && 4108d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 410909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 4110744cf19eSJohan Hedberg mgmt_index_removed(hdev); 411109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 411256e5cb86SJohan Hedberg } 4113ab81cbf9SJohan Hedberg 41142e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 41152e58ef3eSJohan Hedberg * pending list */ 41162e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 41172e58ef3eSJohan Hedberg 41181da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 41191da177e4SLinus Torvalds 4120611b30f7SMarcel Holtmann if (hdev->rfkill) { 4121611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 4122611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 4123611b30f7SMarcel Holtmann } 4124611b30f7SMarcel Holtmann 412599780a7bSJohan Hedberg if (hdev->tfm_aes) 412699780a7bSJohan Hedberg crypto_free_blkcipher(hdev->tfm_aes); 412799780a7bSJohan Hedberg 4128bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 4129147e2d59SDave Young 41300153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 41310153e2ecSMarcel Holtmann 4132f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 41336ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 4134f48fd9c8SMarcel Holtmann 413509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 4136dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 41376659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 41382aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 413955ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 4140b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 4141970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 41422763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 4143dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 4144373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 414509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 4146e2e0cacbSJohan Hedberg 4147dc946bd8SDavid Herrmann hci_dev_put(hdev); 41483df92b31SSasha Levin 41493df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 41501da177e4SLinus Torvalds } 41511da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 41521da177e4SLinus Torvalds 41531da177e4SLinus Torvalds /* Suspend HCI device */ 41541da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 41551da177e4SLinus Torvalds { 41561da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 41571da177e4SLinus Torvalds return 0; 41581da177e4SLinus Torvalds } 41591da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 41601da177e4SLinus Torvalds 41611da177e4SLinus Torvalds /* Resume HCI device */ 41621da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 41631da177e4SLinus Torvalds { 41641da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 41651da177e4SLinus Torvalds return 0; 41661da177e4SLinus Torvalds } 41671da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 41681da177e4SLinus Torvalds 416976bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 4170e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 417176bca880SMarcel Holtmann { 417276bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 417376bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 417476bca880SMarcel Holtmann kfree_skb(skb); 417576bca880SMarcel Holtmann return -ENXIO; 417676bca880SMarcel Holtmann } 417776bca880SMarcel Holtmann 4178d82603c6SJorrit Schippers /* Incoming skb */ 417976bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 418076bca880SMarcel Holtmann 418176bca880SMarcel Holtmann /* Time stamp */ 418276bca880SMarcel Holtmann __net_timestamp(skb); 418376bca880SMarcel Holtmann 418476bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 4185b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 4186c78ae283SMarcel Holtmann 418776bca880SMarcel Holtmann return 0; 418876bca880SMarcel Holtmann } 418976bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 419076bca880SMarcel Holtmann 419133e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 41921e429f38SGustavo F. Padovan int count, __u8 index) 419333e882a5SSuraj Sumangala { 419433e882a5SSuraj Sumangala int len = 0; 419533e882a5SSuraj Sumangala int hlen = 0; 419633e882a5SSuraj Sumangala int remain = count; 419733e882a5SSuraj Sumangala struct sk_buff *skb; 419833e882a5SSuraj Sumangala struct bt_skb_cb *scb; 419933e882a5SSuraj Sumangala 420033e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 420133e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 420233e882a5SSuraj Sumangala return -EILSEQ; 420333e882a5SSuraj Sumangala 420433e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 420533e882a5SSuraj Sumangala 420633e882a5SSuraj Sumangala if (!skb) { 420733e882a5SSuraj Sumangala switch (type) { 420833e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 420933e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 421033e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 421133e882a5SSuraj Sumangala break; 421233e882a5SSuraj Sumangala case HCI_EVENT_PKT: 421333e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 421433e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 421533e882a5SSuraj Sumangala break; 421633e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 421733e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 421833e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 421933e882a5SSuraj Sumangala break; 422033e882a5SSuraj Sumangala } 422133e882a5SSuraj Sumangala 42221e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 422333e882a5SSuraj Sumangala if (!skb) 422433e882a5SSuraj Sumangala return -ENOMEM; 422533e882a5SSuraj Sumangala 422633e882a5SSuraj Sumangala scb = (void *) skb->cb; 422733e882a5SSuraj Sumangala scb->expect = hlen; 422833e882a5SSuraj Sumangala scb->pkt_type = type; 422933e882a5SSuraj Sumangala 423033e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 423133e882a5SSuraj Sumangala } 423233e882a5SSuraj Sumangala 423333e882a5SSuraj Sumangala while (count) { 423433e882a5SSuraj Sumangala scb = (void *) skb->cb; 423589bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 423633e882a5SSuraj Sumangala 423733e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 423833e882a5SSuraj Sumangala 423933e882a5SSuraj Sumangala count -= len; 424033e882a5SSuraj Sumangala data += len; 424133e882a5SSuraj Sumangala scb->expect -= len; 424233e882a5SSuraj Sumangala remain = count; 424333e882a5SSuraj Sumangala 424433e882a5SSuraj Sumangala switch (type) { 424533e882a5SSuraj Sumangala case HCI_EVENT_PKT: 424633e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 424733e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 424833e882a5SSuraj Sumangala scb->expect = h->plen; 424933e882a5SSuraj Sumangala 425033e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 425133e882a5SSuraj Sumangala kfree_skb(skb); 425233e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 425333e882a5SSuraj Sumangala return -ENOMEM; 425433e882a5SSuraj Sumangala } 425533e882a5SSuraj Sumangala } 425633e882a5SSuraj Sumangala break; 425733e882a5SSuraj Sumangala 425833e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 425933e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 426033e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 426133e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 426233e882a5SSuraj Sumangala 426333e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 426433e882a5SSuraj Sumangala kfree_skb(skb); 426533e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 426633e882a5SSuraj Sumangala return -ENOMEM; 426733e882a5SSuraj Sumangala } 426833e882a5SSuraj Sumangala } 426933e882a5SSuraj Sumangala break; 427033e882a5SSuraj Sumangala 427133e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 427233e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 427333e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 427433e882a5SSuraj Sumangala scb->expect = h->dlen; 427533e882a5SSuraj Sumangala 427633e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 427733e882a5SSuraj Sumangala kfree_skb(skb); 427833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 427933e882a5SSuraj Sumangala return -ENOMEM; 428033e882a5SSuraj Sumangala } 428133e882a5SSuraj Sumangala } 428233e882a5SSuraj Sumangala break; 428333e882a5SSuraj Sumangala } 428433e882a5SSuraj Sumangala 428533e882a5SSuraj Sumangala if (scb->expect == 0) { 428633e882a5SSuraj Sumangala /* Complete frame */ 428733e882a5SSuraj Sumangala 428833e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 4289e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 429033e882a5SSuraj Sumangala 429133e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 429233e882a5SSuraj Sumangala return remain; 429333e882a5SSuraj Sumangala } 429433e882a5SSuraj Sumangala } 429533e882a5SSuraj Sumangala 429633e882a5SSuraj Sumangala return remain; 429733e882a5SSuraj Sumangala } 429833e882a5SSuraj Sumangala 4299ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 4300ef222013SMarcel Holtmann { 4301f39a3c06SSuraj Sumangala int rem = 0; 4302f39a3c06SSuraj Sumangala 4303ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 4304ef222013SMarcel Holtmann return -EILSEQ; 4305ef222013SMarcel Holtmann 4306da5f6c37SGustavo F. Padovan while (count) { 43071e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, type - 1); 4308f39a3c06SSuraj Sumangala if (rem < 0) 4309f39a3c06SSuraj Sumangala return rem; 4310ef222013SMarcel Holtmann 4311f39a3c06SSuraj Sumangala data += (count - rem); 4312f39a3c06SSuraj Sumangala count = rem; 4313f81c6224SJoe Perches } 4314ef222013SMarcel Holtmann 4315f39a3c06SSuraj Sumangala return rem; 4316ef222013SMarcel Holtmann } 4317ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 4318ef222013SMarcel Holtmann 431999811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 432099811510SSuraj Sumangala 432199811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 432299811510SSuraj Sumangala { 432399811510SSuraj Sumangala int type; 432499811510SSuraj Sumangala int rem = 0; 432599811510SSuraj Sumangala 4326da5f6c37SGustavo F. Padovan while (count) { 432799811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 432899811510SSuraj Sumangala 432999811510SSuraj Sumangala if (!skb) { 433099811510SSuraj Sumangala struct { char type; } *pkt; 433199811510SSuraj Sumangala 433299811510SSuraj Sumangala /* Start of the frame */ 433399811510SSuraj Sumangala pkt = data; 433499811510SSuraj Sumangala type = pkt->type; 433599811510SSuraj Sumangala 433699811510SSuraj Sumangala data++; 433799811510SSuraj Sumangala count--; 433899811510SSuraj Sumangala } else 433999811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 434099811510SSuraj Sumangala 43411e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 43421e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 434399811510SSuraj Sumangala if (rem < 0) 434499811510SSuraj Sumangala return rem; 434599811510SSuraj Sumangala 434699811510SSuraj Sumangala data += (count - rem); 434799811510SSuraj Sumangala count = rem; 4348f81c6224SJoe Perches } 434999811510SSuraj Sumangala 435099811510SSuraj Sumangala return rem; 435199811510SSuraj Sumangala } 435299811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 435399811510SSuraj Sumangala 43541da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 43551da177e4SLinus Torvalds 43561da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 43571da177e4SLinus Torvalds { 43581da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 43591da177e4SLinus Torvalds 4360f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 43611da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 4362f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 43631da177e4SLinus Torvalds 43641da177e4SLinus Torvalds return 0; 43651da177e4SLinus Torvalds } 43661da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 43671da177e4SLinus Torvalds 43681da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 43691da177e4SLinus Torvalds { 43701da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 43711da177e4SLinus Torvalds 4372f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 43731da177e4SLinus Torvalds list_del(&cb->list); 4374f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 43751da177e4SLinus Torvalds 43761da177e4SLinus Torvalds return 0; 43771da177e4SLinus Torvalds } 43781da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 43791da177e4SLinus Torvalds 438051086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 43811da177e4SLinus Torvalds { 4382cdc52faaSMarcel Holtmann int err; 4383cdc52faaSMarcel Holtmann 43840d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 43851da177e4SLinus Torvalds 43861da177e4SLinus Torvalds /* Time stamp */ 4387a61bbcf2SPatrick McHardy __net_timestamp(skb); 43881da177e4SLinus Torvalds 4389cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4390cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4391cd82e61cSMarcel Holtmann 4392cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 4393cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 4394470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 43951da177e4SLinus Torvalds } 43961da177e4SLinus Torvalds 43971da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 43981da177e4SLinus Torvalds skb_orphan(skb); 43991da177e4SLinus Torvalds 4400cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 4401cdc52faaSMarcel Holtmann if (err < 0) { 4402cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 4403cdc52faaSMarcel Holtmann kfree_skb(skb); 4404cdc52faaSMarcel Holtmann } 44051da177e4SLinus Torvalds } 44061da177e4SLinus Torvalds 44073119ae95SJohan Hedberg void hci_req_init(struct hci_request *req, struct hci_dev *hdev) 44083119ae95SJohan Hedberg { 44093119ae95SJohan Hedberg skb_queue_head_init(&req->cmd_q); 44103119ae95SJohan Hedberg req->hdev = hdev; 44115d73e034SAndre Guedes req->err = 0; 44123119ae95SJohan Hedberg } 44133119ae95SJohan Hedberg 44143119ae95SJohan Hedberg int hci_req_run(struct hci_request *req, hci_req_complete_t complete) 44153119ae95SJohan Hedberg { 44163119ae95SJohan Hedberg struct hci_dev *hdev = req->hdev; 44173119ae95SJohan Hedberg struct sk_buff *skb; 44183119ae95SJohan Hedberg unsigned long flags; 44193119ae95SJohan Hedberg 44203119ae95SJohan Hedberg BT_DBG("length %u", skb_queue_len(&req->cmd_q)); 44213119ae95SJohan Hedberg 44225d73e034SAndre Guedes /* If an error occured during request building, remove all HCI 44235d73e034SAndre Guedes * commands queued on the HCI request queue. 44245d73e034SAndre Guedes */ 44255d73e034SAndre Guedes if (req->err) { 44265d73e034SAndre Guedes skb_queue_purge(&req->cmd_q); 44275d73e034SAndre Guedes return req->err; 44285d73e034SAndre Guedes } 44295d73e034SAndre Guedes 44303119ae95SJohan Hedberg /* Do not allow empty requests */ 44313119ae95SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 4432382b0c39SAndre Guedes return -ENODATA; 44333119ae95SJohan Hedberg 44343119ae95SJohan Hedberg skb = skb_peek_tail(&req->cmd_q); 44353119ae95SJohan Hedberg bt_cb(skb)->req.complete = complete; 44363119ae95SJohan Hedberg 44373119ae95SJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 44383119ae95SJohan Hedberg skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q); 44393119ae95SJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 44403119ae95SJohan Hedberg 44413119ae95SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 44423119ae95SJohan Hedberg 44433119ae95SJohan Hedberg return 0; 44443119ae95SJohan Hedberg } 44453119ae95SJohan Hedberg 4446899de765SMarcel Holtmann bool hci_req_pending(struct hci_dev *hdev) 4447899de765SMarcel Holtmann { 4448899de765SMarcel Holtmann return (hdev->req_status == HCI_REQ_PEND); 4449899de765SMarcel Holtmann } 4450899de765SMarcel Holtmann 44511ca3a9d0SJohan Hedberg static struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, 445207dc93ddSJohan Hedberg u32 plen, const void *param) 44531da177e4SLinus Torvalds { 44541da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 44551da177e4SLinus Torvalds struct hci_command_hdr *hdr; 44561da177e4SLinus Torvalds struct sk_buff *skb; 44571da177e4SLinus Torvalds 44581da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 44591ca3a9d0SJohan Hedberg if (!skb) 44601ca3a9d0SJohan Hedberg return NULL; 44611da177e4SLinus Torvalds 44621da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 4463a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 44641da177e4SLinus Torvalds hdr->plen = plen; 44651da177e4SLinus Torvalds 44661da177e4SLinus Torvalds if (plen) 44671da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 44681da177e4SLinus Torvalds 44691da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 44701da177e4SLinus Torvalds 44710d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 4472c78ae283SMarcel Holtmann 44731ca3a9d0SJohan Hedberg return skb; 44741ca3a9d0SJohan Hedberg } 44751ca3a9d0SJohan Hedberg 44761ca3a9d0SJohan Hedberg /* Send HCI command */ 447707dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 447807dc93ddSJohan Hedberg const void *param) 44791ca3a9d0SJohan Hedberg { 44801ca3a9d0SJohan Hedberg struct sk_buff *skb; 44811ca3a9d0SJohan Hedberg 44821ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 44831ca3a9d0SJohan Hedberg 44841ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 44851ca3a9d0SJohan Hedberg if (!skb) { 44861ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 44871ca3a9d0SJohan Hedberg return -ENOMEM; 44881ca3a9d0SJohan Hedberg } 44891ca3a9d0SJohan Hedberg 449011714b3dSJohan Hedberg /* Stand-alone HCI commands must be flaged as 449111714b3dSJohan Hedberg * single-command requests. 449211714b3dSJohan Hedberg */ 449311714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 449411714b3dSJohan Hedberg 44951da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 4496c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 44971da177e4SLinus Torvalds 44981da177e4SLinus Torvalds return 0; 44991da177e4SLinus Torvalds } 45001da177e4SLinus Torvalds 450171c76a17SJohan Hedberg /* Queue a command to an asynchronous HCI request */ 450207dc93ddSJohan Hedberg void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen, 450307dc93ddSJohan Hedberg const void *param, u8 event) 450471c76a17SJohan Hedberg { 450571c76a17SJohan Hedberg struct hci_dev *hdev = req->hdev; 450671c76a17SJohan Hedberg struct sk_buff *skb; 450771c76a17SJohan Hedberg 450871c76a17SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 450971c76a17SJohan Hedberg 451034739c1eSAndre Guedes /* If an error occured during request building, there is no point in 451134739c1eSAndre Guedes * queueing the HCI command. We can simply return. 451234739c1eSAndre Guedes */ 451334739c1eSAndre Guedes if (req->err) 451434739c1eSAndre Guedes return; 451534739c1eSAndre Guedes 451671c76a17SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 451771c76a17SJohan Hedberg if (!skb) { 45185d73e034SAndre Guedes BT_ERR("%s no memory for command (opcode 0x%4.4x)", 45195d73e034SAndre Guedes hdev->name, opcode); 45205d73e034SAndre Guedes req->err = -ENOMEM; 4521e348fe6bSAndre Guedes return; 452271c76a17SJohan Hedberg } 452371c76a17SJohan Hedberg 452471c76a17SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 452571c76a17SJohan Hedberg bt_cb(skb)->req.start = true; 452671c76a17SJohan Hedberg 452702350a72SJohan Hedberg bt_cb(skb)->req.event = event; 452802350a72SJohan Hedberg 452971c76a17SJohan Hedberg skb_queue_tail(&req->cmd_q, skb); 453071c76a17SJohan Hedberg } 453171c76a17SJohan Hedberg 453207dc93ddSJohan Hedberg void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, 453307dc93ddSJohan Hedberg const void *param) 453402350a72SJohan Hedberg { 453502350a72SJohan Hedberg hci_req_add_ev(req, opcode, plen, param, 0); 453602350a72SJohan Hedberg } 453702350a72SJohan Hedberg 45381da177e4SLinus Torvalds /* Get data from the previously sent command */ 4539a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 45401da177e4SLinus Torvalds { 45411da177e4SLinus Torvalds struct hci_command_hdr *hdr; 45421da177e4SLinus Torvalds 45431da177e4SLinus Torvalds if (!hdev->sent_cmd) 45441da177e4SLinus Torvalds return NULL; 45451da177e4SLinus Torvalds 45461da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 45471da177e4SLinus Torvalds 4548a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 45491da177e4SLinus Torvalds return NULL; 45501da177e4SLinus Torvalds 4551f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 45521da177e4SLinus Torvalds 45531da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 45541da177e4SLinus Torvalds } 45551da177e4SLinus Torvalds 45561da177e4SLinus Torvalds /* Send ACL data */ 45571da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 45581da177e4SLinus Torvalds { 45591da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 45601da177e4SLinus Torvalds int len = skb->len; 45611da177e4SLinus Torvalds 4562badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 4563badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 45649c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 4565aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 4566aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 45671da177e4SLinus Torvalds } 45681da177e4SLinus Torvalds 4569ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 457073d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 45711da177e4SLinus Torvalds { 4572ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 45731da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 45741da177e4SLinus Torvalds struct sk_buff *list; 45751da177e4SLinus Torvalds 4576087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 4577087bfd99SGustavo Padovan skb->data_len = 0; 4578087bfd99SGustavo Padovan 4579087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4580204a6e54SAndrei Emeltchenko 4581204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 4582204a6e54SAndrei Emeltchenko case HCI_BREDR: 4583087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 4584204a6e54SAndrei Emeltchenko break; 4585204a6e54SAndrei Emeltchenko case HCI_AMP: 4586204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 4587204a6e54SAndrei Emeltchenko break; 4588204a6e54SAndrei Emeltchenko default: 4589204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 4590204a6e54SAndrei Emeltchenko return; 4591204a6e54SAndrei Emeltchenko } 4592087bfd99SGustavo Padovan 459370f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 459470f23020SAndrei Emeltchenko if (!list) { 45951da177e4SLinus Torvalds /* Non fragmented */ 45961da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 45971da177e4SLinus Torvalds 459873d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 45991da177e4SLinus Torvalds } else { 46001da177e4SLinus Torvalds /* Fragmented */ 46011da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 46021da177e4SLinus Torvalds 46031da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 46041da177e4SLinus Torvalds 46051da177e4SLinus Torvalds /* Queue all fragments atomically */ 4606af3e6359SGustavo F. Padovan spin_lock(&queue->lock); 46071da177e4SLinus Torvalds 460873d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 4609e702112fSAndrei Emeltchenko 4610e702112fSAndrei Emeltchenko flags &= ~ACL_START; 4611e702112fSAndrei Emeltchenko flags |= ACL_CONT; 46121da177e4SLinus Torvalds do { 46131da177e4SLinus Torvalds skb = list; list = list->next; 46141da177e4SLinus Torvalds 46150d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4616e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 46171da177e4SLinus Torvalds 46181da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 46191da177e4SLinus Torvalds 462073d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 46211da177e4SLinus Torvalds } while (list); 46221da177e4SLinus Torvalds 4623af3e6359SGustavo F. Padovan spin_unlock(&queue->lock); 46241da177e4SLinus Torvalds } 462573d80debSLuiz Augusto von Dentz } 462673d80debSLuiz Augusto von Dentz 462773d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 462873d80debSLuiz Augusto von Dentz { 4629ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 463073d80debSLuiz Augusto von Dentz 4631f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 463273d80debSLuiz Augusto von Dentz 4633ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 46341da177e4SLinus Torvalds 46353eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 46361da177e4SLinus Torvalds } 46371da177e4SLinus Torvalds 46381da177e4SLinus Torvalds /* Send SCO data */ 46390d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 46401da177e4SLinus Torvalds { 46411da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 46421da177e4SLinus Torvalds struct hci_sco_hdr hdr; 46431da177e4SLinus Torvalds 46441da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 46451da177e4SLinus Torvalds 4646aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 46471da177e4SLinus Torvalds hdr.dlen = skb->len; 46481da177e4SLinus Torvalds 4649badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 4650badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 46519c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 46521da177e4SLinus Torvalds 46530d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 4654c78ae283SMarcel Holtmann 46551da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 46563eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 46571da177e4SLinus Torvalds } 46581da177e4SLinus Torvalds 46591da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 46601da177e4SLinus Torvalds 46611da177e4SLinus Torvalds /* HCI Connection scheduler */ 46626039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 4663a8c5fb1aSGustavo Padovan int *quote) 46641da177e4SLinus Torvalds { 46651da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 46668035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 4667abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 46681da177e4SLinus Torvalds 46691da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 46701da177e4SLinus Torvalds * added and removed with TX task disabled. */ 4671bf4c6325SGustavo F. Padovan 4672bf4c6325SGustavo F. Padovan rcu_read_lock(); 4673bf4c6325SGustavo F. Padovan 4674bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4675769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 46761da177e4SLinus Torvalds continue; 4677769be974SMarcel Holtmann 4678769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 4679769be974SMarcel Holtmann continue; 4680769be974SMarcel Holtmann 46811da177e4SLinus Torvalds num++; 46821da177e4SLinus Torvalds 46831da177e4SLinus Torvalds if (c->sent < min) { 46841da177e4SLinus Torvalds min = c->sent; 46851da177e4SLinus Torvalds conn = c; 46861da177e4SLinus Torvalds } 468752087a79SLuiz Augusto von Dentz 468852087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 468952087a79SLuiz Augusto von Dentz break; 46901da177e4SLinus Torvalds } 46911da177e4SLinus Torvalds 4692bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4693bf4c6325SGustavo F. Padovan 46941da177e4SLinus Torvalds if (conn) { 46956ed58ec5SVille Tervo int cnt, q; 46966ed58ec5SVille Tervo 46976ed58ec5SVille Tervo switch (conn->type) { 46986ed58ec5SVille Tervo case ACL_LINK: 46996ed58ec5SVille Tervo cnt = hdev->acl_cnt; 47006ed58ec5SVille Tervo break; 47016ed58ec5SVille Tervo case SCO_LINK: 47026ed58ec5SVille Tervo case ESCO_LINK: 47036ed58ec5SVille Tervo cnt = hdev->sco_cnt; 47046ed58ec5SVille Tervo break; 47056ed58ec5SVille Tervo case LE_LINK: 47066ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 47076ed58ec5SVille Tervo break; 47086ed58ec5SVille Tervo default: 47096ed58ec5SVille Tervo cnt = 0; 47106ed58ec5SVille Tervo BT_ERR("Unknown link type"); 47116ed58ec5SVille Tervo } 47126ed58ec5SVille Tervo 47136ed58ec5SVille Tervo q = cnt / num; 47141da177e4SLinus Torvalds *quote = q ? q : 1; 47151da177e4SLinus Torvalds } else 47161da177e4SLinus Torvalds *quote = 0; 47171da177e4SLinus Torvalds 47181da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 47191da177e4SLinus Torvalds return conn; 47201da177e4SLinus Torvalds } 47211da177e4SLinus Torvalds 47226039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 47231da177e4SLinus Torvalds { 47241da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 47251da177e4SLinus Torvalds struct hci_conn *c; 47261da177e4SLinus Torvalds 4727bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 47281da177e4SLinus Torvalds 4729bf4c6325SGustavo F. Padovan rcu_read_lock(); 4730bf4c6325SGustavo F. Padovan 47311da177e4SLinus Torvalds /* Kill stalled connections */ 4732bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4733bae1f5d9SVille Tervo if (c->type == type && c->sent) { 47346ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 47356ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 4736bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 47371da177e4SLinus Torvalds } 47381da177e4SLinus Torvalds } 4739bf4c6325SGustavo F. Padovan 4740bf4c6325SGustavo F. Padovan rcu_read_unlock(); 47411da177e4SLinus Torvalds } 47421da177e4SLinus Torvalds 47436039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 474473d80debSLuiz Augusto von Dentz int *quote) 474573d80debSLuiz Augusto von Dentz { 474673d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 474773d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 4748abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 474973d80debSLuiz Augusto von Dentz struct hci_conn *conn; 475073d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 475173d80debSLuiz Augusto von Dentz 475273d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 475373d80debSLuiz Augusto von Dentz 4754bf4c6325SGustavo F. Padovan rcu_read_lock(); 4755bf4c6325SGustavo F. Padovan 4756bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 475773d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 475873d80debSLuiz Augusto von Dentz 475973d80debSLuiz Augusto von Dentz if (conn->type != type) 476073d80debSLuiz Augusto von Dentz continue; 476173d80debSLuiz Augusto von Dentz 476273d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 476373d80debSLuiz Augusto von Dentz continue; 476473d80debSLuiz Augusto von Dentz 476573d80debSLuiz Augusto von Dentz conn_num++; 476673d80debSLuiz Augusto von Dentz 47678192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 476873d80debSLuiz Augusto von Dentz struct sk_buff *skb; 476973d80debSLuiz Augusto von Dentz 477073d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 477173d80debSLuiz Augusto von Dentz continue; 477273d80debSLuiz Augusto von Dentz 477373d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 477473d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 477573d80debSLuiz Augusto von Dentz continue; 477673d80debSLuiz Augusto von Dentz 477773d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 477873d80debSLuiz Augusto von Dentz num = 0; 477973d80debSLuiz Augusto von Dentz min = ~0; 478073d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 478173d80debSLuiz Augusto von Dentz } 478273d80debSLuiz Augusto von Dentz 478373d80debSLuiz Augusto von Dentz num++; 478473d80debSLuiz Augusto von Dentz 478573d80debSLuiz Augusto von Dentz if (conn->sent < min) { 478673d80debSLuiz Augusto von Dentz min = conn->sent; 478773d80debSLuiz Augusto von Dentz chan = tmp; 478873d80debSLuiz Augusto von Dentz } 478973d80debSLuiz Augusto von Dentz } 479073d80debSLuiz Augusto von Dentz 479173d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 479273d80debSLuiz Augusto von Dentz break; 479373d80debSLuiz Augusto von Dentz } 479473d80debSLuiz Augusto von Dentz 4795bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4796bf4c6325SGustavo F. Padovan 479773d80debSLuiz Augusto von Dentz if (!chan) 479873d80debSLuiz Augusto von Dentz return NULL; 479973d80debSLuiz Augusto von Dentz 480073d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 480173d80debSLuiz Augusto von Dentz case ACL_LINK: 480273d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 480373d80debSLuiz Augusto von Dentz break; 4804bd1eb66bSAndrei Emeltchenko case AMP_LINK: 4805bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 4806bd1eb66bSAndrei Emeltchenko break; 480773d80debSLuiz Augusto von Dentz case SCO_LINK: 480873d80debSLuiz Augusto von Dentz case ESCO_LINK: 480973d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 481073d80debSLuiz Augusto von Dentz break; 481173d80debSLuiz Augusto von Dentz case LE_LINK: 481273d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 481373d80debSLuiz Augusto von Dentz break; 481473d80debSLuiz Augusto von Dentz default: 481573d80debSLuiz Augusto von Dentz cnt = 0; 481673d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 481773d80debSLuiz Augusto von Dentz } 481873d80debSLuiz Augusto von Dentz 481973d80debSLuiz Augusto von Dentz q = cnt / num; 482073d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 482173d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 482273d80debSLuiz Augusto von Dentz return chan; 482373d80debSLuiz Augusto von Dentz } 482473d80debSLuiz Augusto von Dentz 482502b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 482602b20f0bSLuiz Augusto von Dentz { 482702b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 482802b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 482902b20f0bSLuiz Augusto von Dentz int num = 0; 483002b20f0bSLuiz Augusto von Dentz 483102b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 483202b20f0bSLuiz Augusto von Dentz 4833bf4c6325SGustavo F. Padovan rcu_read_lock(); 4834bf4c6325SGustavo F. Padovan 4835bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 483602b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 483702b20f0bSLuiz Augusto von Dentz 483802b20f0bSLuiz Augusto von Dentz if (conn->type != type) 483902b20f0bSLuiz Augusto von Dentz continue; 484002b20f0bSLuiz Augusto von Dentz 484102b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 484202b20f0bSLuiz Augusto von Dentz continue; 484302b20f0bSLuiz Augusto von Dentz 484402b20f0bSLuiz Augusto von Dentz num++; 484502b20f0bSLuiz Augusto von Dentz 48468192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 484702b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 484802b20f0bSLuiz Augusto von Dentz 484902b20f0bSLuiz Augusto von Dentz if (chan->sent) { 485002b20f0bSLuiz Augusto von Dentz chan->sent = 0; 485102b20f0bSLuiz Augusto von Dentz continue; 485202b20f0bSLuiz Augusto von Dentz } 485302b20f0bSLuiz Augusto von Dentz 485402b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 485502b20f0bSLuiz Augusto von Dentz continue; 485602b20f0bSLuiz Augusto von Dentz 485702b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 485802b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 485902b20f0bSLuiz Augusto von Dentz continue; 486002b20f0bSLuiz Augusto von Dentz 486102b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 486202b20f0bSLuiz Augusto von Dentz 486302b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 486402b20f0bSLuiz Augusto von Dentz skb->priority); 486502b20f0bSLuiz Augusto von Dentz } 486602b20f0bSLuiz Augusto von Dentz 486702b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 486802b20f0bSLuiz Augusto von Dentz break; 486902b20f0bSLuiz Augusto von Dentz } 4870bf4c6325SGustavo F. Padovan 4871bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4872bf4c6325SGustavo F. Padovan 487302b20f0bSLuiz Augusto von Dentz } 487402b20f0bSLuiz Augusto von Dentz 4875b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 4876b71d385aSAndrei Emeltchenko { 4877b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 4878b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 4879b71d385aSAndrei Emeltchenko } 4880b71d385aSAndrei Emeltchenko 48816039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 48821da177e4SLinus Torvalds { 48834a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 48841da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 48851da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 488663d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 48875f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 4888bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 48891da177e4SLinus Torvalds } 489063d2bc1bSAndrei Emeltchenko } 48911da177e4SLinus Torvalds 48926039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 489363d2bc1bSAndrei Emeltchenko { 489463d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 489563d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 489663d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 489763d2bc1bSAndrei Emeltchenko int quote; 489863d2bc1bSAndrei Emeltchenko 489963d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 490004837f64SMarcel Holtmann 490173d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 490273d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 4903ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4904ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 490573d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 490673d80debSLuiz Augusto von Dentz skb->len, skb->priority); 490773d80debSLuiz Augusto von Dentz 4908ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4909ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4910ec1cce24SLuiz Augusto von Dentz break; 4911ec1cce24SLuiz Augusto von Dentz 4912ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4913ec1cce24SLuiz Augusto von Dentz 491473d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 491573d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 491604837f64SMarcel Holtmann 491757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 49181da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 49191da177e4SLinus Torvalds 49201da177e4SLinus Torvalds hdev->acl_cnt--; 492173d80debSLuiz Augusto von Dentz chan->sent++; 492273d80debSLuiz Augusto von Dentz chan->conn->sent++; 49231da177e4SLinus Torvalds } 49241da177e4SLinus Torvalds } 492502b20f0bSLuiz Augusto von Dentz 492602b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 492702b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 49281da177e4SLinus Torvalds } 49291da177e4SLinus Torvalds 49306039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 4931b71d385aSAndrei Emeltchenko { 493263d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 4933b71d385aSAndrei Emeltchenko struct hci_chan *chan; 4934b71d385aSAndrei Emeltchenko struct sk_buff *skb; 4935b71d385aSAndrei Emeltchenko int quote; 4936bd1eb66bSAndrei Emeltchenko u8 type; 4937b71d385aSAndrei Emeltchenko 493863d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 4939b71d385aSAndrei Emeltchenko 4940bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4941bd1eb66bSAndrei Emeltchenko 4942bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 4943bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 4944bd1eb66bSAndrei Emeltchenko else 4945bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 4946bd1eb66bSAndrei Emeltchenko 4947b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 4948bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 4949b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 4950b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 4951b71d385aSAndrei Emeltchenko int blocks; 4952b71d385aSAndrei Emeltchenko 4953b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 4954b71d385aSAndrei Emeltchenko skb->len, skb->priority); 4955b71d385aSAndrei Emeltchenko 4956b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 4957b71d385aSAndrei Emeltchenko if (skb->priority < priority) 4958b71d385aSAndrei Emeltchenko break; 4959b71d385aSAndrei Emeltchenko 4960b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 4961b71d385aSAndrei Emeltchenko 4962b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 4963b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 4964b71d385aSAndrei Emeltchenko return; 4965b71d385aSAndrei Emeltchenko 4966b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 4967b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 4968b71d385aSAndrei Emeltchenko 496957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4970b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 4971b71d385aSAndrei Emeltchenko 4972b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 4973b71d385aSAndrei Emeltchenko quote -= blocks; 4974b71d385aSAndrei Emeltchenko 4975b71d385aSAndrei Emeltchenko chan->sent += blocks; 4976b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 4977b71d385aSAndrei Emeltchenko } 4978b71d385aSAndrei Emeltchenko } 4979b71d385aSAndrei Emeltchenko 4980b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 4981bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 4982b71d385aSAndrei Emeltchenko } 4983b71d385aSAndrei Emeltchenko 49846039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 4985b71d385aSAndrei Emeltchenko { 4986b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4987b71d385aSAndrei Emeltchenko 4988bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 4989bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 4990bd1eb66bSAndrei Emeltchenko return; 4991bd1eb66bSAndrei Emeltchenko 4992bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 4993bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 4994b71d385aSAndrei Emeltchenko return; 4995b71d385aSAndrei Emeltchenko 4996b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 4997b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 4998b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 4999b71d385aSAndrei Emeltchenko break; 5000b71d385aSAndrei Emeltchenko 5001b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 5002b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 5003b71d385aSAndrei Emeltchenko break; 5004b71d385aSAndrei Emeltchenko } 5005b71d385aSAndrei Emeltchenko } 5006b71d385aSAndrei Emeltchenko 50071da177e4SLinus Torvalds /* Schedule SCO */ 50086039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 50091da177e4SLinus Torvalds { 50101da177e4SLinus Torvalds struct hci_conn *conn; 50111da177e4SLinus Torvalds struct sk_buff *skb; 50121da177e4SLinus Torvalds int quote; 50131da177e4SLinus Torvalds 50141da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 50151da177e4SLinus Torvalds 501652087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 501752087a79SLuiz Augusto von Dentz return; 501852087a79SLuiz Augusto von Dentz 50191da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 50201da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 50211da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 502257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 50231da177e4SLinus Torvalds 50241da177e4SLinus Torvalds conn->sent++; 50251da177e4SLinus Torvalds if (conn->sent == ~0) 50261da177e4SLinus Torvalds conn->sent = 0; 50271da177e4SLinus Torvalds } 50281da177e4SLinus Torvalds } 50291da177e4SLinus Torvalds } 50301da177e4SLinus Torvalds 50316039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 5032b6a0dc82SMarcel Holtmann { 5033b6a0dc82SMarcel Holtmann struct hci_conn *conn; 5034b6a0dc82SMarcel Holtmann struct sk_buff *skb; 5035b6a0dc82SMarcel Holtmann int quote; 5036b6a0dc82SMarcel Holtmann 5037b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 5038b6a0dc82SMarcel Holtmann 503952087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 504052087a79SLuiz Augusto von Dentz return; 504152087a79SLuiz Augusto von Dentz 50428fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 50438fc9ced3SGustavo Padovan "e))) { 5044b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 5045b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 504657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 5047b6a0dc82SMarcel Holtmann 5048b6a0dc82SMarcel Holtmann conn->sent++; 5049b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 5050b6a0dc82SMarcel Holtmann conn->sent = 0; 5051b6a0dc82SMarcel Holtmann } 5052b6a0dc82SMarcel Holtmann } 5053b6a0dc82SMarcel Holtmann } 5054b6a0dc82SMarcel Holtmann 50556039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 50566ed58ec5SVille Tervo { 505773d80debSLuiz Augusto von Dentz struct hci_chan *chan; 50586ed58ec5SVille Tervo struct sk_buff *skb; 505902b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 50606ed58ec5SVille Tervo 50616ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 50626ed58ec5SVille Tervo 506352087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 506452087a79SLuiz Augusto von Dentz return; 506552087a79SLuiz Augusto von Dentz 50664a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 50676ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 50686ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 5069bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 50706ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 5071bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 50726ed58ec5SVille Tervo } 50736ed58ec5SVille Tervo 50746ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 507502b20f0bSLuiz Augusto von Dentz tmp = cnt; 507673d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 5077ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 5078ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 507973d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 508073d80debSLuiz Augusto von Dentz skb->len, skb->priority); 50816ed58ec5SVille Tervo 5082ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 5083ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 5084ec1cce24SLuiz Augusto von Dentz break; 5085ec1cce24SLuiz Augusto von Dentz 5086ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 5087ec1cce24SLuiz Augusto von Dentz 508857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 50896ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 50906ed58ec5SVille Tervo 50916ed58ec5SVille Tervo cnt--; 509273d80debSLuiz Augusto von Dentz chan->sent++; 509373d80debSLuiz Augusto von Dentz chan->conn->sent++; 50946ed58ec5SVille Tervo } 50956ed58ec5SVille Tervo } 509673d80debSLuiz Augusto von Dentz 50976ed58ec5SVille Tervo if (hdev->le_pkts) 50986ed58ec5SVille Tervo hdev->le_cnt = cnt; 50996ed58ec5SVille Tervo else 51006ed58ec5SVille Tervo hdev->acl_cnt = cnt; 510102b20f0bSLuiz Augusto von Dentz 510202b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 510302b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 51046ed58ec5SVille Tervo } 51056ed58ec5SVille Tervo 51063eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 51071da177e4SLinus Torvalds { 51083eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 51091da177e4SLinus Torvalds struct sk_buff *skb; 51101da177e4SLinus Torvalds 51116ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 51126ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 51131da177e4SLinus Torvalds 511452de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 51151da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 51161da177e4SLinus Torvalds hci_sched_acl(hdev); 51171da177e4SLinus Torvalds hci_sched_sco(hdev); 5118b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 51196ed58ec5SVille Tervo hci_sched_le(hdev); 512052de599eSMarcel Holtmann } 51216ed58ec5SVille Tervo 51221da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 51231da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 512457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 51251da177e4SLinus Torvalds } 51261da177e4SLinus Torvalds 512725985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 51281da177e4SLinus Torvalds 51291da177e4SLinus Torvalds /* ACL data packet */ 51306039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 51311da177e4SLinus Torvalds { 51321da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 51331da177e4SLinus Torvalds struct hci_conn *conn; 51341da177e4SLinus Torvalds __u16 handle, flags; 51351da177e4SLinus Torvalds 51361da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 51371da177e4SLinus Torvalds 51381da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 51391da177e4SLinus Torvalds flags = hci_flags(handle); 51401da177e4SLinus Torvalds handle = hci_handle(handle); 51411da177e4SLinus Torvalds 5142f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 5143a8c5fb1aSGustavo Padovan handle, flags); 51441da177e4SLinus Torvalds 51451da177e4SLinus Torvalds hdev->stat.acl_rx++; 51461da177e4SLinus Torvalds 51471da177e4SLinus Torvalds hci_dev_lock(hdev); 51481da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 51491da177e4SLinus Torvalds hci_dev_unlock(hdev); 51501da177e4SLinus Torvalds 51511da177e4SLinus Torvalds if (conn) { 515265983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 515304837f64SMarcel Holtmann 51541da177e4SLinus Torvalds /* Send to upper protocol */ 5155686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 51561da177e4SLinus Torvalds return; 51571da177e4SLinus Torvalds } else { 51581da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 51591da177e4SLinus Torvalds hdev->name, handle); 51601da177e4SLinus Torvalds } 51611da177e4SLinus Torvalds 51621da177e4SLinus Torvalds kfree_skb(skb); 51631da177e4SLinus Torvalds } 51641da177e4SLinus Torvalds 51651da177e4SLinus Torvalds /* SCO data packet */ 51666039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 51671da177e4SLinus Torvalds { 51681da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 51691da177e4SLinus Torvalds struct hci_conn *conn; 51701da177e4SLinus Torvalds __u16 handle; 51711da177e4SLinus Torvalds 51721da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 51731da177e4SLinus Torvalds 51741da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 51751da177e4SLinus Torvalds 5176f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 51771da177e4SLinus Torvalds 51781da177e4SLinus Torvalds hdev->stat.sco_rx++; 51791da177e4SLinus Torvalds 51801da177e4SLinus Torvalds hci_dev_lock(hdev); 51811da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 51821da177e4SLinus Torvalds hci_dev_unlock(hdev); 51831da177e4SLinus Torvalds 51841da177e4SLinus Torvalds if (conn) { 51851da177e4SLinus Torvalds /* Send to upper protocol */ 5186686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 51871da177e4SLinus Torvalds return; 51881da177e4SLinus Torvalds } else { 51891da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 51901da177e4SLinus Torvalds hdev->name, handle); 51911da177e4SLinus Torvalds } 51921da177e4SLinus Torvalds 51931da177e4SLinus Torvalds kfree_skb(skb); 51941da177e4SLinus Torvalds } 51951da177e4SLinus Torvalds 51969238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 51979238f36aSJohan Hedberg { 51989238f36aSJohan Hedberg struct sk_buff *skb; 51999238f36aSJohan Hedberg 52009238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 52019238f36aSJohan Hedberg if (!skb) 52029238f36aSJohan Hedberg return true; 52039238f36aSJohan Hedberg 52049238f36aSJohan Hedberg return bt_cb(skb)->req.start; 52059238f36aSJohan Hedberg } 52069238f36aSJohan Hedberg 520742c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 520842c6b129SJohan Hedberg { 520942c6b129SJohan Hedberg struct hci_command_hdr *sent; 521042c6b129SJohan Hedberg struct sk_buff *skb; 521142c6b129SJohan Hedberg u16 opcode; 521242c6b129SJohan Hedberg 521342c6b129SJohan Hedberg if (!hdev->sent_cmd) 521442c6b129SJohan Hedberg return; 521542c6b129SJohan Hedberg 521642c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 521742c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 521842c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 521942c6b129SJohan Hedberg return; 522042c6b129SJohan Hedberg 522142c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 522242c6b129SJohan Hedberg if (!skb) 522342c6b129SJohan Hedberg return; 522442c6b129SJohan Hedberg 522542c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 522642c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 522742c6b129SJohan Hedberg } 522842c6b129SJohan Hedberg 52299238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 52309238f36aSJohan Hedberg { 52319238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 52329238f36aSJohan Hedberg struct sk_buff *skb; 52339238f36aSJohan Hedberg unsigned long flags; 52349238f36aSJohan Hedberg 52359238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 52369238f36aSJohan Hedberg 523742c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 523842c6b129SJohan Hedberg * sent we need to do special handling of it. 52399238f36aSJohan Hedberg */ 524042c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 524142c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 524242c6b129SJohan Hedberg * reset complete event during init and any pending 524342c6b129SJohan Hedberg * command will never be completed. In such a case we 524442c6b129SJohan Hedberg * need to resend whatever was the last sent 524542c6b129SJohan Hedberg * command. 524642c6b129SJohan Hedberg */ 524742c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 524842c6b129SJohan Hedberg hci_resend_last(hdev); 524942c6b129SJohan Hedberg 52509238f36aSJohan Hedberg return; 525142c6b129SJohan Hedberg } 52529238f36aSJohan Hedberg 52539238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 52549238f36aSJohan Hedberg * this request the request is not yet complete. 52559238f36aSJohan Hedberg */ 52569238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 52579238f36aSJohan Hedberg return; 52589238f36aSJohan Hedberg 52599238f36aSJohan Hedberg /* If this was the last command in a request the complete 52609238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 52619238f36aSJohan Hedberg * command queue (hdev->cmd_q). 52629238f36aSJohan Hedberg */ 52639238f36aSJohan Hedberg if (hdev->sent_cmd) { 52649238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 526553e21fbcSJohan Hedberg 526653e21fbcSJohan Hedberg if (req_complete) { 526753e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 526853e21fbcSJohan Hedberg * avoid calling the callback more than once if 526953e21fbcSJohan Hedberg * this function gets called again. 527053e21fbcSJohan Hedberg */ 527153e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 527253e21fbcSJohan Hedberg 52739238f36aSJohan Hedberg goto call_complete; 52749238f36aSJohan Hedberg } 527553e21fbcSJohan Hedberg } 52769238f36aSJohan Hedberg 52779238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 52789238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 52799238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 52809238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 52819238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 52829238f36aSJohan Hedberg break; 52839238f36aSJohan Hedberg } 52849238f36aSJohan Hedberg 52859238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 52869238f36aSJohan Hedberg kfree_skb(skb); 52879238f36aSJohan Hedberg } 52889238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 52899238f36aSJohan Hedberg 52909238f36aSJohan Hedberg call_complete: 52919238f36aSJohan Hedberg if (req_complete) 52929238f36aSJohan Hedberg req_complete(hdev, status); 52939238f36aSJohan Hedberg } 52949238f36aSJohan Hedberg 5295b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 52961da177e4SLinus Torvalds { 5297b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 52981da177e4SLinus Torvalds struct sk_buff *skb; 52991da177e4SLinus Torvalds 53001da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 53011da177e4SLinus Torvalds 53021da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 5303cd82e61cSMarcel Holtmann /* Send copy to monitor */ 5304cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 5305cd82e61cSMarcel Holtmann 53061da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 53071da177e4SLinus Torvalds /* Send copy to the sockets */ 5308470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 53091da177e4SLinus Torvalds } 53101da177e4SLinus Torvalds 5311fee746b0SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 53121da177e4SLinus Torvalds kfree_skb(skb); 53131da177e4SLinus Torvalds continue; 53141da177e4SLinus Torvalds } 53151da177e4SLinus Torvalds 53161da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 53171da177e4SLinus Torvalds /* Don't process data packets in this states. */ 53180d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 53191da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 53201da177e4SLinus Torvalds case HCI_SCODATA_PKT: 53211da177e4SLinus Torvalds kfree_skb(skb); 53221da177e4SLinus Torvalds continue; 53233ff50b79SStephen Hemminger } 53241da177e4SLinus Torvalds } 53251da177e4SLinus Torvalds 53261da177e4SLinus Torvalds /* Process frame */ 53270d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 53281da177e4SLinus Torvalds case HCI_EVENT_PKT: 5329b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 53301da177e4SLinus Torvalds hci_event_packet(hdev, skb); 53311da177e4SLinus Torvalds break; 53321da177e4SLinus Torvalds 53331da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 53341da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 53351da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 53361da177e4SLinus Torvalds break; 53371da177e4SLinus Torvalds 53381da177e4SLinus Torvalds case HCI_SCODATA_PKT: 53391da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 53401da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 53411da177e4SLinus Torvalds break; 53421da177e4SLinus Torvalds 53431da177e4SLinus Torvalds default: 53441da177e4SLinus Torvalds kfree_skb(skb); 53451da177e4SLinus Torvalds break; 53461da177e4SLinus Torvalds } 53471da177e4SLinus Torvalds } 53481da177e4SLinus Torvalds } 53491da177e4SLinus Torvalds 5350c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 53511da177e4SLinus Torvalds { 5352c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 53531da177e4SLinus Torvalds struct sk_buff *skb; 53541da177e4SLinus Torvalds 53552104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 53562104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 53571da177e4SLinus Torvalds 53581da177e4SLinus Torvalds /* Send queued commands */ 53595a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 53605a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 53615a08ecceSAndrei Emeltchenko if (!skb) 53625a08ecceSAndrei Emeltchenko return; 53635a08ecceSAndrei Emeltchenko 53641da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 53651da177e4SLinus Torvalds 5366a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 536770f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 53681da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 536957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 53707bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 537165cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 53727bdb8a5cSSzymon Janc else 537365cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 537465cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 53751da177e4SLinus Torvalds } else { 53761da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 5377c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 53781da177e4SLinus Torvalds } 53791da177e4SLinus Torvalds } 53801da177e4SLinus Torvalds } 5381b1efcc28SAndre Guedes 5382b1efcc28SAndre Guedes void hci_req_add_le_scan_disable(struct hci_request *req) 5383b1efcc28SAndre Guedes { 5384b1efcc28SAndre Guedes struct hci_cp_le_set_scan_enable cp; 5385b1efcc28SAndre Guedes 5386b1efcc28SAndre Guedes memset(&cp, 0, sizeof(cp)); 5387b1efcc28SAndre Guedes cp.enable = LE_SCAN_DISABLE; 5388b1efcc28SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 5389b1efcc28SAndre Guedes } 5390a4790dbdSAndre Guedes 53918ef30fd3SAndre Guedes void hci_req_add_le_passive_scan(struct hci_request *req) 53928ef30fd3SAndre Guedes { 53938ef30fd3SAndre Guedes struct hci_cp_le_set_scan_param param_cp; 53948ef30fd3SAndre Guedes struct hci_cp_le_set_scan_enable enable_cp; 53958ef30fd3SAndre Guedes struct hci_dev *hdev = req->hdev; 53968ef30fd3SAndre Guedes u8 own_addr_type; 53978ef30fd3SAndre Guedes 53986ab535a7SMarcel Holtmann /* Set require_privacy to false since no SCAN_REQ are send 53996ab535a7SMarcel Holtmann * during passive scanning. Not using an unresolvable address 54006ab535a7SMarcel Holtmann * here is important so that peer devices using direct 54016ab535a7SMarcel Holtmann * advertising with our address will be correctly reported 54026ab535a7SMarcel Holtmann * by the controller. 54038ef30fd3SAndre Guedes */ 54046ab535a7SMarcel Holtmann if (hci_update_random_address(req, false, &own_addr_type)) 54058ef30fd3SAndre Guedes return; 54068ef30fd3SAndre Guedes 54078ef30fd3SAndre Guedes memset(¶m_cp, 0, sizeof(param_cp)); 54088ef30fd3SAndre Guedes param_cp.type = LE_SCAN_PASSIVE; 54098ef30fd3SAndre Guedes param_cp.interval = cpu_to_le16(hdev->le_scan_interval); 54108ef30fd3SAndre Guedes param_cp.window = cpu_to_le16(hdev->le_scan_window); 54118ef30fd3SAndre Guedes param_cp.own_address_type = own_addr_type; 54128ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_PARAM, sizeof(param_cp), 54138ef30fd3SAndre Guedes ¶m_cp); 54148ef30fd3SAndre Guedes 54158ef30fd3SAndre Guedes memset(&enable_cp, 0, sizeof(enable_cp)); 54168ef30fd3SAndre Guedes enable_cp.enable = LE_SCAN_ENABLE; 54174340a124SAndre Guedes enable_cp.filter_dup = LE_SCAN_FILTER_DUP_ENABLE; 54188ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(enable_cp), 54198ef30fd3SAndre Guedes &enable_cp); 54208ef30fd3SAndre Guedes } 54218ef30fd3SAndre Guedes 5422a4790dbdSAndre Guedes static void update_background_scan_complete(struct hci_dev *hdev, u8 status) 5423a4790dbdSAndre Guedes { 5424a4790dbdSAndre Guedes if (status) 5425a4790dbdSAndre Guedes BT_DBG("HCI request failed to update background scanning: " 5426a4790dbdSAndre Guedes "status 0x%2.2x", status); 5427a4790dbdSAndre Guedes } 5428a4790dbdSAndre Guedes 5429a4790dbdSAndre Guedes /* This function controls the background scanning based on hdev->pend_le_conns 5430a4790dbdSAndre Guedes * list. If there are pending LE connection we start the background scanning, 5431a4790dbdSAndre Guedes * otherwise we stop it. 5432a4790dbdSAndre Guedes * 5433a4790dbdSAndre Guedes * This function requires the caller holds hdev->lock. 5434a4790dbdSAndre Guedes */ 5435a4790dbdSAndre Guedes void hci_update_background_scan(struct hci_dev *hdev) 5436a4790dbdSAndre Guedes { 5437a4790dbdSAndre Guedes struct hci_request req; 5438a4790dbdSAndre Guedes struct hci_conn *conn; 5439a4790dbdSAndre Guedes int err; 5440a4790dbdSAndre Guedes 5441c20c02d5SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags) || 5442c20c02d5SMarcel Holtmann test_bit(HCI_INIT, &hdev->flags) || 5443c20c02d5SMarcel Holtmann test_bit(HCI_SETUP, &hdev->dev_flags) || 5444d603b76bSMarcel Holtmann test_bit(HCI_CONFIG, &hdev->dev_flags) || 5445b8221770SMarcel Holtmann test_bit(HCI_AUTO_OFF, &hdev->dev_flags) || 5446c20c02d5SMarcel Holtmann test_bit(HCI_UNREGISTER, &hdev->dev_flags)) 54471c1697c0SMarcel Holtmann return; 54481c1697c0SMarcel Holtmann 5449a70f4b5fSJohan Hedberg /* No point in doing scanning if LE support hasn't been enabled */ 5450a70f4b5fSJohan Hedberg if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 5451a70f4b5fSJohan Hedberg return; 5452a70f4b5fSJohan Hedberg 5453ae23ada4SJohan Hedberg /* If discovery is active don't interfere with it */ 5454ae23ada4SJohan Hedberg if (hdev->discovery.state != DISCOVERY_STOPPED) 5455ae23ada4SJohan Hedberg return; 5456ae23ada4SJohan Hedberg 5457a4790dbdSAndre Guedes hci_req_init(&req, hdev); 5458a4790dbdSAndre Guedes 54592b7be33eSJohan Hedberg if (!test_bit(HCI_CONNECTABLE, &hdev->dev_flags) && 54602b7be33eSJohan Hedberg list_empty(&hdev->pend_le_conns) && 546166f8455aSJohan Hedberg list_empty(&hdev->pend_le_reports)) { 54620d2bf134SJohan Hedberg /* If there is no pending LE connections or devices 54630d2bf134SJohan Hedberg * to be scanned for, we should stop the background 54640d2bf134SJohan Hedberg * scanning. 5465a4790dbdSAndre Guedes */ 5466a4790dbdSAndre Guedes 5467a4790dbdSAndre Guedes /* If controller is not scanning we are done. */ 5468a4790dbdSAndre Guedes if (!test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 5469a4790dbdSAndre Guedes return; 5470a4790dbdSAndre Guedes 5471a4790dbdSAndre Guedes hci_req_add_le_scan_disable(&req); 5472a4790dbdSAndre Guedes 5473a4790dbdSAndre Guedes BT_DBG("%s stopping background scanning", hdev->name); 5474a4790dbdSAndre Guedes } else { 5475a4790dbdSAndre Guedes /* If there is at least one pending LE connection, we should 5476a4790dbdSAndre Guedes * keep the background scan running. 5477a4790dbdSAndre Guedes */ 5478a4790dbdSAndre Guedes 5479a4790dbdSAndre Guedes /* If controller is connecting, we should not start scanning 5480a4790dbdSAndre Guedes * since some controllers are not able to scan and connect at 5481a4790dbdSAndre Guedes * the same time. 5482a4790dbdSAndre Guedes */ 5483a4790dbdSAndre Guedes conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT); 5484a4790dbdSAndre Guedes if (conn) 5485a4790dbdSAndre Guedes return; 5486a4790dbdSAndre Guedes 54874340a124SAndre Guedes /* If controller is currently scanning, we stop it to ensure we 54884340a124SAndre Guedes * don't miss any advertising (due to duplicates filter). 54894340a124SAndre Guedes */ 54904340a124SAndre Guedes if (test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 54914340a124SAndre Guedes hci_req_add_le_scan_disable(&req); 54924340a124SAndre Guedes 54938ef30fd3SAndre Guedes hci_req_add_le_passive_scan(&req); 5494a4790dbdSAndre Guedes 5495a4790dbdSAndre Guedes BT_DBG("%s starting background scanning", hdev->name); 5496a4790dbdSAndre Guedes } 5497a4790dbdSAndre Guedes 5498a4790dbdSAndre Guedes err = hci_req_run(&req, update_background_scan_complete); 5499a4790dbdSAndre Guedes if (err) 5500a4790dbdSAndre Guedes BT_ERR("Failed to run HCI request: err %d", err); 5501a4790dbdSAndre Guedes } 5502