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[1] |= 0x08; /* Read Remote Version Information Complete */ 1426c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 1427c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 1428c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 1429c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 1430c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 14310da71f1bSMarcel Holtmann 14320da71f1bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) { 14330da71f1bSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 1434c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 14352177bab5SJohan Hedberg } 14360da71f1bSMarcel Holtmann } 14372177bab5SJohan Hedberg 14382177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 14392177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 14402177bab5SJohan Hedberg 14412177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 14422177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 14432177bab5SJohan Hedberg 14442177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 14452177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 14462177bab5SJohan Hedberg 14472177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 14482177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 14492177bab5SJohan Hedberg 14502177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 14512177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 14522177bab5SJohan Hedberg 14532177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 14542177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 14552177bab5SJohan Hedberg 14562177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 14572177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 14582177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 14592177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 14602177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 14612177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 14622177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 14632177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 14642177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 14652177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 14662177bab5SJohan Hedberg * Features Notification 14672177bab5SJohan Hedberg */ 14682177bab5SJohan Hedberg } 14692177bab5SJohan Hedberg 14702177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 14712177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 14722177bab5SJohan Hedberg 147342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 14742177bab5SJohan Hedberg } 14752177bab5SJohan Hedberg 147642c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 14772177bab5SJohan Hedberg { 147842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 147942c6b129SJohan Hedberg 14802177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 148142c6b129SJohan Hedberg bredr_setup(req); 148256f87901SJohan Hedberg else 148356f87901SJohan Hedberg clear_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 14842177bab5SJohan Hedberg 14852177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 148642c6b129SJohan Hedberg le_setup(req); 14872177bab5SJohan Hedberg 14883f8e2d75SJohan Hedberg /* AVM Berlin (31), aka "BlueFRITZ!", doesn't support the read 14893f8e2d75SJohan Hedberg * local supported commands HCI command. 14903f8e2d75SJohan Hedberg */ 14913f8e2d75SJohan Hedberg if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) 149242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 14932177bab5SJohan Hedberg 14942177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 149557af75a8SMarcel Holtmann /* When SSP is available, then the host features page 149657af75a8SMarcel Holtmann * should also be available as well. However some 149757af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 149857af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 149957af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 150057af75a8SMarcel Holtmann */ 150157af75a8SMarcel Holtmann hdev->max_page = 0x01; 150257af75a8SMarcel Holtmann 15032177bab5SJohan Hedberg if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) { 15042177bab5SJohan Hedberg u8 mode = 0x01; 150542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 15062177bab5SJohan Hedberg sizeof(mode), &mode); 15072177bab5SJohan Hedberg } else { 15082177bab5SJohan Hedberg struct hci_cp_write_eir cp; 15092177bab5SJohan Hedberg 15102177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 15112177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 15122177bab5SJohan Hedberg 151342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 15142177bab5SJohan Hedberg } 15152177bab5SJohan Hedberg } 15162177bab5SJohan Hedberg 15172177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 151842c6b129SJohan Hedberg hci_setup_inquiry_mode(req); 15192177bab5SJohan Hedberg 15202177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 152142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 15222177bab5SJohan Hedberg 15232177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 15242177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 15252177bab5SJohan Hedberg 15262177bab5SJohan Hedberg cp.page = 0x01; 152742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 152842c6b129SJohan Hedberg sizeof(cp), &cp); 15292177bab5SJohan Hedberg } 15302177bab5SJohan Hedberg 15312177bab5SJohan Hedberg if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) { 15322177bab5SJohan Hedberg u8 enable = 1; 153342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 15342177bab5SJohan Hedberg &enable); 15352177bab5SJohan Hedberg } 15362177bab5SJohan Hedberg } 15372177bab5SJohan Hedberg 153842c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 15392177bab5SJohan Hedberg { 154042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 15412177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 15422177bab5SJohan Hedberg u16 link_policy = 0; 15432177bab5SJohan Hedberg 15442177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 15452177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 15462177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 15472177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 15482177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 15492177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 15502177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 15512177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 15522177bab5SJohan Hedberg 15532177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 155442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 15552177bab5SJohan Hedberg } 15562177bab5SJohan Hedberg 155742c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 15582177bab5SJohan Hedberg { 155942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 15602177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 15612177bab5SJohan Hedberg 1562c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 1563c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1564c73eee91SJohan Hedberg return; 1565c73eee91SJohan Hedberg 15662177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 15672177bab5SJohan Hedberg 15682177bab5SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) { 15692177bab5SJohan Hedberg cp.le = 0x01; 15702177bab5SJohan Hedberg cp.simul = lmp_le_br_capable(hdev); 15712177bab5SJohan Hedberg } 15722177bab5SJohan Hedberg 15732177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 157442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 15752177bab5SJohan Hedberg &cp); 15762177bab5SJohan Hedberg } 15772177bab5SJohan Hedberg 1578d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 1579d62e6d67SJohan Hedberg { 1580d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 1581d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 1582d62e6d67SJohan Hedberg 1583d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 1584d62e6d67SJohan Hedberg * enable all necessary events for it. 1585d62e6d67SJohan Hedberg */ 158653b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 1587d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 1588d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 1589d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 1590d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 1591d62e6d67SJohan Hedberg } 1592d62e6d67SJohan Hedberg 1593d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 1594d62e6d67SJohan Hedberg * enable all necessary events for it. 1595d62e6d67SJohan Hedberg */ 159653b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 1597d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 1598d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 1599d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 1600d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 1601d62e6d67SJohan Hedberg } 1602d62e6d67SJohan Hedberg 160340c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 1604cd7ca0ecSMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) 160540c59fcbSMarcel Holtmann events[2] |= 0x80; 160640c59fcbSMarcel Holtmann 1607d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 1608d62e6d67SJohan Hedberg } 1609d62e6d67SJohan Hedberg 161042c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 16112177bab5SJohan Hedberg { 161242c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 1613d2c5d77fSJohan Hedberg u8 p; 161442c6b129SJohan Hedberg 16150da71f1bSMarcel Holtmann hci_setup_event_mask(req); 16160da71f1bSMarcel Holtmann 1617b8f4e068SGustavo Padovan /* Some Broadcom based Bluetooth controllers do not support the 1618b8f4e068SGustavo Padovan * Delete Stored Link Key command. They are clearly indicating its 1619b8f4e068SGustavo Padovan * absence in the bit mask of supported commands. 1620b8f4e068SGustavo Padovan * 1621b8f4e068SGustavo Padovan * Check the supported commands and only if the the command is marked 1622b8f4e068SGustavo Padovan * as supported send it. If not supported assume that the controller 1623b8f4e068SGustavo Padovan * does not have actual support for stored link keys which makes this 1624b8f4e068SGustavo Padovan * command redundant anyway. 1625f9f462faSMarcel Holtmann * 1626f9f462faSMarcel Holtmann * Some controllers indicate that they support handling deleting 1627f9f462faSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 1628f9f462faSMarcel Holtmann * just disable this command. 1629b8f4e068SGustavo Padovan */ 1630f9f462faSMarcel Holtmann if (hdev->commands[6] & 0x80 && 1631f9f462faSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 163259f45d57SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 163359f45d57SJohan Hedberg 163459f45d57SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 163559f45d57SJohan Hedberg cp.delete_all = 0x01; 163659f45d57SJohan Hedberg hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 163759f45d57SJohan Hedberg sizeof(cp), &cp); 163859f45d57SJohan Hedberg } 163959f45d57SJohan Hedberg 16402177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 164142c6b129SJohan Hedberg hci_setup_link_policy(req); 16422177bab5SJohan Hedberg 16439193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 16449193c6e8SAndre Guedes u8 events[8]; 16459193c6e8SAndre Guedes 16469193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 16474d6c705bSMarcel Holtmann events[0] = 0x0f; 16484d6c705bSMarcel Holtmann 16494d6c705bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) 16504d6c705bSMarcel Holtmann events[0] |= 0x10; /* LE Long Term Key Request */ 1651662bc2e6SAndre Guedes 1652662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 1653662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 1654662bc2e6SAndre Guedes */ 1655662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 1656662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 1657662bc2e6SAndre Guedes * Parameter Request 1658662bc2e6SAndre Guedes */ 1659662bc2e6SAndre Guedes 16609193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 16619193c6e8SAndre Guedes events); 16629193c6e8SAndre Guedes 166315a49ccaSMarcel Holtmann if (hdev->commands[25] & 0x40) { 166415a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 166515a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 166615a49ccaSMarcel Holtmann } 166715a49ccaSMarcel Holtmann 166842c6b129SJohan Hedberg hci_set_le_support(req); 16699193c6e8SAndre Guedes } 1670d2c5d77fSJohan Hedberg 1671d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 1672d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 1673d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 1674d2c5d77fSJohan Hedberg 1675d2c5d77fSJohan Hedberg cp.page = p; 1676d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 1677d2c5d77fSJohan Hedberg sizeof(cp), &cp); 1678d2c5d77fSJohan Hedberg } 16792177bab5SJohan Hedberg } 16802177bab5SJohan Hedberg 16815d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 16825d4e7e8dSJohan Hedberg { 16835d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 16845d4e7e8dSJohan Hedberg 1685d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 1686d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 1687d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 1688d62e6d67SJohan Hedberg 1689109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 1690109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 1691109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 1692109e3191SMarcel Holtmann 1693f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 1694f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 1695f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 1696f4fe73edSMarcel Holtmann 16975d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 169853b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 16995d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 1700a6d0d690SMarcel Holtmann 1701a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 17025afeac14SMarcel Holtmann if ((lmp_sc_capable(hdev) || 1703111902f7SMarcel Holtmann test_bit(HCI_FORCE_SC, &hdev->dbg_flags)) && 1704a6d0d690SMarcel Holtmann test_bit(HCI_SC_ENABLED, &hdev->dev_flags)) { 1705a6d0d690SMarcel Holtmann u8 support = 0x01; 1706a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 1707a6d0d690SMarcel Holtmann sizeof(support), &support); 1708a6d0d690SMarcel Holtmann } 17095d4e7e8dSJohan Hedberg } 17105d4e7e8dSJohan Hedberg 17112177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 17122177bab5SJohan Hedberg { 17132177bab5SJohan Hedberg int err; 17142177bab5SJohan Hedberg 17152177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 17162177bab5SJohan Hedberg if (err < 0) 17172177bab5SJohan Hedberg return err; 17182177bab5SJohan Hedberg 17194b4148e9SMarcel Holtmann /* The Device Under Test (DUT) mode is special and available for 17204b4148e9SMarcel Holtmann * all controller types. So just create it early on. 17214b4148e9SMarcel Holtmann */ 17224b4148e9SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 17234b4148e9SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 17244b4148e9SMarcel Holtmann &dut_mode_fops); 17254b4148e9SMarcel Holtmann } 17264b4148e9SMarcel Holtmann 17272177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 17282177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 17292177bab5SJohan Hedberg * first stage init. 17302177bab5SJohan Hedberg */ 17312177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 17322177bab5SJohan Hedberg return 0; 17332177bab5SJohan Hedberg 17342177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 17352177bab5SJohan Hedberg if (err < 0) 17362177bab5SJohan Hedberg return err; 17372177bab5SJohan Hedberg 17385d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 17395d4e7e8dSJohan Hedberg if (err < 0) 17405d4e7e8dSJohan Hedberg return err; 17415d4e7e8dSJohan Hedberg 1742baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 1743baf27f6eSMarcel Holtmann if (err < 0) 1744baf27f6eSMarcel Holtmann return err; 1745baf27f6eSMarcel Holtmann 1746baf27f6eSMarcel Holtmann /* Only create debugfs entries during the initial setup 1747baf27f6eSMarcel Holtmann * phase and not every time the controller gets powered on. 1748baf27f6eSMarcel Holtmann */ 1749baf27f6eSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 1750baf27f6eSMarcel Holtmann return 0; 1751baf27f6eSMarcel Holtmann 1752dfb826a8SMarcel Holtmann debugfs_create_file("features", 0444, hdev->debugfs, hdev, 1753dfb826a8SMarcel Holtmann &features_fops); 1754ceeb3bc0SMarcel Holtmann debugfs_create_u16("manufacturer", 0444, hdev->debugfs, 1755ceeb3bc0SMarcel Holtmann &hdev->manufacturer); 1756ceeb3bc0SMarcel Holtmann debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver); 1757ceeb3bc0SMarcel Holtmann debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev); 175870afe0b8SMarcel Holtmann debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev, 175970afe0b8SMarcel Holtmann &blacklist_fops); 17606659358eSJohan Hedberg debugfs_create_file("whitelist", 0444, hdev->debugfs, hdev, 17616659358eSJohan Hedberg &whitelist_fops); 176247219839SMarcel Holtmann debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 176347219839SMarcel Holtmann 176431ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev, 176531ad1691SAndrzej Kaczmarek &conn_info_min_age_fops); 176631ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev, 176731ad1691SAndrzej Kaczmarek &conn_info_max_age_fops); 176831ad1691SAndrzej Kaczmarek 1769baf27f6eSMarcel Holtmann if (lmp_bredr_capable(hdev)) { 1770baf27f6eSMarcel Holtmann debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, 1771baf27f6eSMarcel Holtmann hdev, &inquiry_cache_fops); 177202d08d15SMarcel Holtmann debugfs_create_file("link_keys", 0400, hdev->debugfs, 177302d08d15SMarcel Holtmann hdev, &link_keys_fops); 1774babdbb3cSMarcel Holtmann debugfs_create_file("dev_class", 0444, hdev->debugfs, 1775babdbb3cSMarcel Holtmann hdev, &dev_class_fops); 1776041000b9SMarcel Holtmann debugfs_create_file("voice_setting", 0444, hdev->debugfs, 1777041000b9SMarcel Holtmann hdev, &voice_setting_fops); 1778baf27f6eSMarcel Holtmann } 1779baf27f6eSMarcel Holtmann 178006f5b778SMarcel Holtmann if (lmp_ssp_capable(hdev)) { 1781ebd1e33bSMarcel Holtmann debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 1782ebd1e33bSMarcel Holtmann hdev, &auto_accept_delay_fops); 17835afeac14SMarcel Holtmann debugfs_create_file("force_sc_support", 0644, hdev->debugfs, 17845afeac14SMarcel Holtmann hdev, &force_sc_support_fops); 1785134c2a89SMarcel Holtmann debugfs_create_file("sc_only_mode", 0444, hdev->debugfs, 1786134c2a89SMarcel Holtmann hdev, &sc_only_mode_fops); 178706f5b778SMarcel Holtmann } 1788ebd1e33bSMarcel Holtmann 17892bfa3531SMarcel Holtmann if (lmp_sniff_capable(hdev)) { 17902bfa3531SMarcel Holtmann debugfs_create_file("idle_timeout", 0644, hdev->debugfs, 17912bfa3531SMarcel Holtmann hdev, &idle_timeout_fops); 17922bfa3531SMarcel Holtmann debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs, 17932bfa3531SMarcel Holtmann hdev, &sniff_min_interval_fops); 17942bfa3531SMarcel Holtmann debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs, 17952bfa3531SMarcel Holtmann hdev, &sniff_max_interval_fops); 17962bfa3531SMarcel Holtmann } 17972bfa3531SMarcel Holtmann 1798d0f729b8SMarcel Holtmann if (lmp_le_capable(hdev)) { 1799ac345813SMarcel Holtmann debugfs_create_file("identity", 0400, hdev->debugfs, 1800ac345813SMarcel Holtmann hdev, &identity_fops); 1801ac345813SMarcel Holtmann debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, 1802ac345813SMarcel Holtmann hdev, &rpa_timeout_fops); 18037a4cd51dSMarcel Holtmann debugfs_create_file("random_address", 0444, hdev->debugfs, 18047a4cd51dSMarcel Holtmann hdev, &random_address_fops); 1805e7b8fc92SMarcel Holtmann debugfs_create_file("static_address", 0444, hdev->debugfs, 1806e7b8fc92SMarcel Holtmann hdev, &static_address_fops); 1807b32bba6cSMarcel Holtmann 1808b32bba6cSMarcel Holtmann /* For controllers with a public address, provide a debug 1809b32bba6cSMarcel Holtmann * option to force the usage of the configured static 1810b32bba6cSMarcel Holtmann * address. By default the public address is used. 1811b32bba6cSMarcel Holtmann */ 1812b32bba6cSMarcel Holtmann if (bacmp(&hdev->bdaddr, BDADDR_ANY)) 1813b32bba6cSMarcel Holtmann debugfs_create_file("force_static_address", 0644, 1814b32bba6cSMarcel Holtmann hdev->debugfs, hdev, 1815b32bba6cSMarcel Holtmann &force_static_address_fops); 1816b32bba6cSMarcel Holtmann 1817b32bba6cSMarcel Holtmann debugfs_create_u8("white_list_size", 0444, hdev->debugfs, 1818b32bba6cSMarcel Holtmann &hdev->le_white_list_size); 1819d2ab0ac1SMarcel Holtmann debugfs_create_file("white_list", 0444, hdev->debugfs, hdev, 1820d2ab0ac1SMarcel Holtmann &white_list_fops); 18213698d704SMarcel Holtmann debugfs_create_file("identity_resolving_keys", 0400, 18223698d704SMarcel Holtmann hdev->debugfs, hdev, 18233698d704SMarcel Holtmann &identity_resolving_keys_fops); 18248f8625cdSMarcel Holtmann debugfs_create_file("long_term_keys", 0400, hdev->debugfs, 18258f8625cdSMarcel Holtmann hdev, &long_term_keys_fops); 18264e70c7e7SMarcel Holtmann debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, 18274e70c7e7SMarcel Holtmann hdev, &conn_min_interval_fops); 18284e70c7e7SMarcel Holtmann debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, 18294e70c7e7SMarcel Holtmann hdev, &conn_max_interval_fops); 1830816a93d1SMarcel Holtmann debugfs_create_file("conn_latency", 0644, hdev->debugfs, 1831816a93d1SMarcel Holtmann hdev, &conn_latency_fops); 1832f1649577SMarcel Holtmann debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, 1833f1649577SMarcel Holtmann hdev, &supervision_timeout_fops); 18343f959d46SMarcel Holtmann debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, 18353f959d46SMarcel Holtmann hdev, &adv_channel_map_fops); 18360b3c7d37SMarcel Holtmann debugfs_create_file("device_list", 0444, hdev->debugfs, hdev, 18370b3c7d37SMarcel Holtmann &device_list_fops); 1838b9a7a61eSLukasz Rymanowski debugfs_create_u16("discov_interleaved_timeout", 0644, 1839b9a7a61eSLukasz Rymanowski hdev->debugfs, 1840b9a7a61eSLukasz Rymanowski &hdev->discov_interleaved_timeout); 1841d0f729b8SMarcel Holtmann } 1842e7b8fc92SMarcel Holtmann 1843baf27f6eSMarcel Holtmann return 0; 18442177bab5SJohan Hedberg } 18452177bab5SJohan Hedberg 18460ebca7d6SMarcel Holtmann static void hci_init0_req(struct hci_request *req, unsigned long opt) 18470ebca7d6SMarcel Holtmann { 18480ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 18490ebca7d6SMarcel Holtmann 18500ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 18510ebca7d6SMarcel Holtmann 18520ebca7d6SMarcel Holtmann /* Reset */ 18530ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 18540ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 18550ebca7d6SMarcel Holtmann 18560ebca7d6SMarcel Holtmann /* Read Local Version */ 18570ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 18580ebca7d6SMarcel Holtmann 18590ebca7d6SMarcel Holtmann /* Read BD Address */ 18600ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 18610ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 18620ebca7d6SMarcel Holtmann } 18630ebca7d6SMarcel Holtmann 18640ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 18650ebca7d6SMarcel Holtmann { 18660ebca7d6SMarcel Holtmann int err; 18670ebca7d6SMarcel Holtmann 1868cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 1869cc78b44bSMarcel Holtmann return 0; 1870cc78b44bSMarcel Holtmann 18710ebca7d6SMarcel Holtmann err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT); 18720ebca7d6SMarcel Holtmann if (err < 0) 18730ebca7d6SMarcel Holtmann return err; 18740ebca7d6SMarcel Holtmann 18750ebca7d6SMarcel Holtmann return 0; 18760ebca7d6SMarcel Holtmann } 18770ebca7d6SMarcel Holtmann 187842c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 18791da177e4SLinus Torvalds { 18801da177e4SLinus Torvalds __u8 scan = opt; 18811da177e4SLinus Torvalds 188242c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 18831da177e4SLinus Torvalds 18841da177e4SLinus Torvalds /* Inquiry and Page scans */ 188542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 18861da177e4SLinus Torvalds } 18871da177e4SLinus Torvalds 188842c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 18891da177e4SLinus Torvalds { 18901da177e4SLinus Torvalds __u8 auth = opt; 18911da177e4SLinus Torvalds 189242c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 18931da177e4SLinus Torvalds 18941da177e4SLinus Torvalds /* Authentication */ 189542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 18961da177e4SLinus Torvalds } 18971da177e4SLinus Torvalds 189842c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 18991da177e4SLinus Torvalds { 19001da177e4SLinus Torvalds __u8 encrypt = opt; 19011da177e4SLinus Torvalds 190242c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 19031da177e4SLinus Torvalds 1904e4e8e37cSMarcel Holtmann /* Encryption */ 190542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 19061da177e4SLinus Torvalds } 19071da177e4SLinus Torvalds 190842c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1909e4e8e37cSMarcel Holtmann { 1910e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1911e4e8e37cSMarcel Holtmann 191242c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1913e4e8e37cSMarcel Holtmann 1914e4e8e37cSMarcel Holtmann /* Default link policy */ 191542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1916e4e8e37cSMarcel Holtmann } 1917e4e8e37cSMarcel Holtmann 19181da177e4SLinus Torvalds /* Get HCI device by index. 19191da177e4SLinus Torvalds * Device is held on return. */ 19201da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 19211da177e4SLinus Torvalds { 19228035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 19231da177e4SLinus Torvalds 19241da177e4SLinus Torvalds BT_DBG("%d", index); 19251da177e4SLinus Torvalds 19261da177e4SLinus Torvalds if (index < 0) 19271da177e4SLinus Torvalds return NULL; 19281da177e4SLinus Torvalds 19291da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 19308035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 19311da177e4SLinus Torvalds if (d->id == index) { 19321da177e4SLinus Torvalds hdev = hci_dev_hold(d); 19331da177e4SLinus Torvalds break; 19341da177e4SLinus Torvalds } 19351da177e4SLinus Torvalds } 19361da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 19371da177e4SLinus Torvalds return hdev; 19381da177e4SLinus Torvalds } 19391da177e4SLinus Torvalds 19401da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1941ff9ef578SJohan Hedberg 194230dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 194330dc78e1SJohan Hedberg { 194430dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 194530dc78e1SJohan Hedberg 19466fbe195dSAndre Guedes switch (discov->state) { 1947343f935bSAndre Guedes case DISCOVERY_FINDING: 19486fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 194930dc78e1SJohan Hedberg return true; 195030dc78e1SJohan Hedberg 19516fbe195dSAndre Guedes default: 195230dc78e1SJohan Hedberg return false; 195330dc78e1SJohan Hedberg } 19546fbe195dSAndre Guedes } 195530dc78e1SJohan Hedberg 1956ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1957ff9ef578SJohan Hedberg { 1958bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 1959bb3e0a33SJohan Hedberg 1960ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1961ff9ef578SJohan Hedberg 1962bb3e0a33SJohan Hedberg if (old_state == state) 1963ff9ef578SJohan Hedberg return; 1964ff9ef578SJohan Hedberg 1965bb3e0a33SJohan Hedberg hdev->discovery.state = state; 1966bb3e0a33SJohan Hedberg 1967ff9ef578SJohan Hedberg switch (state) { 1968ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1969c54c3860SAndre Guedes hci_update_background_scan(hdev); 1970c54c3860SAndre Guedes 1971bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1972ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1973ff9ef578SJohan Hedberg break; 1974ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1975ff9ef578SJohan Hedberg break; 1976343f935bSAndre Guedes case DISCOVERY_FINDING: 1977ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1978ff9ef578SJohan Hedberg break; 197930dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 198030dc78e1SJohan Hedberg break; 1981ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1982ff9ef578SJohan Hedberg break; 1983ff9ef578SJohan Hedberg } 1984ff9ef578SJohan Hedberg } 1985ff9ef578SJohan Hedberg 19861f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 19871da177e4SLinus Torvalds { 198830883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1989b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 19901da177e4SLinus Torvalds 1991561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1992561aafbcSJohan Hedberg list_del(&p->all); 1993b57c1a56SJohan Hedberg kfree(p); 19941da177e4SLinus Torvalds } 1995561aafbcSJohan Hedberg 1996561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1997561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 19981da177e4SLinus Torvalds } 19991da177e4SLinus Torvalds 2000a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 2001a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 20021da177e4SLinus Torvalds { 200330883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 20041da177e4SLinus Torvalds struct inquiry_entry *e; 20051da177e4SLinus Torvalds 20066ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 20071da177e4SLinus Torvalds 2008561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 20091da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 20101da177e4SLinus Torvalds return e; 20111da177e4SLinus Torvalds } 20121da177e4SLinus Torvalds 2013b57c1a56SJohan Hedberg return NULL; 2014b57c1a56SJohan Hedberg } 2015b57c1a56SJohan Hedberg 2016561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 2017561aafbcSJohan Hedberg bdaddr_t *bdaddr) 2018561aafbcSJohan Hedberg { 201930883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2020561aafbcSJohan Hedberg struct inquiry_entry *e; 2021561aafbcSJohan Hedberg 20226ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 2023561aafbcSJohan Hedberg 2024561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 2025561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 2026561aafbcSJohan Hedberg return e; 2027561aafbcSJohan Hedberg } 2028561aafbcSJohan Hedberg 2029561aafbcSJohan Hedberg return NULL; 2030561aafbcSJohan Hedberg } 2031561aafbcSJohan Hedberg 203230dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 203330dc78e1SJohan Hedberg bdaddr_t *bdaddr, 203430dc78e1SJohan Hedberg int state) 203530dc78e1SJohan Hedberg { 203630dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 203730dc78e1SJohan Hedberg struct inquiry_entry *e; 203830dc78e1SJohan Hedberg 20396ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 204030dc78e1SJohan Hedberg 204130dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 204230dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 204330dc78e1SJohan Hedberg return e; 204430dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 204530dc78e1SJohan Hedberg return e; 204630dc78e1SJohan Hedberg } 204730dc78e1SJohan Hedberg 204830dc78e1SJohan Hedberg return NULL; 204930dc78e1SJohan Hedberg } 205030dc78e1SJohan Hedberg 2051a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 2052a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 2053a3d4e20aSJohan Hedberg { 2054a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2055a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 2056a3d4e20aSJohan Hedberg struct inquiry_entry *p; 2057a3d4e20aSJohan Hedberg 2058a3d4e20aSJohan Hedberg list_del(&ie->list); 2059a3d4e20aSJohan Hedberg 2060a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 2061a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 2062a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 2063a3d4e20aSJohan Hedberg break; 2064a3d4e20aSJohan Hedberg pos = &p->list; 2065a3d4e20aSJohan Hedberg } 2066a3d4e20aSJohan Hedberg 2067a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 2068a3d4e20aSJohan Hedberg } 2069a3d4e20aSJohan Hedberg 2070af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 2071af58925cSMarcel Holtmann bool name_known) 20721da177e4SLinus Torvalds { 207330883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 207470f23020SAndrei Emeltchenko struct inquiry_entry *ie; 2075af58925cSMarcel Holtmann u32 flags = 0; 20761da177e4SLinus Torvalds 20776ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 20781da177e4SLinus Torvalds 20792b2fec4dSSzymon Janc hci_remove_remote_oob_data(hdev, &data->bdaddr); 20802b2fec4dSSzymon Janc 2081af58925cSMarcel Holtmann if (!data->ssp_mode) 2082af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 2083388fc8faSJohan Hedberg 208470f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 2085a3d4e20aSJohan Hedberg if (ie) { 2086af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 2087af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 2088388fc8faSJohan Hedberg 2089a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 2090a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 2091a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 2092a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 2093a3d4e20aSJohan Hedberg } 2094a3d4e20aSJohan Hedberg 2095561aafbcSJohan Hedberg goto update; 2096a3d4e20aSJohan Hedberg } 2097561aafbcSJohan Hedberg 20981da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 209927f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 2100af58925cSMarcel Holtmann if (!ie) { 2101af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 2102af58925cSMarcel Holtmann goto done; 2103af58925cSMarcel Holtmann } 210470f23020SAndrei Emeltchenko 2105561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 2106561aafbcSJohan Hedberg 2107561aafbcSJohan Hedberg if (name_known) { 2108561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2109561aafbcSJohan Hedberg } else { 2110561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 2111561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 2112561aafbcSJohan Hedberg } 2113561aafbcSJohan Hedberg 2114561aafbcSJohan Hedberg update: 2115561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 2116561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 2117561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2118561aafbcSJohan Hedberg list_del(&ie->list); 21191da177e4SLinus Torvalds } 21201da177e4SLinus Torvalds 212170f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 212270f23020SAndrei Emeltchenko ie->timestamp = jiffies; 21231da177e4SLinus Torvalds cache->timestamp = jiffies; 21243175405bSJohan Hedberg 21253175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 2126af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 21273175405bSJohan Hedberg 2128af58925cSMarcel Holtmann done: 2129af58925cSMarcel Holtmann return flags; 21301da177e4SLinus Torvalds } 21311da177e4SLinus Torvalds 21321da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 21331da177e4SLinus Torvalds { 213430883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 21351da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 21361da177e4SLinus Torvalds struct inquiry_entry *e; 21371da177e4SLinus Torvalds int copied = 0; 21381da177e4SLinus Torvalds 2139561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 21401da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 2141b57c1a56SJohan Hedberg 2142b57c1a56SJohan Hedberg if (copied >= num) 2143b57c1a56SJohan Hedberg break; 2144b57c1a56SJohan Hedberg 21451da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 21461da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 21471da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 21481da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 21491da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 21501da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 2151b57c1a56SJohan Hedberg 21521da177e4SLinus Torvalds info++; 2153b57c1a56SJohan Hedberg copied++; 21541da177e4SLinus Torvalds } 21551da177e4SLinus Torvalds 21561da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 21571da177e4SLinus Torvalds return copied; 21581da177e4SLinus Torvalds } 21591da177e4SLinus Torvalds 216042c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 21611da177e4SLinus Torvalds { 21621da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 216342c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 21641da177e4SLinus Torvalds struct hci_cp_inquiry cp; 21651da177e4SLinus Torvalds 21661da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 21671da177e4SLinus Torvalds 21681da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 21691da177e4SLinus Torvalds return; 21701da177e4SLinus Torvalds 21711da177e4SLinus Torvalds /* Start Inquiry */ 21721da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 21731da177e4SLinus Torvalds cp.length = ir->length; 21741da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 217542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 21761da177e4SLinus Torvalds } 21771da177e4SLinus Torvalds 21783e13fa1eSAndre Guedes static int wait_inquiry(void *word) 21793e13fa1eSAndre Guedes { 21803e13fa1eSAndre Guedes schedule(); 21813e13fa1eSAndre Guedes return signal_pending(current); 21823e13fa1eSAndre Guedes } 21833e13fa1eSAndre Guedes 21841da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 21851da177e4SLinus Torvalds { 21861da177e4SLinus Torvalds __u8 __user *ptr = arg; 21871da177e4SLinus Torvalds struct hci_inquiry_req ir; 21881da177e4SLinus Torvalds struct hci_dev *hdev; 21891da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 21901da177e4SLinus Torvalds long timeo; 21911da177e4SLinus Torvalds __u8 *buf; 21921da177e4SLinus Torvalds 21931da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 21941da177e4SLinus Torvalds return -EFAULT; 21951da177e4SLinus Torvalds 21965a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 21975a08ecceSAndrei Emeltchenko if (!hdev) 21981da177e4SLinus Torvalds return -ENODEV; 21991da177e4SLinus Torvalds 22000736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 22010736cfa8SMarcel Holtmann err = -EBUSY; 22020736cfa8SMarcel Holtmann goto done; 22030736cfa8SMarcel Holtmann } 22040736cfa8SMarcel Holtmann 22054a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2206fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2207fee746b0SMarcel Holtmann goto done; 2208fee746b0SMarcel Holtmann } 2209fee746b0SMarcel Holtmann 22105b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 22115b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 22125b69bef5SMarcel Holtmann goto done; 22135b69bef5SMarcel Holtmann } 22145b69bef5SMarcel Holtmann 221556f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 221656f87901SJohan Hedberg err = -EOPNOTSUPP; 221756f87901SJohan Hedberg goto done; 221856f87901SJohan Hedberg } 221956f87901SJohan Hedberg 222009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 22211da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 2222a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 22231f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 22241da177e4SLinus Torvalds do_inquiry = 1; 22251da177e4SLinus Torvalds } 222609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 22271da177e4SLinus Torvalds 222804837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 222970f23020SAndrei Emeltchenko 223070f23020SAndrei Emeltchenko if (do_inquiry) { 223101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 223201178cd4SJohan Hedberg timeo); 223370f23020SAndrei Emeltchenko if (err < 0) 22341da177e4SLinus Torvalds goto done; 22353e13fa1eSAndre Guedes 22363e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 22373e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 22383e13fa1eSAndre Guedes */ 22393e13fa1eSAndre Guedes if (wait_on_bit(&hdev->flags, HCI_INQUIRY, wait_inquiry, 22403e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 22413e13fa1eSAndre Guedes return -EINTR; 224270f23020SAndrei Emeltchenko } 22431da177e4SLinus Torvalds 22448fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 22458fc9ced3SGustavo Padovan * 255 entries 22468fc9ced3SGustavo Padovan */ 22471da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 22481da177e4SLinus Torvalds 22491da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 22501da177e4SLinus Torvalds * copy it to the user space. 22511da177e4SLinus Torvalds */ 225270f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 225370f23020SAndrei Emeltchenko if (!buf) { 22541da177e4SLinus Torvalds err = -ENOMEM; 22551da177e4SLinus Torvalds goto done; 22561da177e4SLinus Torvalds } 22571da177e4SLinus Torvalds 225809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 22591da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 226009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 22611da177e4SLinus Torvalds 22621da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 22631da177e4SLinus Torvalds 22641da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 22651da177e4SLinus Torvalds ptr += sizeof(ir); 22661da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 22671da177e4SLinus Torvalds ir.num_rsp)) 22681da177e4SLinus Torvalds err = -EFAULT; 22691da177e4SLinus Torvalds } else 22701da177e4SLinus Torvalds err = -EFAULT; 22711da177e4SLinus Torvalds 22721da177e4SLinus Torvalds kfree(buf); 22731da177e4SLinus Torvalds 22741da177e4SLinus Torvalds done: 22751da177e4SLinus Torvalds hci_dev_put(hdev); 22761da177e4SLinus Torvalds return err; 22771da177e4SLinus Torvalds } 22781da177e4SLinus Torvalds 2279cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 22801da177e4SLinus Torvalds { 22811da177e4SLinus Torvalds int ret = 0; 22821da177e4SLinus Torvalds 22831da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 22841da177e4SLinus Torvalds 22851da177e4SLinus Torvalds hci_req_lock(hdev); 22861da177e4SLinus Torvalds 228794324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 228894324962SJohan Hovold ret = -ENODEV; 228994324962SJohan Hovold goto done; 229094324962SJohan Hovold } 229194324962SJohan Hovold 2292d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2293d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 2294a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 2295a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 2296bf543036SJohan Hedberg */ 2297a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 2298611b30f7SMarcel Holtmann ret = -ERFKILL; 2299611b30f7SMarcel Holtmann goto done; 2300611b30f7SMarcel Holtmann } 2301611b30f7SMarcel Holtmann 2302a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 2303a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 2304a5c8f270SMarcel Holtmann * be able to determine if there is a public address 2305a5c8f270SMarcel Holtmann * or not. 2306a5c8f270SMarcel Holtmann * 2307c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 2308c6beca0eSMarcel Holtmann * if a public address or static random address is 2309c6beca0eSMarcel Holtmann * available. 2310c6beca0eSMarcel Holtmann * 2311a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 2312a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 2313a5c8f270SMarcel Holtmann */ 2314c6beca0eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 2315c6beca0eSMarcel Holtmann hdev->dev_type == HCI_BREDR && 2316a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2317a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 2318a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 2319a5c8f270SMarcel Holtmann goto done; 2320a5c8f270SMarcel Holtmann } 2321a5c8f270SMarcel Holtmann } 2322a5c8f270SMarcel Holtmann 23231da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 23241da177e4SLinus Torvalds ret = -EALREADY; 23251da177e4SLinus Torvalds goto done; 23261da177e4SLinus Torvalds } 23271da177e4SLinus Torvalds 23281da177e4SLinus Torvalds if (hdev->open(hdev)) { 23291da177e4SLinus Torvalds ret = -EIO; 23301da177e4SLinus Torvalds goto done; 23311da177e4SLinus Torvalds } 23321da177e4SLinus Torvalds 23331da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 23341da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 2335f41c70c4SMarcel Holtmann 2336af202f84SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 2337af202f84SMarcel Holtmann if (hdev->setup) 2338f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 2339f41c70c4SMarcel Holtmann 2340af202f84SMarcel Holtmann /* The transport driver can set these quirks before 2341af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 2342af202f84SMarcel Holtmann * 2343af202f84SMarcel Holtmann * In case any of them is set, the controller has to 2344af202f84SMarcel Holtmann * start up as unconfigured. 2345af202f84SMarcel Holtmann */ 2346eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 2347eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 234889bc22d2SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 23490ebca7d6SMarcel Holtmann 23500ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 23510ebca7d6SMarcel Holtmann * read at least the version information provided by 23520ebca7d6SMarcel Holtmann * the Read Local Version Information command. 23530ebca7d6SMarcel Holtmann * 23540ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 23550ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 23560ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 23570ebca7d6SMarcel Holtmann */ 23580ebca7d6SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 23590ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 236089bc22d2SMarcel Holtmann } 236189bc22d2SMarcel Holtmann 23629713c17bSMarcel Holtmann if (test_bit(HCI_CONFIG, &hdev->dev_flags)) { 23639713c17bSMarcel Holtmann /* If public address change is configured, ensure that 23649713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 23659713c17bSMarcel Holtmann * support changing the public address, fail the power 23669713c17bSMarcel Holtmann * on procedure. 236724c457e2SMarcel Holtmann */ 23689713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 23699713c17bSMarcel Holtmann hdev->set_bdaddr) 237024c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 237124c457e2SMarcel Holtmann else 237224c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 237324c457e2SMarcel Holtmann } 237424c457e2SMarcel Holtmann 2375f41c70c4SMarcel Holtmann if (!ret) { 23764a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 23770736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 23782177bab5SJohan Hedberg ret = __hci_init(hdev); 23791da177e4SLinus Torvalds } 23801da177e4SLinus Torvalds 2381f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 2382f41c70c4SMarcel Holtmann 23831da177e4SLinus Torvalds if (!ret) { 23841da177e4SLinus Torvalds hci_dev_hold(hdev); 2385d6bfd59cSJohan Hedberg set_bit(HCI_RPA_EXPIRED, &hdev->dev_flags); 23861da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 23871da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 2388bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2389d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags) && 23904a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 23910736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 23921514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 239309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2394744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 239509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 239656e5cb86SJohan Hedberg } 23971da177e4SLinus Torvalds } else { 23981da177e4SLinus Torvalds /* Init failed, cleanup */ 23993eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2400c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 2401b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 24021da177e4SLinus Torvalds 24031da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 24041da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 24051da177e4SLinus Torvalds 24061da177e4SLinus Torvalds if (hdev->flush) 24071da177e4SLinus Torvalds hdev->flush(hdev); 24081da177e4SLinus Torvalds 24091da177e4SLinus Torvalds if (hdev->sent_cmd) { 24101da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 24111da177e4SLinus Torvalds hdev->sent_cmd = NULL; 24121da177e4SLinus Torvalds } 24131da177e4SLinus Torvalds 24141da177e4SLinus Torvalds hdev->close(hdev); 2415fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 24161da177e4SLinus Torvalds } 24171da177e4SLinus Torvalds 24181da177e4SLinus Torvalds done: 24191da177e4SLinus Torvalds hci_req_unlock(hdev); 24201da177e4SLinus Torvalds return ret; 24211da177e4SLinus Torvalds } 24221da177e4SLinus Torvalds 2423cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 2424cbed0ca1SJohan Hedberg 2425cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 2426cbed0ca1SJohan Hedberg { 2427cbed0ca1SJohan Hedberg struct hci_dev *hdev; 2428cbed0ca1SJohan Hedberg int err; 2429cbed0ca1SJohan Hedberg 2430cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 2431cbed0ca1SJohan Hedberg if (!hdev) 2432cbed0ca1SJohan Hedberg return -ENODEV; 2433cbed0ca1SJohan Hedberg 24344a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 2435fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 2436fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 2437fee746b0SMarcel Holtmann * possible. 2438fee746b0SMarcel Holtmann * 2439fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 2440fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 2441fee746b0SMarcel Holtmann * open the device. 2442fee746b0SMarcel Holtmann */ 24434a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 2444fee746b0SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 2445fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2446fee746b0SMarcel Holtmann goto done; 2447fee746b0SMarcel Holtmann } 2448fee746b0SMarcel Holtmann 2449e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 2450e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 2451e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 2452e1d08f40SJohan Hedberg * completed. 2453e1d08f40SJohan Hedberg */ 2454e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 2455e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 2456e1d08f40SJohan Hedberg 2457a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 2458a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 2459a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 2460a5c8f270SMarcel Holtmann */ 2461e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 2462e1d08f40SJohan Hedberg 246312aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 246412aa4f0aSMarcel Holtmann * are brought up using legacy ioctl, set the HCI_PAIRABLE bit 246512aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 246612aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 246712aa4f0aSMarcel Holtmann * to explicitly enable it. 246812aa4f0aSMarcel Holtmann */ 246912aa4f0aSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 247012aa4f0aSMarcel Holtmann !test_bit(HCI_MGMT, &hdev->dev_flags)) 247112aa4f0aSMarcel Holtmann set_bit(HCI_PAIRABLE, &hdev->dev_flags); 247212aa4f0aSMarcel Holtmann 2473cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 2474cbed0ca1SJohan Hedberg 2475fee746b0SMarcel Holtmann done: 2476cbed0ca1SJohan Hedberg hci_dev_put(hdev); 2477cbed0ca1SJohan Hedberg return err; 2478cbed0ca1SJohan Hedberg } 2479cbed0ca1SJohan Hedberg 2480d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 2481d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 2482d7347f3cSJohan Hedberg { 2483d7347f3cSJohan Hedberg struct hci_conn_params *p; 2484d7347f3cSJohan Hedberg 2485d7347f3cSJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) 2486d7347f3cSJohan Hedberg list_del_init(&p->action); 2487d7347f3cSJohan Hedberg 2488d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 2489d7347f3cSJohan Hedberg } 2490d7347f3cSJohan Hedberg 24911da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 24921da177e4SLinus Torvalds { 24931da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 24941da177e4SLinus Torvalds 249578c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 249678c04c0bSVinicius Costa Gomes 24971da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 24981da177e4SLinus Torvalds hci_req_lock(hdev); 24991da177e4SLinus Torvalds 25001da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 250165cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 25021da177e4SLinus Torvalds hci_req_unlock(hdev); 25031da177e4SLinus Torvalds return 0; 25041da177e4SLinus Torvalds } 25051da177e4SLinus Torvalds 25063eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 25073eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2508b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 25091da177e4SLinus Torvalds 251016ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 2511e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 251216ab91abSJohan Hedberg hdev->discov_timeout = 0; 25135e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 2514310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 251516ab91abSJohan Hedberg } 251616ab91abSJohan Hedberg 2517a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 25187d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 25197d78525dSJohan Hedberg 25207ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 25214518bb0fSJohan Hedberg 25224518bb0fSJohan Hedberg if (test_bit(HCI_MGMT, &hdev->dev_flags)) 2523d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 25247ba8b4beSAndre Guedes 252509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 25261f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 25271da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 2528d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 252909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 25301da177e4SLinus Torvalds 25311da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 25321da177e4SLinus Torvalds 25331da177e4SLinus Torvalds if (hdev->flush) 25341da177e4SLinus Torvalds hdev->flush(hdev); 25351da177e4SLinus Torvalds 25361da177e4SLinus Torvalds /* Reset device */ 25371da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 25381da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 25394a964404SMarcel Holtmann if (!test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 25404a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 2541a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 25421da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 254301178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 25441da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 25451da177e4SLinus Torvalds } 25461da177e4SLinus Torvalds 2547c347b765SGustavo F. Padovan /* flush cmd work */ 2548c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 25491da177e4SLinus Torvalds 25501da177e4SLinus Torvalds /* Drop queues */ 25511da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 25521da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 25531da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 25541da177e4SLinus Torvalds 25551da177e4SLinus Torvalds /* Drop last sent command */ 25561da177e4SLinus Torvalds if (hdev->sent_cmd) { 255765cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 25581da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 25591da177e4SLinus Torvalds hdev->sent_cmd = NULL; 25601da177e4SLinus Torvalds } 25611da177e4SLinus Torvalds 2562b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 2563b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 2564b6ddb638SJohan Hedberg 25651da177e4SLinus Torvalds /* After this point our queues are empty 25661da177e4SLinus Torvalds * and no tasks are scheduled. */ 25671da177e4SLinus Torvalds hdev->close(hdev); 25681da177e4SLinus Torvalds 256935b973c9SJohan Hedberg /* Clear flags */ 2570fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 257135b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 257235b973c9SJohan Hedberg 257393c311a0SMarcel Holtmann if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 257493c311a0SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 257509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2576744cf19eSJohan Hedberg mgmt_powered(hdev, 0); 257709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 25788ee56540SMarcel Holtmann } 257993c311a0SMarcel Holtmann } 25805add6af8SJohan Hedberg 2581ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 2582536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 2583ced5c338SAndrei Emeltchenko 2584e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 258509b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 25867a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 2587e59fda8dSJohan Hedberg 25881da177e4SLinus Torvalds hci_req_unlock(hdev); 25891da177e4SLinus Torvalds 25901da177e4SLinus Torvalds hci_dev_put(hdev); 25911da177e4SLinus Torvalds return 0; 25921da177e4SLinus Torvalds } 25931da177e4SLinus Torvalds 25941da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 25951da177e4SLinus Torvalds { 25961da177e4SLinus Torvalds struct hci_dev *hdev; 25971da177e4SLinus Torvalds int err; 25981da177e4SLinus Torvalds 259970f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 260070f23020SAndrei Emeltchenko if (!hdev) 26011da177e4SLinus Torvalds return -ENODEV; 26028ee56540SMarcel Holtmann 26030736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 26040736cfa8SMarcel Holtmann err = -EBUSY; 26050736cfa8SMarcel Holtmann goto done; 26060736cfa8SMarcel Holtmann } 26070736cfa8SMarcel Holtmann 26088ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 26098ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 26108ee56540SMarcel Holtmann 26111da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 26128ee56540SMarcel Holtmann 26130736cfa8SMarcel Holtmann done: 26141da177e4SLinus Torvalds hci_dev_put(hdev); 26151da177e4SLinus Torvalds return err; 26161da177e4SLinus Torvalds } 26171da177e4SLinus Torvalds 26181da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 26191da177e4SLinus Torvalds { 26201da177e4SLinus Torvalds struct hci_dev *hdev; 26211da177e4SLinus Torvalds int ret = 0; 26221da177e4SLinus Torvalds 262370f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 262470f23020SAndrei Emeltchenko if (!hdev) 26251da177e4SLinus Torvalds return -ENODEV; 26261da177e4SLinus Torvalds 26271da177e4SLinus Torvalds hci_req_lock(hdev); 26281da177e4SLinus Torvalds 2629808a049eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 2630808a049eSMarcel Holtmann ret = -ENETDOWN; 26311da177e4SLinus Torvalds goto done; 2632808a049eSMarcel Holtmann } 26331da177e4SLinus Torvalds 26340736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 26350736cfa8SMarcel Holtmann ret = -EBUSY; 26360736cfa8SMarcel Holtmann goto done; 26370736cfa8SMarcel Holtmann } 26380736cfa8SMarcel Holtmann 26394a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2640fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2641fee746b0SMarcel Holtmann goto done; 2642fee746b0SMarcel Holtmann } 2643fee746b0SMarcel Holtmann 26441da177e4SLinus Torvalds /* Drop queues */ 26451da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 26461da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 26471da177e4SLinus Torvalds 264809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 26491f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 26501da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 265109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 26521da177e4SLinus Torvalds 26531da177e4SLinus Torvalds if (hdev->flush) 26541da177e4SLinus Torvalds hdev->flush(hdev); 26551da177e4SLinus Torvalds 26561da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 26576ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 26581da177e4SLinus Torvalds 265901178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 26601da177e4SLinus Torvalds 26611da177e4SLinus Torvalds done: 26621da177e4SLinus Torvalds hci_req_unlock(hdev); 26631da177e4SLinus Torvalds hci_dev_put(hdev); 26641da177e4SLinus Torvalds return ret; 26651da177e4SLinus Torvalds } 26661da177e4SLinus Torvalds 26671da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 26681da177e4SLinus Torvalds { 26691da177e4SLinus Torvalds struct hci_dev *hdev; 26701da177e4SLinus Torvalds int ret = 0; 26711da177e4SLinus Torvalds 267270f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 267370f23020SAndrei Emeltchenko if (!hdev) 26741da177e4SLinus Torvalds return -ENODEV; 26751da177e4SLinus Torvalds 26760736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 26770736cfa8SMarcel Holtmann ret = -EBUSY; 26780736cfa8SMarcel Holtmann goto done; 26790736cfa8SMarcel Holtmann } 26800736cfa8SMarcel Holtmann 26814a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2682fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2683fee746b0SMarcel Holtmann goto done; 2684fee746b0SMarcel Holtmann } 2685fee746b0SMarcel Holtmann 26861da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 26871da177e4SLinus Torvalds 26880736cfa8SMarcel Holtmann done: 26891da177e4SLinus Torvalds hci_dev_put(hdev); 26901da177e4SLinus Torvalds return ret; 26911da177e4SLinus Torvalds } 26921da177e4SLinus Torvalds 2693123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 2694123abc08SJohan Hedberg { 2695bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 2696123abc08SJohan Hedberg 2697123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 2698123abc08SJohan Hedberg 2699123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 2700123abc08SJohan Hedberg conn_changed = !test_and_set_bit(HCI_CONNECTABLE, 2701123abc08SJohan Hedberg &hdev->dev_flags); 2702123abc08SJohan Hedberg else 2703123abc08SJohan Hedberg conn_changed = test_and_clear_bit(HCI_CONNECTABLE, 2704123abc08SJohan Hedberg &hdev->dev_flags); 2705123abc08SJohan Hedberg 2706bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 2707bc6d2d04SJohan Hedberg discov_changed = !test_and_set_bit(HCI_DISCOVERABLE, 2708bc6d2d04SJohan Hedberg &hdev->dev_flags); 2709bc6d2d04SJohan Hedberg } else { 2710bc6d2d04SJohan Hedberg clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 2711bc6d2d04SJohan Hedberg discov_changed = test_and_clear_bit(HCI_DISCOVERABLE, 2712bc6d2d04SJohan Hedberg &hdev->dev_flags); 2713bc6d2d04SJohan Hedberg } 2714bc6d2d04SJohan Hedberg 2715123abc08SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 2716123abc08SJohan Hedberg return; 2717123abc08SJohan Hedberg 2718bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 2719bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 2720bc6d2d04SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 2721bc6d2d04SJohan Hedberg 2722bc6d2d04SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 2723bc6d2d04SJohan Hedberg mgmt_update_adv_data(hdev); 2724bc6d2d04SJohan Hedberg 2725123abc08SJohan Hedberg mgmt_new_settings(hdev); 2726123abc08SJohan Hedberg } 2727bc6d2d04SJohan Hedberg } 2728123abc08SJohan Hedberg 27291da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 27301da177e4SLinus Torvalds { 27311da177e4SLinus Torvalds struct hci_dev *hdev; 27321da177e4SLinus Torvalds struct hci_dev_req dr; 27331da177e4SLinus Torvalds int err = 0; 27341da177e4SLinus Torvalds 27351da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 27361da177e4SLinus Torvalds return -EFAULT; 27371da177e4SLinus Torvalds 273870f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 273970f23020SAndrei Emeltchenko if (!hdev) 27401da177e4SLinus Torvalds return -ENODEV; 27411da177e4SLinus Torvalds 27420736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 27430736cfa8SMarcel Holtmann err = -EBUSY; 27440736cfa8SMarcel Holtmann goto done; 27450736cfa8SMarcel Holtmann } 27460736cfa8SMarcel Holtmann 27474a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2748fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2749fee746b0SMarcel Holtmann goto done; 2750fee746b0SMarcel Holtmann } 2751fee746b0SMarcel Holtmann 27525b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 27535b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 27545b69bef5SMarcel Holtmann goto done; 27555b69bef5SMarcel Holtmann } 27565b69bef5SMarcel Holtmann 275756f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 275856f87901SJohan Hedberg err = -EOPNOTSUPP; 275956f87901SJohan Hedberg goto done; 276056f87901SJohan Hedberg } 276156f87901SJohan Hedberg 27621da177e4SLinus Torvalds switch (cmd) { 27631da177e4SLinus Torvalds case HCISETAUTH: 276401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 27655f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27661da177e4SLinus Torvalds break; 27671da177e4SLinus Torvalds 27681da177e4SLinus Torvalds case HCISETENCRYPT: 27691da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 27701da177e4SLinus Torvalds err = -EOPNOTSUPP; 27711da177e4SLinus Torvalds break; 27721da177e4SLinus Torvalds } 27731da177e4SLinus Torvalds 27741da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 27751da177e4SLinus Torvalds /* Auth must be enabled first */ 277601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 27775f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27781da177e4SLinus Torvalds if (err) 27791da177e4SLinus Torvalds break; 27801da177e4SLinus Torvalds } 27811da177e4SLinus Torvalds 278201178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 27835f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27841da177e4SLinus Torvalds break; 27851da177e4SLinus Torvalds 27861da177e4SLinus Torvalds case HCISETSCAN: 278701178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 27885f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 278991a668b0SJohan Hedberg 2790bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 2791bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 279291a668b0SJohan Hedberg */ 2793123abc08SJohan Hedberg if (!err) 2794123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 27951da177e4SLinus Torvalds break; 27961da177e4SLinus Torvalds 27971da177e4SLinus Torvalds case HCISETLINKPOL: 279801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 27995f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 28001da177e4SLinus Torvalds break; 28011da177e4SLinus Torvalds 28021da177e4SLinus Torvalds case HCISETLINKMODE: 2803e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 2804e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 2805e4e8e37cSMarcel Holtmann break; 2806e4e8e37cSMarcel Holtmann 2807e4e8e37cSMarcel Holtmann case HCISETPTYPE: 2808e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 28091da177e4SLinus Torvalds break; 28101da177e4SLinus Torvalds 28111da177e4SLinus Torvalds case HCISETACLMTU: 28121da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 28131da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 28141da177e4SLinus Torvalds break; 28151da177e4SLinus Torvalds 28161da177e4SLinus Torvalds case HCISETSCOMTU: 28171da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 28181da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 28191da177e4SLinus Torvalds break; 28201da177e4SLinus Torvalds 28211da177e4SLinus Torvalds default: 28221da177e4SLinus Torvalds err = -EINVAL; 28231da177e4SLinus Torvalds break; 28241da177e4SLinus Torvalds } 2825e4e8e37cSMarcel Holtmann 28260736cfa8SMarcel Holtmann done: 28271da177e4SLinus Torvalds hci_dev_put(hdev); 28281da177e4SLinus Torvalds return err; 28291da177e4SLinus Torvalds } 28301da177e4SLinus Torvalds 28311da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 28321da177e4SLinus Torvalds { 28338035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 28341da177e4SLinus Torvalds struct hci_dev_list_req *dl; 28351da177e4SLinus Torvalds struct hci_dev_req *dr; 28361da177e4SLinus Torvalds int n = 0, size, err; 28371da177e4SLinus Torvalds __u16 dev_num; 28381da177e4SLinus Torvalds 28391da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 28401da177e4SLinus Torvalds return -EFAULT; 28411da177e4SLinus Torvalds 28421da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 28431da177e4SLinus Torvalds return -EINVAL; 28441da177e4SLinus Torvalds 28451da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 28461da177e4SLinus Torvalds 284770f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 284870f23020SAndrei Emeltchenko if (!dl) 28491da177e4SLinus Torvalds return -ENOMEM; 28501da177e4SLinus Torvalds 28511da177e4SLinus Torvalds dr = dl->dev_req; 28521da177e4SLinus Torvalds 2853f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 28548035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 28552e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 28562e84d8dbSMarcel Holtmann 28572e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 28582e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 28592e84d8dbSMarcel Holtmann * device is actually down. 28602e84d8dbSMarcel Holtmann */ 28612e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 28622e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 2863c542a06cSJohan Hedberg 28641da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 28652e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 2866c542a06cSJohan Hedberg 28671da177e4SLinus Torvalds if (++n >= dev_num) 28681da177e4SLinus Torvalds break; 28691da177e4SLinus Torvalds } 2870f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 28711da177e4SLinus Torvalds 28721da177e4SLinus Torvalds dl->dev_num = n; 28731da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 28741da177e4SLinus Torvalds 28751da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 28761da177e4SLinus Torvalds kfree(dl); 28771da177e4SLinus Torvalds 28781da177e4SLinus Torvalds return err ? -EFAULT : 0; 28791da177e4SLinus Torvalds } 28801da177e4SLinus Torvalds 28811da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 28821da177e4SLinus Torvalds { 28831da177e4SLinus Torvalds struct hci_dev *hdev; 28841da177e4SLinus Torvalds struct hci_dev_info di; 28852e84d8dbSMarcel Holtmann unsigned long flags; 28861da177e4SLinus Torvalds int err = 0; 28871da177e4SLinus Torvalds 28881da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 28891da177e4SLinus Torvalds return -EFAULT; 28901da177e4SLinus Torvalds 289170f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 289270f23020SAndrei Emeltchenko if (!hdev) 28931da177e4SLinus Torvalds return -ENODEV; 28941da177e4SLinus Torvalds 28952e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 28962e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 28972e84d8dbSMarcel Holtmann * device is actually down. 28982e84d8dbSMarcel Holtmann */ 28992e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 29002e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 29012e84d8dbSMarcel Holtmann else 29022e84d8dbSMarcel Holtmann flags = hdev->flags; 2903ab81cbf9SJohan Hedberg 29041da177e4SLinus Torvalds strcpy(di.name, hdev->name); 29051da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 290660f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 29072e84d8dbSMarcel Holtmann di.flags = flags; 29081da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2909572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 29101da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 29111da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 29121da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 29131da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2914572c7f84SJohan Hedberg } else { 2915572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2916572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2917572c7f84SJohan Hedberg di.sco_mtu = 0; 2918572c7f84SJohan Hedberg di.sco_pkts = 0; 2919572c7f84SJohan Hedberg } 29201da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 29211da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 29221da177e4SLinus Torvalds 29231da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 29241da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 29251da177e4SLinus Torvalds 29261da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 29271da177e4SLinus Torvalds err = -EFAULT; 29281da177e4SLinus Torvalds 29291da177e4SLinus Torvalds hci_dev_put(hdev); 29301da177e4SLinus Torvalds 29311da177e4SLinus Torvalds return err; 29321da177e4SLinus Torvalds } 29331da177e4SLinus Torvalds 29341da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 29351da177e4SLinus Torvalds 2936611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2937611b30f7SMarcel Holtmann { 2938611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2939611b30f7SMarcel Holtmann 2940611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2941611b30f7SMarcel Holtmann 29420736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 29430736cfa8SMarcel Holtmann return -EBUSY; 29440736cfa8SMarcel Holtmann 29455e130367SJohan Hedberg if (blocked) { 29465e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 2947d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2948d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) 2949611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 29505e130367SJohan Hedberg } else { 29515e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 29525e130367SJohan Hedberg } 2953611b30f7SMarcel Holtmann 2954611b30f7SMarcel Holtmann return 0; 2955611b30f7SMarcel Holtmann } 2956611b30f7SMarcel Holtmann 2957611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2958611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2959611b30f7SMarcel Holtmann }; 2960611b30f7SMarcel Holtmann 2961ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2962ab81cbf9SJohan Hedberg { 2963ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 296496570ffcSJohan Hedberg int err; 2965ab81cbf9SJohan Hedberg 2966ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2967ab81cbf9SJohan Hedberg 2968cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 296996570ffcSJohan Hedberg if (err < 0) { 297096570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 2971ab81cbf9SJohan Hedberg return; 297296570ffcSJohan Hedberg } 2973ab81cbf9SJohan Hedberg 2974a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2975a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2976a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2977a5c8f270SMarcel Holtmann */ 2978a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 29794a964404SMarcel Holtmann test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) || 2980a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 2981a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2982a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2983bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2984bf543036SJohan Hedberg hci_dev_do_close(hdev); 2985bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 298619202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 298719202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2988bf543036SJohan Hedberg } 2989ab81cbf9SJohan Hedberg 2990fee746b0SMarcel Holtmann if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) { 29914a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 29924a964404SMarcel Holtmann * so that userspace can easily identify them. 29934a964404SMarcel Holtmann */ 29944a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 29954a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 29960602a8adSMarcel Holtmann 29970602a8adSMarcel Holtmann /* For fully configured devices, this will send 29980602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 29990602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 30000602a8adSMarcel Holtmann * 30010602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 30020602a8adSMarcel Holtmann * and no event will be send. 30030602a8adSMarcel Holtmann */ 3004744cf19eSJohan Hedberg mgmt_index_added(hdev); 3005d603b76bSMarcel Holtmann } else if (test_and_clear_bit(HCI_CONFIG, &hdev->dev_flags)) { 30065ea234d3SMarcel Holtmann /* When the controller is now configured, then it 30075ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 30085ea234d3SMarcel Holtmann */ 30095ea234d3SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 30105ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 30115ea234d3SMarcel Holtmann 3012d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 3013d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 3014d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 3015d603b76bSMarcel Holtmann */ 3016d603b76bSMarcel Holtmann mgmt_index_added(hdev); 3017ab81cbf9SJohan Hedberg } 3018fee746b0SMarcel Holtmann } 3019ab81cbf9SJohan Hedberg 3020ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 3021ab81cbf9SJohan Hedberg { 30223243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 30233243553fSJohan Hedberg power_off.work); 3024ab81cbf9SJohan Hedberg 3025ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 3026ab81cbf9SJohan Hedberg 30278ee56540SMarcel Holtmann hci_dev_do_close(hdev); 3028ab81cbf9SJohan Hedberg } 3029ab81cbf9SJohan Hedberg 303016ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 303116ab91abSJohan Hedberg { 303216ab91abSJohan Hedberg struct hci_dev *hdev; 303316ab91abSJohan Hedberg 303416ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 303516ab91abSJohan Hedberg 303616ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 303716ab91abSJohan Hedberg 3038d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 303916ab91abSJohan Hedberg } 304016ab91abSJohan Hedberg 304135f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 30422aeb9a1aSJohan Hedberg { 30434821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 30442aeb9a1aSJohan Hedberg 30454821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 30464821002cSJohan Hedberg list_del(&uuid->list); 30472aeb9a1aSJohan Hedberg kfree(uuid); 30482aeb9a1aSJohan Hedberg } 30492aeb9a1aSJohan Hedberg } 30502aeb9a1aSJohan Hedberg 305135f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 305255ed8ca1SJohan Hedberg { 305355ed8ca1SJohan Hedberg struct list_head *p, *n; 305455ed8ca1SJohan Hedberg 305555ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 305655ed8ca1SJohan Hedberg struct link_key *key; 305755ed8ca1SJohan Hedberg 305855ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 305955ed8ca1SJohan Hedberg 306055ed8ca1SJohan Hedberg list_del(p); 306155ed8ca1SJohan Hedberg kfree(key); 306255ed8ca1SJohan Hedberg } 306355ed8ca1SJohan Hedberg } 306455ed8ca1SJohan Hedberg 306535f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 3066b899efafSVinicius Costa Gomes { 3067b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 3068b899efafSVinicius Costa Gomes 3069b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 3070b899efafSVinicius Costa Gomes list_del(&k->list); 3071b899efafSVinicius Costa Gomes kfree(k); 3072b899efafSVinicius Costa Gomes } 3073b899efafSVinicius Costa Gomes } 3074b899efafSVinicius Costa Gomes 3075970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 3076970c4e46SJohan Hedberg { 3077970c4e46SJohan Hedberg struct smp_irk *k, *tmp; 3078970c4e46SJohan Hedberg 3079970c4e46SJohan Hedberg list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) { 3080970c4e46SJohan Hedberg list_del(&k->list); 3081970c4e46SJohan Hedberg kfree(k); 3082970c4e46SJohan Hedberg } 3083970c4e46SJohan Hedberg } 3084970c4e46SJohan Hedberg 308555ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 308655ed8ca1SJohan Hedberg { 308755ed8ca1SJohan Hedberg struct link_key *k; 308855ed8ca1SJohan Hedberg 30898035ded4SLuiz Augusto von Dentz list_for_each_entry(k, &hdev->link_keys, list) 309055ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 309155ed8ca1SJohan Hedberg return k; 309255ed8ca1SJohan Hedberg 309355ed8ca1SJohan Hedberg return NULL; 309455ed8ca1SJohan Hedberg } 309555ed8ca1SJohan Hedberg 3096745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 3097d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 3098d25e28abSJohan Hedberg { 3099d25e28abSJohan Hedberg /* Legacy key */ 3100d25e28abSJohan Hedberg if (key_type < 0x03) 3101745c0ce3SVishal Agarwal return true; 3102d25e28abSJohan Hedberg 3103d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 3104d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 3105745c0ce3SVishal Agarwal return false; 3106d25e28abSJohan Hedberg 3107d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 3108d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 3109745c0ce3SVishal Agarwal return false; 3110d25e28abSJohan Hedberg 3111d25e28abSJohan Hedberg /* Security mode 3 case */ 3112d25e28abSJohan Hedberg if (!conn) 3113745c0ce3SVishal Agarwal return true; 3114d25e28abSJohan Hedberg 3115d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 3116d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 3117745c0ce3SVishal Agarwal return true; 3118d25e28abSJohan Hedberg 3119d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 3120d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 3121745c0ce3SVishal Agarwal return true; 3122d25e28abSJohan Hedberg 3123d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 3124d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 3125745c0ce3SVishal Agarwal return true; 3126d25e28abSJohan Hedberg 3127d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 3128d25e28abSJohan Hedberg * persistently */ 3129745c0ce3SVishal Agarwal return false; 3130d25e28abSJohan Hedberg } 3131d25e28abSJohan Hedberg 3132e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 313398a0b845SJohan Hedberg { 3134e804d25dSJohan Hedberg if (type == SMP_LTK) 3135e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 3136e804d25dSJohan Hedberg 3137e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 313898a0b845SJohan Hedberg } 313998a0b845SJohan Hedberg 3140fe39c7b2SMarcel Holtmann struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, __le64 rand, 3141e804d25dSJohan Hedberg u8 role) 314275d262c2SVinicius Costa Gomes { 3143c9839a11SVinicius Costa Gomes struct smp_ltk *k; 314475d262c2SVinicius Costa Gomes 3145c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) { 3146fe39c7b2SMarcel Holtmann if (k->ediv != ediv || k->rand != rand) 314775d262c2SVinicius Costa Gomes continue; 314875d262c2SVinicius Costa Gomes 3149e804d25dSJohan Hedberg if (ltk_role(k->type) != role) 315098a0b845SJohan Hedberg continue; 315198a0b845SJohan Hedberg 315275d262c2SVinicius Costa Gomes return k; 315375d262c2SVinicius Costa Gomes } 315475d262c2SVinicius Costa Gomes 315575d262c2SVinicius Costa Gomes return NULL; 315675d262c2SVinicius Costa Gomes } 315775d262c2SVinicius Costa Gomes 3158c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 3159e804d25dSJohan Hedberg u8 addr_type, u8 role) 316075d262c2SVinicius Costa Gomes { 3161c9839a11SVinicius Costa Gomes struct smp_ltk *k; 316275d262c2SVinicius Costa Gomes 3163c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) 3164c9839a11SVinicius Costa Gomes if (addr_type == k->bdaddr_type && 316598a0b845SJohan Hedberg bacmp(bdaddr, &k->bdaddr) == 0 && 3166e804d25dSJohan Hedberg ltk_role(k->type) == role) 316775d262c2SVinicius Costa Gomes return k; 316875d262c2SVinicius Costa Gomes 316975d262c2SVinicius Costa Gomes return NULL; 317075d262c2SVinicius Costa Gomes } 317175d262c2SVinicius Costa Gomes 3172970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 3173970c4e46SJohan Hedberg { 3174970c4e46SJohan Hedberg struct smp_irk *irk; 3175970c4e46SJohan Hedberg 3176970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3177970c4e46SJohan Hedberg if (!bacmp(&irk->rpa, rpa)) 3178970c4e46SJohan Hedberg return irk; 3179970c4e46SJohan Hedberg } 3180970c4e46SJohan Hedberg 3181970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3182970c4e46SJohan Hedberg if (smp_irk_matches(hdev->tfm_aes, irk->val, rpa)) { 3183970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 3184970c4e46SJohan Hedberg return irk; 3185970c4e46SJohan Hedberg } 3186970c4e46SJohan Hedberg } 3187970c4e46SJohan Hedberg 3188970c4e46SJohan Hedberg return NULL; 3189970c4e46SJohan Hedberg } 3190970c4e46SJohan Hedberg 3191970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 3192970c4e46SJohan Hedberg u8 addr_type) 3193970c4e46SJohan Hedberg { 3194970c4e46SJohan Hedberg struct smp_irk *irk; 3195970c4e46SJohan Hedberg 31966cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 31976cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 31986cfc9988SJohan Hedberg return NULL; 31996cfc9988SJohan Hedberg 3200970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3201970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 3202970c4e46SJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) 3203970c4e46SJohan Hedberg return irk; 3204970c4e46SJohan Hedberg } 3205970c4e46SJohan Hedberg 3206970c4e46SJohan Hedberg return NULL; 3207970c4e46SJohan Hedberg } 3208970c4e46SJohan Hedberg 3209567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 32107652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 32117652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 321255ed8ca1SJohan Hedberg { 321355ed8ca1SJohan Hedberg struct link_key *key, *old_key; 3214745c0ce3SVishal Agarwal u8 old_key_type; 321555ed8ca1SJohan Hedberg 321655ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 321755ed8ca1SJohan Hedberg if (old_key) { 321855ed8ca1SJohan Hedberg old_key_type = old_key->type; 321955ed8ca1SJohan Hedberg key = old_key; 322055ed8ca1SJohan Hedberg } else { 322112adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 32220a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 322355ed8ca1SJohan Hedberg if (!key) 3224567fa2aaSJohan Hedberg return NULL; 322555ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 322655ed8ca1SJohan Hedberg } 322755ed8ca1SJohan Hedberg 32286ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 322955ed8ca1SJohan Hedberg 3230d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 3231d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 3232d25e28abSJohan Hedberg * previous key */ 3233d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 3234a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 3235d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 3236655fe6ecSJohan Hedberg if (conn) 3237655fe6ecSJohan Hedberg conn->key_type = type; 3238655fe6ecSJohan Hedberg } 3239d25e28abSJohan Hedberg 324055ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 32419b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 324255ed8ca1SJohan Hedberg key->pin_len = pin_len; 324355ed8ca1SJohan Hedberg 3244b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 324555ed8ca1SJohan Hedberg key->type = old_key_type; 32464748fed2SJohan Hedberg else 32474748fed2SJohan Hedberg key->type = type; 32484748fed2SJohan Hedberg 32497652ff6aSJohan Hedberg if (persistent) 32507652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 32517652ff6aSJohan Hedberg old_key_type); 325255ed8ca1SJohan Hedberg 3253567fa2aaSJohan Hedberg return key; 325455ed8ca1SJohan Hedberg } 325555ed8ca1SJohan Hedberg 3256ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 325735d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 3258fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 325975d262c2SVinicius Costa Gomes { 3260c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 3261e804d25dSJohan Hedberg u8 role = ltk_role(type); 326275d262c2SVinicius Costa Gomes 3263e804d25dSJohan Hedberg old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type, role); 3264c9839a11SVinicius Costa Gomes if (old_key) 326575d262c2SVinicius Costa Gomes key = old_key; 3266c9839a11SVinicius Costa Gomes else { 32670a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 326875d262c2SVinicius Costa Gomes if (!key) 3269ca9142b8SJohan Hedberg return NULL; 3270c9839a11SVinicius Costa Gomes list_add(&key->list, &hdev->long_term_keys); 327175d262c2SVinicius Costa Gomes } 327275d262c2SVinicius Costa Gomes 327375d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 3274c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 3275c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 3276c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 3277c9839a11SVinicius Costa Gomes key->ediv = ediv; 3278fe39c7b2SMarcel Holtmann key->rand = rand; 3279c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 3280c9839a11SVinicius Costa Gomes key->type = type; 328175d262c2SVinicius Costa Gomes 3282ca9142b8SJohan Hedberg return key; 328375d262c2SVinicius Costa Gomes } 328475d262c2SVinicius Costa Gomes 3285ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 3286ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 3287970c4e46SJohan Hedberg { 3288970c4e46SJohan Hedberg struct smp_irk *irk; 3289970c4e46SJohan Hedberg 3290970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 3291970c4e46SJohan Hedberg if (!irk) { 3292970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 3293970c4e46SJohan Hedberg if (!irk) 3294ca9142b8SJohan Hedberg return NULL; 3295970c4e46SJohan Hedberg 3296970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 3297970c4e46SJohan Hedberg irk->addr_type = addr_type; 3298970c4e46SJohan Hedberg 3299970c4e46SJohan Hedberg list_add(&irk->list, &hdev->identity_resolving_keys); 3300970c4e46SJohan Hedberg } 3301970c4e46SJohan Hedberg 3302970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 3303970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 3304970c4e46SJohan Hedberg 3305ca9142b8SJohan Hedberg return irk; 3306970c4e46SJohan Hedberg } 3307970c4e46SJohan Hedberg 330855ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 330955ed8ca1SJohan Hedberg { 331055ed8ca1SJohan Hedberg struct link_key *key; 331155ed8ca1SJohan Hedberg 331255ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 331355ed8ca1SJohan Hedberg if (!key) 331455ed8ca1SJohan Hedberg return -ENOENT; 331555ed8ca1SJohan Hedberg 33166ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 331755ed8ca1SJohan Hedberg 331855ed8ca1SJohan Hedberg list_del(&key->list); 331955ed8ca1SJohan Hedberg kfree(key); 332055ed8ca1SJohan Hedberg 332155ed8ca1SJohan Hedberg return 0; 332255ed8ca1SJohan Hedberg } 332355ed8ca1SJohan Hedberg 3324e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 3325b899efafSVinicius Costa Gomes { 3326b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 3327c51ffa0bSJohan Hedberg int removed = 0; 3328b899efafSVinicius Costa Gomes 3329b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 3330e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 3331b899efafSVinicius Costa Gomes continue; 3332b899efafSVinicius Costa Gomes 33336ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3334b899efafSVinicius Costa Gomes 3335b899efafSVinicius Costa Gomes list_del(&k->list); 3336b899efafSVinicius Costa Gomes kfree(k); 3337c51ffa0bSJohan Hedberg removed++; 3338b899efafSVinicius Costa Gomes } 3339b899efafSVinicius Costa Gomes 3340c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 3341b899efafSVinicius Costa Gomes } 3342b899efafSVinicius Costa Gomes 3343a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 3344a7ec7338SJohan Hedberg { 3345a7ec7338SJohan Hedberg struct smp_irk *k, *tmp; 3346a7ec7338SJohan Hedberg 3347668b7b19SJohan Hedberg list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) { 3348a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 3349a7ec7338SJohan Hedberg continue; 3350a7ec7338SJohan Hedberg 3351a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3352a7ec7338SJohan Hedberg 3353a7ec7338SJohan Hedberg list_del(&k->list); 3354a7ec7338SJohan Hedberg kfree(k); 3355a7ec7338SJohan Hedberg } 3356a7ec7338SJohan Hedberg } 3357a7ec7338SJohan Hedberg 33586bd32326SVille Tervo /* HCI command timer function */ 335965cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 33606bd32326SVille Tervo { 336165cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 336265cc2b49SMarcel Holtmann cmd_timer.work); 33636bd32326SVille Tervo 3364bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 3365bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 3366bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 3367bda4f23aSAndrei Emeltchenko 3368bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 3369bda4f23aSAndrei Emeltchenko } else { 33706bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 3371bda4f23aSAndrei Emeltchenko } 3372bda4f23aSAndrei Emeltchenko 33736bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 3374c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 33756bd32326SVille Tervo } 33766bd32326SVille Tervo 33772763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 33782763eda6SSzymon Janc bdaddr_t *bdaddr) 33792763eda6SSzymon Janc { 33802763eda6SSzymon Janc struct oob_data *data; 33812763eda6SSzymon Janc 33822763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 33832763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 33842763eda6SSzymon Janc return data; 33852763eda6SSzymon Janc 33862763eda6SSzymon Janc return NULL; 33872763eda6SSzymon Janc } 33882763eda6SSzymon Janc 33892763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 33902763eda6SSzymon Janc { 33912763eda6SSzymon Janc struct oob_data *data; 33922763eda6SSzymon Janc 33932763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 33942763eda6SSzymon Janc if (!data) 33952763eda6SSzymon Janc return -ENOENT; 33962763eda6SSzymon Janc 33976ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 33982763eda6SSzymon Janc 33992763eda6SSzymon Janc list_del(&data->list); 34002763eda6SSzymon Janc kfree(data); 34012763eda6SSzymon Janc 34022763eda6SSzymon Janc return 0; 34032763eda6SSzymon Janc } 34042763eda6SSzymon Janc 340535f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 34062763eda6SSzymon Janc { 34072763eda6SSzymon Janc struct oob_data *data, *n; 34082763eda6SSzymon Janc 34092763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 34102763eda6SSzymon Janc list_del(&data->list); 34112763eda6SSzymon Janc kfree(data); 34122763eda6SSzymon Janc } 34132763eda6SSzymon Janc } 34142763eda6SSzymon Janc 34150798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 34160798872eSMarcel Holtmann u8 *hash, u8 *randomizer) 34172763eda6SSzymon Janc { 34182763eda6SSzymon Janc struct oob_data *data; 34192763eda6SSzymon Janc 34202763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 34212763eda6SSzymon Janc if (!data) { 34220a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 34232763eda6SSzymon Janc if (!data) 34242763eda6SSzymon Janc return -ENOMEM; 34252763eda6SSzymon Janc 34262763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 34272763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 34282763eda6SSzymon Janc } 34292763eda6SSzymon Janc 3430519ca9d0SMarcel Holtmann memcpy(data->hash192, hash, sizeof(data->hash192)); 3431519ca9d0SMarcel Holtmann memcpy(data->randomizer192, randomizer, sizeof(data->randomizer192)); 34322763eda6SSzymon Janc 34330798872eSMarcel Holtmann memset(data->hash256, 0, sizeof(data->hash256)); 34340798872eSMarcel Holtmann memset(data->randomizer256, 0, sizeof(data->randomizer256)); 34350798872eSMarcel Holtmann 34360798872eSMarcel Holtmann BT_DBG("%s for %pMR", hdev->name, bdaddr); 34370798872eSMarcel Holtmann 34380798872eSMarcel Holtmann return 0; 34390798872eSMarcel Holtmann } 34400798872eSMarcel Holtmann 34410798872eSMarcel Holtmann int hci_add_remote_oob_ext_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 34420798872eSMarcel Holtmann u8 *hash192, u8 *randomizer192, 34430798872eSMarcel Holtmann u8 *hash256, u8 *randomizer256) 34440798872eSMarcel Holtmann { 34450798872eSMarcel Holtmann struct oob_data *data; 34460798872eSMarcel Holtmann 34470798872eSMarcel Holtmann data = hci_find_remote_oob_data(hdev, bdaddr); 34480798872eSMarcel Holtmann if (!data) { 34490a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 34500798872eSMarcel Holtmann if (!data) 34510798872eSMarcel Holtmann return -ENOMEM; 34520798872eSMarcel Holtmann 34530798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 34540798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 34550798872eSMarcel Holtmann } 34560798872eSMarcel Holtmann 34570798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 34580798872eSMarcel Holtmann memcpy(data->randomizer192, randomizer192, sizeof(data->randomizer192)); 34590798872eSMarcel Holtmann 34600798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 34610798872eSMarcel Holtmann memcpy(data->randomizer256, randomizer256, sizeof(data->randomizer256)); 34620798872eSMarcel Holtmann 34636ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 34642763eda6SSzymon Janc 34652763eda6SSzymon Janc return 0; 34662763eda6SSzymon Janc } 34672763eda6SSzymon Janc 3468dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 3469b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 3470b2a66aadSAntti Julku { 3471b2a66aadSAntti Julku struct bdaddr_list *b; 3472b2a66aadSAntti Julku 3473dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 3474b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 3475b2a66aadSAntti Julku return b; 3476b9ee0a78SMarcel Holtmann } 3477b2a66aadSAntti Julku 3478b2a66aadSAntti Julku return NULL; 3479b2a66aadSAntti Julku } 3480b2a66aadSAntti Julku 3481dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 3482b2a66aadSAntti Julku { 3483b2a66aadSAntti Julku struct list_head *p, *n; 3484b2a66aadSAntti Julku 3485dcc36c16SJohan Hedberg list_for_each_safe(p, n, bdaddr_list) { 3486b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 3487b2a66aadSAntti Julku 3488b2a66aadSAntti Julku list_del(p); 3489b2a66aadSAntti Julku kfree(b); 3490b2a66aadSAntti Julku } 3491b2a66aadSAntti Julku } 3492b2a66aadSAntti Julku 3493dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3494b2a66aadSAntti Julku { 3495b2a66aadSAntti Julku struct bdaddr_list *entry; 3496b2a66aadSAntti Julku 3497b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 3498b2a66aadSAntti Julku return -EBADF; 3499b2a66aadSAntti Julku 3500dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 35015e762444SAntti Julku return -EEXIST; 3502b2a66aadSAntti Julku 350327f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 35045e762444SAntti Julku if (!entry) 35055e762444SAntti Julku return -ENOMEM; 3506b2a66aadSAntti Julku 3507b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 3508b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 3509b2a66aadSAntti Julku 3510dcc36c16SJohan Hedberg list_add(&entry->list, list); 3511b2a66aadSAntti Julku 35122a8357f2SJohan Hedberg return 0; 3513b2a66aadSAntti Julku } 3514b2a66aadSAntti Julku 3515dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3516b2a66aadSAntti Julku { 3517b2a66aadSAntti Julku struct bdaddr_list *entry; 3518b2a66aadSAntti Julku 351935f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 3520dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 352135f7498aSJohan Hedberg return 0; 352235f7498aSJohan Hedberg } 3523b2a66aadSAntti Julku 3524dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 3525d2ab0ac1SMarcel Holtmann if (!entry) 3526d2ab0ac1SMarcel Holtmann return -ENOENT; 3527d2ab0ac1SMarcel Holtmann 3528d2ab0ac1SMarcel Holtmann list_del(&entry->list); 3529d2ab0ac1SMarcel Holtmann kfree(entry); 3530d2ab0ac1SMarcel Holtmann 3531d2ab0ac1SMarcel Holtmann return 0; 3532d2ab0ac1SMarcel Holtmann } 3533d2ab0ac1SMarcel Holtmann 353415819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 353515819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 353615819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 353715819a70SAndre Guedes { 353815819a70SAndre Guedes struct hci_conn_params *params; 353915819a70SAndre Guedes 3540738f6185SJohan Hedberg /* The conn params list only contains identity addresses */ 3541738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 3542738f6185SJohan Hedberg return NULL; 3543738f6185SJohan Hedberg 354415819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 354515819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 354615819a70SAndre Guedes params->addr_type == addr_type) { 354715819a70SAndre Guedes return params; 354815819a70SAndre Guedes } 354915819a70SAndre Guedes } 355015819a70SAndre Guedes 355115819a70SAndre Guedes return NULL; 355215819a70SAndre Guedes } 355315819a70SAndre Guedes 3554cef952ceSAndre Guedes static bool is_connected(struct hci_dev *hdev, bdaddr_t *addr, u8 type) 3555cef952ceSAndre Guedes { 3556cef952ceSAndre Guedes struct hci_conn *conn; 3557cef952ceSAndre Guedes 3558cef952ceSAndre Guedes conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, addr); 3559cef952ceSAndre Guedes if (!conn) 3560cef952ceSAndre Guedes return false; 3561cef952ceSAndre Guedes 3562cef952ceSAndre Guedes if (conn->dst_type != type) 3563cef952ceSAndre Guedes return false; 3564cef952ceSAndre Guedes 3565cef952ceSAndre Guedes if (conn->state != BT_CONNECTED) 3566cef952ceSAndre Guedes return false; 3567cef952ceSAndre Guedes 3568cef952ceSAndre Guedes return true; 3569cef952ceSAndre Guedes } 3570cef952ceSAndre Guedes 357115819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 3572501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 35734b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 35744b10966fSMarcel Holtmann { 3575912b42efSJohan Hedberg struct hci_conn_params *param; 35764b10966fSMarcel Holtmann 3577738f6185SJohan Hedberg /* The list only contains identity addresses */ 3578738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 3579738f6185SJohan Hedberg return NULL; 3580738f6185SJohan Hedberg 3581501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 3582912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 3583912b42efSJohan Hedberg param->addr_type == addr_type) 3584912b42efSJohan Hedberg return param; 35854b10966fSMarcel Holtmann } 35864b10966fSMarcel Holtmann 35874b10966fSMarcel Holtmann return NULL; 35884b10966fSMarcel Holtmann } 35894b10966fSMarcel Holtmann 35904b10966fSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 359151d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 359251d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 3593bf5b3c8bSMarcel Holtmann { 3594bf5b3c8bSMarcel Holtmann struct hci_conn_params *params; 3595bf5b3c8bSMarcel Holtmann 3596c46245b3SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 359751d167c0SMarcel Holtmann return NULL; 3598bf5b3c8bSMarcel Holtmann 3599bf5b3c8bSMarcel Holtmann params = hci_conn_params_lookup(hdev, addr, addr_type); 3600bf5b3c8bSMarcel Holtmann if (params) 360151d167c0SMarcel Holtmann return params; 3602bf5b3c8bSMarcel Holtmann 3603bf5b3c8bSMarcel Holtmann params = kzalloc(sizeof(*params), GFP_KERNEL); 3604bf5b3c8bSMarcel Holtmann if (!params) { 3605bf5b3c8bSMarcel Holtmann BT_ERR("Out of memory"); 360651d167c0SMarcel Holtmann return NULL; 3607bf5b3c8bSMarcel Holtmann } 3608bf5b3c8bSMarcel Holtmann 3609bf5b3c8bSMarcel Holtmann bacpy(¶ms->addr, addr); 3610bf5b3c8bSMarcel Holtmann params->addr_type = addr_type; 3611bf5b3c8bSMarcel Holtmann 3612bf5b3c8bSMarcel Holtmann list_add(¶ms->list, &hdev->le_conn_params); 361393450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 3614bf5b3c8bSMarcel Holtmann 3615bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 3616bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 3617bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 3618bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 3619bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 3620bf5b3c8bSMarcel Holtmann 3621bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 3622bf5b3c8bSMarcel Holtmann 362351d167c0SMarcel Holtmann return params; 3624bf5b3c8bSMarcel Holtmann } 3625bf5b3c8bSMarcel Holtmann 3626bf5b3c8bSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 3627bf5b3c8bSMarcel Holtmann int hci_conn_params_set(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type, 3628d06b50ceSMarcel Holtmann u8 auto_connect) 362915819a70SAndre Guedes { 363015819a70SAndre Guedes struct hci_conn_params *params; 363115819a70SAndre Guedes 36328c87aae1SMarcel Holtmann params = hci_conn_params_add(hdev, addr, addr_type); 36338c87aae1SMarcel Holtmann if (!params) 36348c87aae1SMarcel Holtmann return -EIO; 3635a9b0a04cSAndre Guedes 363642ce26deSJohan Hedberg if (params->auto_connect == auto_connect) 363742ce26deSJohan Hedberg return 0; 363842ce26deSJohan Hedberg 363966f8455aSJohan Hedberg list_del_init(¶ms->action); 364015819a70SAndre Guedes 3641cef952ceSAndre Guedes switch (auto_connect) { 3642cef952ceSAndre Guedes case HCI_AUTO_CONN_DISABLED: 3643cef952ceSAndre Guedes case HCI_AUTO_CONN_LINK_LOSS: 364495305baaSJohan Hedberg hci_update_background_scan(hdev); 3645cef952ceSAndre Guedes break; 3646851efca8SJohan Hedberg case HCI_AUTO_CONN_REPORT: 364795305baaSJohan Hedberg list_add(¶ms->action, &hdev->pend_le_reports); 364895305baaSJohan Hedberg hci_update_background_scan(hdev); 3649851efca8SJohan Hedberg break; 3650cef952ceSAndre Guedes case HCI_AUTO_CONN_ALWAYS: 365195305baaSJohan Hedberg if (!is_connected(hdev, addr, addr_type)) { 365295305baaSJohan Hedberg list_add(¶ms->action, &hdev->pend_le_conns); 365395305baaSJohan Hedberg hci_update_background_scan(hdev); 365495305baaSJohan Hedberg } 3655cef952ceSAndre Guedes break; 3656cef952ceSAndre Guedes } 365715819a70SAndre Guedes 3658851efca8SJohan Hedberg params->auto_connect = auto_connect; 3659851efca8SJohan Hedberg 3660d06b50ceSMarcel Holtmann BT_DBG("addr %pMR (type %u) auto_connect %u", addr, addr_type, 3661d06b50ceSMarcel Holtmann auto_connect); 3662a9b0a04cSAndre Guedes 3663a9b0a04cSAndre Guedes return 0; 366415819a70SAndre Guedes } 366515819a70SAndre Guedes 366615819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 366715819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 366815819a70SAndre Guedes { 366915819a70SAndre Guedes struct hci_conn_params *params; 367015819a70SAndre Guedes 367115819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 367215819a70SAndre Guedes if (!params) 367315819a70SAndre Guedes return; 367415819a70SAndre Guedes 367595305baaSJohan Hedberg list_del(¶ms->action); 367615819a70SAndre Guedes list_del(¶ms->list); 367715819a70SAndre Guedes kfree(params); 367815819a70SAndre Guedes 367995305baaSJohan Hedberg hci_update_background_scan(hdev); 368095305baaSJohan Hedberg 368115819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 368215819a70SAndre Guedes } 368315819a70SAndre Guedes 368415819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 368555af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 368655af49a8SJohan Hedberg { 368755af49a8SJohan Hedberg struct hci_conn_params *params, *tmp; 368855af49a8SJohan Hedberg 368955af49a8SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 369055af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 369155af49a8SJohan Hedberg continue; 369255af49a8SJohan Hedberg list_del(¶ms->list); 369355af49a8SJohan Hedberg kfree(params); 369455af49a8SJohan Hedberg } 369555af49a8SJohan Hedberg 369655af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 369755af49a8SJohan Hedberg } 369855af49a8SJohan Hedberg 369955af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 3700373110c5SJohan Hedberg void hci_conn_params_clear_all(struct hci_dev *hdev) 370115819a70SAndre Guedes { 370215819a70SAndre Guedes struct hci_conn_params *params, *tmp; 370315819a70SAndre Guedes 370415819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 3705a2f41a8fSJohan Hedberg list_del(¶ms->action); 370615819a70SAndre Guedes list_del(¶ms->list); 370715819a70SAndre Guedes kfree(params); 370815819a70SAndre Guedes } 370915819a70SAndre Guedes 3710a2f41a8fSJohan Hedberg hci_update_background_scan(hdev); 37111089b67dSMarcel Holtmann 371215819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 371315819a70SAndre Guedes } 371415819a70SAndre Guedes 37154c87eaabSAndre Guedes static void inquiry_complete(struct hci_dev *hdev, u8 status) 37167ba8b4beSAndre Guedes { 37174c87eaabSAndre Guedes if (status) { 37184c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 37197ba8b4beSAndre Guedes 37204c87eaabSAndre Guedes hci_dev_lock(hdev); 37214c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37224c87eaabSAndre Guedes hci_dev_unlock(hdev); 37234c87eaabSAndre Guedes return; 37244c87eaabSAndre Guedes } 37257ba8b4beSAndre Guedes } 37267ba8b4beSAndre Guedes 37274c87eaabSAndre Guedes static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status) 37287ba8b4beSAndre Guedes { 37294c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 37304c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 37314c87eaabSAndre Guedes struct hci_request req; 37324c87eaabSAndre Guedes struct hci_cp_inquiry cp; 37337ba8b4beSAndre Guedes int err; 37347ba8b4beSAndre Guedes 37354c87eaabSAndre Guedes if (status) { 37364c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 37374c87eaabSAndre Guedes return; 37387ba8b4beSAndre Guedes } 37397ba8b4beSAndre Guedes 37404c87eaabSAndre Guedes switch (hdev->discovery.type) { 37414c87eaabSAndre Guedes case DISCOV_TYPE_LE: 37424c87eaabSAndre Guedes hci_dev_lock(hdev); 37434c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37444c87eaabSAndre Guedes hci_dev_unlock(hdev); 37454c87eaabSAndre Guedes break; 37467dbfac1dSAndre Guedes 37474c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 37484c87eaabSAndre Guedes hci_req_init(&req, hdev); 37497dbfac1dSAndre Guedes 37507dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 37514c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 37524c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 37534c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 37544c87eaabSAndre Guedes 37554c87eaabSAndre Guedes hci_dev_lock(hdev); 37564c87eaabSAndre Guedes 37574c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 37584c87eaabSAndre Guedes 37594c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 37604c87eaabSAndre Guedes if (err) { 37614c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 37624c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37637dbfac1dSAndre Guedes } 37647dbfac1dSAndre Guedes 37654c87eaabSAndre Guedes hci_dev_unlock(hdev); 37664c87eaabSAndre Guedes break; 37674c87eaabSAndre Guedes } 37687dbfac1dSAndre Guedes } 37697dbfac1dSAndre Guedes 37707ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 37717ba8b4beSAndre Guedes { 37727ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 37737ba8b4beSAndre Guedes le_scan_disable.work); 37744c87eaabSAndre Guedes struct hci_request req; 37754c87eaabSAndre Guedes int err; 37767ba8b4beSAndre Guedes 37777ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 37787ba8b4beSAndre Guedes 37794c87eaabSAndre Guedes hci_req_init(&req, hdev); 37807ba8b4beSAndre Guedes 3781b1efcc28SAndre Guedes hci_req_add_le_scan_disable(&req); 37827ba8b4beSAndre Guedes 37834c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 37844c87eaabSAndre Guedes if (err) 37854c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 378628b75a89SAndre Guedes } 378728b75a89SAndre Guedes 37888d97250eSJohan Hedberg static void set_random_addr(struct hci_request *req, bdaddr_t *rpa) 37898d97250eSJohan Hedberg { 37908d97250eSJohan Hedberg struct hci_dev *hdev = req->hdev; 37918d97250eSJohan Hedberg 37928d97250eSJohan Hedberg /* If we're advertising or initiating an LE connection we can't 37938d97250eSJohan Hedberg * go ahead and change the random address at this time. This is 37948d97250eSJohan Hedberg * because the eventual initiator address used for the 37958d97250eSJohan Hedberg * subsequently created connection will be undefined (some 37968d97250eSJohan Hedberg * controllers use the new address and others the one we had 37978d97250eSJohan Hedberg * when the operation started). 37988d97250eSJohan Hedberg * 37998d97250eSJohan Hedberg * In this kind of scenario skip the update and let the random 38008d97250eSJohan Hedberg * address be updated at the next cycle. 38018d97250eSJohan Hedberg */ 38025ce194c4SJohan Hedberg if (test_bit(HCI_LE_ADV, &hdev->dev_flags) || 38038d97250eSJohan Hedberg hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT)) { 38048d97250eSJohan Hedberg BT_DBG("Deferring random address update"); 38058d97250eSJohan Hedberg return; 38068d97250eSJohan Hedberg } 38078d97250eSJohan Hedberg 38088d97250eSJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, rpa); 38098d97250eSJohan Hedberg } 38108d97250eSJohan Hedberg 381194b1fc92SMarcel Holtmann int hci_update_random_address(struct hci_request *req, bool require_privacy, 381294b1fc92SMarcel Holtmann u8 *own_addr_type) 3813ebd3a747SJohan Hedberg { 3814ebd3a747SJohan Hedberg struct hci_dev *hdev = req->hdev; 3815ebd3a747SJohan Hedberg int err; 3816ebd3a747SJohan Hedberg 3817ebd3a747SJohan Hedberg /* If privacy is enabled use a resolvable private address. If 38182b5224dcSMarcel Holtmann * current RPA has expired or there is something else than 38192b5224dcSMarcel Holtmann * the current RPA in use, then generate a new one. 3820ebd3a747SJohan Hedberg */ 3821ebd3a747SJohan Hedberg if (test_bit(HCI_PRIVACY, &hdev->dev_flags)) { 3822ebd3a747SJohan Hedberg int to; 3823ebd3a747SJohan Hedberg 3824ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3825ebd3a747SJohan Hedberg 3826ebd3a747SJohan Hedberg if (!test_and_clear_bit(HCI_RPA_EXPIRED, &hdev->dev_flags) && 38272b5224dcSMarcel Holtmann !bacmp(&hdev->random_addr, &hdev->rpa)) 3828ebd3a747SJohan Hedberg return 0; 3829ebd3a747SJohan Hedberg 38302b5224dcSMarcel Holtmann err = smp_generate_rpa(hdev->tfm_aes, hdev->irk, &hdev->rpa); 3831ebd3a747SJohan Hedberg if (err < 0) { 3832ebd3a747SJohan Hedberg BT_ERR("%s failed to generate new RPA", hdev->name); 3833ebd3a747SJohan Hedberg return err; 3834ebd3a747SJohan Hedberg } 3835ebd3a747SJohan Hedberg 38368d97250eSJohan Hedberg set_random_addr(req, &hdev->rpa); 3837ebd3a747SJohan Hedberg 3838ebd3a747SJohan Hedberg to = msecs_to_jiffies(hdev->rpa_timeout * 1000); 3839ebd3a747SJohan Hedberg queue_delayed_work(hdev->workqueue, &hdev->rpa_expired, to); 3840ebd3a747SJohan Hedberg 3841ebd3a747SJohan Hedberg return 0; 3842ebd3a747SJohan Hedberg } 3843ebd3a747SJohan Hedberg 384494b1fc92SMarcel Holtmann /* In case of required privacy without resolvable private address, 384594b1fc92SMarcel Holtmann * use an unresolvable private address. This is useful for active 384694b1fc92SMarcel Holtmann * scanning and non-connectable advertising. 384794b1fc92SMarcel Holtmann */ 384894b1fc92SMarcel Holtmann if (require_privacy) { 384994b1fc92SMarcel Holtmann bdaddr_t urpa; 385094b1fc92SMarcel Holtmann 385194b1fc92SMarcel Holtmann get_random_bytes(&urpa, 6); 385294b1fc92SMarcel Holtmann urpa.b[5] &= 0x3f; /* Clear two most significant bits */ 385394b1fc92SMarcel Holtmann 385494b1fc92SMarcel Holtmann *own_addr_type = ADDR_LE_DEV_RANDOM; 38558d97250eSJohan Hedberg set_random_addr(req, &urpa); 385694b1fc92SMarcel Holtmann return 0; 385794b1fc92SMarcel Holtmann } 385894b1fc92SMarcel Holtmann 3859ebd3a747SJohan Hedberg /* If forcing static address is in use or there is no public 3860ebd3a747SJohan Hedberg * address use the static address as random address (but skip 3861ebd3a747SJohan Hedberg * the HCI command if the current random address is already the 3862ebd3a747SJohan Hedberg * static one. 3863ebd3a747SJohan Hedberg */ 3864111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3865ebd3a747SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3866ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3867ebd3a747SJohan Hedberg if (bacmp(&hdev->static_addr, &hdev->random_addr)) 3868ebd3a747SJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, 3869ebd3a747SJohan Hedberg &hdev->static_addr); 3870ebd3a747SJohan Hedberg return 0; 3871ebd3a747SJohan Hedberg } 3872ebd3a747SJohan Hedberg 3873ebd3a747SJohan Hedberg /* Neither privacy nor static address is being used so use a 3874ebd3a747SJohan Hedberg * public address. 3875ebd3a747SJohan Hedberg */ 3876ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_PUBLIC; 3877ebd3a747SJohan Hedberg 3878ebd3a747SJohan Hedberg return 0; 3879ebd3a747SJohan Hedberg } 3880ebd3a747SJohan Hedberg 3881a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 3882a1f4c318SJohan Hedberg * 3883a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 3884a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 3885a1f4c318SJohan Hedberg * the static random address. 3886a1f4c318SJohan Hedberg * 3887a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 3888a1f4c318SJohan Hedberg * public address to use the static random address instead. 3889a1f4c318SJohan Hedberg */ 3890a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 3891a1f4c318SJohan Hedberg u8 *bdaddr_type) 3892a1f4c318SJohan Hedberg { 3893111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3894a1f4c318SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3895a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3896a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3897a1f4c318SJohan Hedberg } else { 3898a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3899a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3900a1f4c318SJohan Hedberg } 3901a1f4c318SJohan Hedberg } 3902a1f4c318SJohan Hedberg 39039be0dab7SDavid Herrmann /* Alloc HCI device */ 39049be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 39059be0dab7SDavid Herrmann { 39069be0dab7SDavid Herrmann struct hci_dev *hdev; 39079be0dab7SDavid Herrmann 390827f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 39099be0dab7SDavid Herrmann if (!hdev) 39109be0dab7SDavid Herrmann return NULL; 39119be0dab7SDavid Herrmann 3912b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3913b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3914b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3915b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3916b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 391796c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3918bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3919bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3920b1b813d4SDavid Herrmann 3921b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3922b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3923b1b813d4SDavid Herrmann 39243f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3925bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3926bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 39274e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 39284e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 392904fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 393004fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3931bef64738SMarcel Holtmann 3932d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3933b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 393431ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 393531ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3936d6bfd59cSJohan Hedberg 3937b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3938b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3939b1b813d4SDavid Herrmann 3940b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3941b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 39426659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 3943b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3944b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3945b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3946970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3947b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3948d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 394915819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 395077a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 395166f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 39526b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3953b1b813d4SDavid Herrmann 3954b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3955b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3956b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3957b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3958b1b813d4SDavid Herrmann 3959b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3960b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 3961b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 3962b1b813d4SDavid Herrmann 3963b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3964b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3965b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3966b1b813d4SDavid Herrmann 3967b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3968b1b813d4SDavid Herrmann 396965cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3970b1b813d4SDavid Herrmann 3971b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3972b1b813d4SDavid Herrmann discovery_init(hdev); 39739be0dab7SDavid Herrmann 39749be0dab7SDavid Herrmann return hdev; 39759be0dab7SDavid Herrmann } 39769be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 39779be0dab7SDavid Herrmann 39789be0dab7SDavid Herrmann /* Free HCI device */ 39799be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 39809be0dab7SDavid Herrmann { 39819be0dab7SDavid Herrmann /* will free via device release */ 39829be0dab7SDavid Herrmann put_device(&hdev->dev); 39839be0dab7SDavid Herrmann } 39849be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 39859be0dab7SDavid Herrmann 39861da177e4SLinus Torvalds /* Register HCI device */ 39871da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 39881da177e4SLinus Torvalds { 3989b1b813d4SDavid Herrmann int id, error; 39901da177e4SLinus Torvalds 399174292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 39921da177e4SLinus Torvalds return -EINVAL; 39931da177e4SLinus Torvalds 399408add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 399508add513SMat Martineau * so the index can be used as the AMP controller ID. 399608add513SMat Martineau */ 39973df92b31SSasha Levin switch (hdev->dev_type) { 39983df92b31SSasha Levin case HCI_BREDR: 39993df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 40001da177e4SLinus Torvalds break; 40013df92b31SSasha Levin case HCI_AMP: 40023df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 40033df92b31SSasha Levin break; 40043df92b31SSasha Levin default: 40053df92b31SSasha Levin return -EINVAL; 40061da177e4SLinus Torvalds } 40071da177e4SLinus Torvalds 40083df92b31SSasha Levin if (id < 0) 40093df92b31SSasha Levin return id; 40103df92b31SSasha Levin 40111da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 40121da177e4SLinus Torvalds hdev->id = id; 40132d8b3a11SAndrei Emeltchenko 40142d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 40152d8b3a11SAndrei Emeltchenko 4016d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 4017d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 401833ca954dSDavid Herrmann if (!hdev->workqueue) { 401933ca954dSDavid Herrmann error = -ENOMEM; 402033ca954dSDavid Herrmann goto err; 402133ca954dSDavid Herrmann } 4022f48fd9c8SMarcel Holtmann 4023d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 4024d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 40256ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 40266ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 40276ead1bbcSJohan Hedberg error = -ENOMEM; 40286ead1bbcSJohan Hedberg goto err; 40296ead1bbcSJohan Hedberg } 40306ead1bbcSJohan Hedberg 40310153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 40320153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 40330153e2ecSMarcel Holtmann 4034bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 4035bdc3e0f1SMarcel Holtmann 403699780a7bSJohan Hedberg hdev->tfm_aes = crypto_alloc_blkcipher("ecb(aes)", 0, 403799780a7bSJohan Hedberg CRYPTO_ALG_ASYNC); 403899780a7bSJohan Hedberg if (IS_ERR(hdev->tfm_aes)) { 403999780a7bSJohan Hedberg BT_ERR("Unable to create crypto context"); 404099780a7bSJohan Hedberg error = PTR_ERR(hdev->tfm_aes); 404199780a7bSJohan Hedberg hdev->tfm_aes = NULL; 404299780a7bSJohan Hedberg goto err_wqueue; 404399780a7bSJohan Hedberg } 404499780a7bSJohan Hedberg 4045bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 404633ca954dSDavid Herrmann if (error < 0) 404799780a7bSJohan Hedberg goto err_tfm; 40481da177e4SLinus Torvalds 4049611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 4050a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 4051a8c5fb1aSGustavo Padovan hdev); 4052611b30f7SMarcel Holtmann if (hdev->rfkill) { 4053611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 4054611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 4055611b30f7SMarcel Holtmann hdev->rfkill = NULL; 4056611b30f7SMarcel Holtmann } 4057611b30f7SMarcel Holtmann } 4058611b30f7SMarcel Holtmann 40595e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 40605e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 40615e130367SJohan Hedberg 4062a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 4063004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 4064ce2be9acSAndrei Emeltchenko 406501cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 406656f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 406756f87901SJohan Hedberg * through reading supported features during init. 406856f87901SJohan Hedberg */ 406956f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 407056f87901SJohan Hedberg } 4071ce2be9acSAndrei Emeltchenko 4072fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 4073fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 4074fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 4075fcee3377SGustavo Padovan 40764a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 40774a964404SMarcel Holtmann * and should not be included in normal operation. 4078fee746b0SMarcel Holtmann */ 4079fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 40804a964404SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 4081fee746b0SMarcel Holtmann 40821da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 4083dc946bd8SDavid Herrmann hci_dev_hold(hdev); 40841da177e4SLinus Torvalds 408519202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 4086fbe96d6fSMarcel Holtmann 40871da177e4SLinus Torvalds return id; 4088f48fd9c8SMarcel Holtmann 408999780a7bSJohan Hedberg err_tfm: 409099780a7bSJohan Hedberg crypto_free_blkcipher(hdev->tfm_aes); 409133ca954dSDavid Herrmann err_wqueue: 409233ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 40936ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 409433ca954dSDavid Herrmann err: 40953df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 4096f48fd9c8SMarcel Holtmann 409733ca954dSDavid Herrmann return error; 40981da177e4SLinus Torvalds } 40991da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 41001da177e4SLinus Torvalds 41011da177e4SLinus Torvalds /* Unregister HCI device */ 410259735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 41031da177e4SLinus Torvalds { 41043df92b31SSasha Levin int i, id; 4105ef222013SMarcel Holtmann 4106c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 41071da177e4SLinus Torvalds 410894324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 410994324962SJohan Hovold 41103df92b31SSasha Levin id = hdev->id; 41113df92b31SSasha Levin 4112f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 41131da177e4SLinus Torvalds list_del(&hdev->list); 4114f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 41151da177e4SLinus Torvalds 41161da177e4SLinus Torvalds hci_dev_do_close(hdev); 41171da177e4SLinus Torvalds 4118cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 4119ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 4120ef222013SMarcel Holtmann 4121b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 4122b9b5ef18SGustavo Padovan 4123ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 4124d603b76bSMarcel Holtmann !test_bit(HCI_SETUP, &hdev->dev_flags) && 4125d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 412609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 4127744cf19eSJohan Hedberg mgmt_index_removed(hdev); 412809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 412956e5cb86SJohan Hedberg } 4130ab81cbf9SJohan Hedberg 41312e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 41322e58ef3eSJohan Hedberg * pending list */ 41332e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 41342e58ef3eSJohan Hedberg 41351da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 41361da177e4SLinus Torvalds 4137611b30f7SMarcel Holtmann if (hdev->rfkill) { 4138611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 4139611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 4140611b30f7SMarcel Holtmann } 4141611b30f7SMarcel Holtmann 414299780a7bSJohan Hedberg if (hdev->tfm_aes) 414399780a7bSJohan Hedberg crypto_free_blkcipher(hdev->tfm_aes); 414499780a7bSJohan Hedberg 4145bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 4146147e2d59SDave Young 41470153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 41480153e2ecSMarcel Holtmann 4149f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 41506ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 4151f48fd9c8SMarcel Holtmann 415209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 4153dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 41546659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 41552aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 415655ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 4157b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 4158970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 41592763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 4160dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 4161373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 416209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 4163e2e0cacbSJohan Hedberg 4164dc946bd8SDavid Herrmann hci_dev_put(hdev); 41653df92b31SSasha Levin 41663df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 41671da177e4SLinus Torvalds } 41681da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 41691da177e4SLinus Torvalds 41701da177e4SLinus Torvalds /* Suspend HCI device */ 41711da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 41721da177e4SLinus Torvalds { 41731da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 41741da177e4SLinus Torvalds return 0; 41751da177e4SLinus Torvalds } 41761da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 41771da177e4SLinus Torvalds 41781da177e4SLinus Torvalds /* Resume HCI device */ 41791da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 41801da177e4SLinus Torvalds { 41811da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 41821da177e4SLinus Torvalds return 0; 41831da177e4SLinus Torvalds } 41841da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 41851da177e4SLinus Torvalds 418676bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 4187e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 418876bca880SMarcel Holtmann { 418976bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 419076bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 419176bca880SMarcel Holtmann kfree_skb(skb); 419276bca880SMarcel Holtmann return -ENXIO; 419376bca880SMarcel Holtmann } 419476bca880SMarcel Holtmann 4195d82603c6SJorrit Schippers /* Incoming skb */ 419676bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 419776bca880SMarcel Holtmann 419876bca880SMarcel Holtmann /* Time stamp */ 419976bca880SMarcel Holtmann __net_timestamp(skb); 420076bca880SMarcel Holtmann 420176bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 4202b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 4203c78ae283SMarcel Holtmann 420476bca880SMarcel Holtmann return 0; 420576bca880SMarcel Holtmann } 420676bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 420776bca880SMarcel Holtmann 420833e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 42091e429f38SGustavo F. Padovan int count, __u8 index) 421033e882a5SSuraj Sumangala { 421133e882a5SSuraj Sumangala int len = 0; 421233e882a5SSuraj Sumangala int hlen = 0; 421333e882a5SSuraj Sumangala int remain = count; 421433e882a5SSuraj Sumangala struct sk_buff *skb; 421533e882a5SSuraj Sumangala struct bt_skb_cb *scb; 421633e882a5SSuraj Sumangala 421733e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 421833e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 421933e882a5SSuraj Sumangala return -EILSEQ; 422033e882a5SSuraj Sumangala 422133e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 422233e882a5SSuraj Sumangala 422333e882a5SSuraj Sumangala if (!skb) { 422433e882a5SSuraj Sumangala switch (type) { 422533e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 422633e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 422733e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 422833e882a5SSuraj Sumangala break; 422933e882a5SSuraj Sumangala case HCI_EVENT_PKT: 423033e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 423133e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 423233e882a5SSuraj Sumangala break; 423333e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 423433e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 423533e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 423633e882a5SSuraj Sumangala break; 423733e882a5SSuraj Sumangala } 423833e882a5SSuraj Sumangala 42391e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 424033e882a5SSuraj Sumangala if (!skb) 424133e882a5SSuraj Sumangala return -ENOMEM; 424233e882a5SSuraj Sumangala 424333e882a5SSuraj Sumangala scb = (void *) skb->cb; 424433e882a5SSuraj Sumangala scb->expect = hlen; 424533e882a5SSuraj Sumangala scb->pkt_type = type; 424633e882a5SSuraj Sumangala 424733e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 424833e882a5SSuraj Sumangala } 424933e882a5SSuraj Sumangala 425033e882a5SSuraj Sumangala while (count) { 425133e882a5SSuraj Sumangala scb = (void *) skb->cb; 425289bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 425333e882a5SSuraj Sumangala 425433e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 425533e882a5SSuraj Sumangala 425633e882a5SSuraj Sumangala count -= len; 425733e882a5SSuraj Sumangala data += len; 425833e882a5SSuraj Sumangala scb->expect -= len; 425933e882a5SSuraj Sumangala remain = count; 426033e882a5SSuraj Sumangala 426133e882a5SSuraj Sumangala switch (type) { 426233e882a5SSuraj Sumangala case HCI_EVENT_PKT: 426333e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 426433e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 426533e882a5SSuraj Sumangala scb->expect = h->plen; 426633e882a5SSuraj Sumangala 426733e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 426833e882a5SSuraj Sumangala kfree_skb(skb); 426933e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 427033e882a5SSuraj Sumangala return -ENOMEM; 427133e882a5SSuraj Sumangala } 427233e882a5SSuraj Sumangala } 427333e882a5SSuraj Sumangala break; 427433e882a5SSuraj Sumangala 427533e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 427633e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 427733e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 427833e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 427933e882a5SSuraj Sumangala 428033e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 428133e882a5SSuraj Sumangala kfree_skb(skb); 428233e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 428333e882a5SSuraj Sumangala return -ENOMEM; 428433e882a5SSuraj Sumangala } 428533e882a5SSuraj Sumangala } 428633e882a5SSuraj Sumangala break; 428733e882a5SSuraj Sumangala 428833e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 428933e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 429033e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 429133e882a5SSuraj Sumangala scb->expect = h->dlen; 429233e882a5SSuraj Sumangala 429333e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 429433e882a5SSuraj Sumangala kfree_skb(skb); 429533e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 429633e882a5SSuraj Sumangala return -ENOMEM; 429733e882a5SSuraj Sumangala } 429833e882a5SSuraj Sumangala } 429933e882a5SSuraj Sumangala break; 430033e882a5SSuraj Sumangala } 430133e882a5SSuraj Sumangala 430233e882a5SSuraj Sumangala if (scb->expect == 0) { 430333e882a5SSuraj Sumangala /* Complete frame */ 430433e882a5SSuraj Sumangala 430533e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 4306e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 430733e882a5SSuraj Sumangala 430833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 430933e882a5SSuraj Sumangala return remain; 431033e882a5SSuraj Sumangala } 431133e882a5SSuraj Sumangala } 431233e882a5SSuraj Sumangala 431333e882a5SSuraj Sumangala return remain; 431433e882a5SSuraj Sumangala } 431533e882a5SSuraj Sumangala 4316ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 4317ef222013SMarcel Holtmann { 4318f39a3c06SSuraj Sumangala int rem = 0; 4319f39a3c06SSuraj Sumangala 4320ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 4321ef222013SMarcel Holtmann return -EILSEQ; 4322ef222013SMarcel Holtmann 4323da5f6c37SGustavo F. Padovan while (count) { 43241e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, type - 1); 4325f39a3c06SSuraj Sumangala if (rem < 0) 4326f39a3c06SSuraj Sumangala return rem; 4327ef222013SMarcel Holtmann 4328f39a3c06SSuraj Sumangala data += (count - rem); 4329f39a3c06SSuraj Sumangala count = rem; 4330f81c6224SJoe Perches } 4331ef222013SMarcel Holtmann 4332f39a3c06SSuraj Sumangala return rem; 4333ef222013SMarcel Holtmann } 4334ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 4335ef222013SMarcel Holtmann 433699811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 433799811510SSuraj Sumangala 433899811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 433999811510SSuraj Sumangala { 434099811510SSuraj Sumangala int type; 434199811510SSuraj Sumangala int rem = 0; 434299811510SSuraj Sumangala 4343da5f6c37SGustavo F. Padovan while (count) { 434499811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 434599811510SSuraj Sumangala 434699811510SSuraj Sumangala if (!skb) { 434799811510SSuraj Sumangala struct { char type; } *pkt; 434899811510SSuraj Sumangala 434999811510SSuraj Sumangala /* Start of the frame */ 435099811510SSuraj Sumangala pkt = data; 435199811510SSuraj Sumangala type = pkt->type; 435299811510SSuraj Sumangala 435399811510SSuraj Sumangala data++; 435499811510SSuraj Sumangala count--; 435599811510SSuraj Sumangala } else 435699811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 435799811510SSuraj Sumangala 43581e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 43591e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 436099811510SSuraj Sumangala if (rem < 0) 436199811510SSuraj Sumangala return rem; 436299811510SSuraj Sumangala 436399811510SSuraj Sumangala data += (count - rem); 436499811510SSuraj Sumangala count = rem; 4365f81c6224SJoe Perches } 436699811510SSuraj Sumangala 436799811510SSuraj Sumangala return rem; 436899811510SSuraj Sumangala } 436999811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 437099811510SSuraj Sumangala 43711da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 43721da177e4SLinus Torvalds 43731da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 43741da177e4SLinus Torvalds { 43751da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 43761da177e4SLinus Torvalds 4377f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 43781da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 4379f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 43801da177e4SLinus Torvalds 43811da177e4SLinus Torvalds return 0; 43821da177e4SLinus Torvalds } 43831da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 43841da177e4SLinus Torvalds 43851da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 43861da177e4SLinus Torvalds { 43871da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 43881da177e4SLinus Torvalds 4389f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 43901da177e4SLinus Torvalds list_del(&cb->list); 4391f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 43921da177e4SLinus Torvalds 43931da177e4SLinus Torvalds return 0; 43941da177e4SLinus Torvalds } 43951da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 43961da177e4SLinus Torvalds 439751086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 43981da177e4SLinus Torvalds { 4399cdc52faaSMarcel Holtmann int err; 4400cdc52faaSMarcel Holtmann 44010d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 44021da177e4SLinus Torvalds 44031da177e4SLinus Torvalds /* Time stamp */ 4404a61bbcf2SPatrick McHardy __net_timestamp(skb); 44051da177e4SLinus Torvalds 4406cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4407cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4408cd82e61cSMarcel Holtmann 4409cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 4410cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 4411470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 44121da177e4SLinus Torvalds } 44131da177e4SLinus Torvalds 44141da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 44151da177e4SLinus Torvalds skb_orphan(skb); 44161da177e4SLinus Torvalds 4417cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 4418cdc52faaSMarcel Holtmann if (err < 0) { 4419cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 4420cdc52faaSMarcel Holtmann kfree_skb(skb); 4421cdc52faaSMarcel Holtmann } 44221da177e4SLinus Torvalds } 44231da177e4SLinus Torvalds 44243119ae95SJohan Hedberg void hci_req_init(struct hci_request *req, struct hci_dev *hdev) 44253119ae95SJohan Hedberg { 44263119ae95SJohan Hedberg skb_queue_head_init(&req->cmd_q); 44273119ae95SJohan Hedberg req->hdev = hdev; 44285d73e034SAndre Guedes req->err = 0; 44293119ae95SJohan Hedberg } 44303119ae95SJohan Hedberg 44313119ae95SJohan Hedberg int hci_req_run(struct hci_request *req, hci_req_complete_t complete) 44323119ae95SJohan Hedberg { 44333119ae95SJohan Hedberg struct hci_dev *hdev = req->hdev; 44343119ae95SJohan Hedberg struct sk_buff *skb; 44353119ae95SJohan Hedberg unsigned long flags; 44363119ae95SJohan Hedberg 44373119ae95SJohan Hedberg BT_DBG("length %u", skb_queue_len(&req->cmd_q)); 44383119ae95SJohan Hedberg 44395d73e034SAndre Guedes /* If an error occured during request building, remove all HCI 44405d73e034SAndre Guedes * commands queued on the HCI request queue. 44415d73e034SAndre Guedes */ 44425d73e034SAndre Guedes if (req->err) { 44435d73e034SAndre Guedes skb_queue_purge(&req->cmd_q); 44445d73e034SAndre Guedes return req->err; 44455d73e034SAndre Guedes } 44465d73e034SAndre Guedes 44473119ae95SJohan Hedberg /* Do not allow empty requests */ 44483119ae95SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 4449382b0c39SAndre Guedes return -ENODATA; 44503119ae95SJohan Hedberg 44513119ae95SJohan Hedberg skb = skb_peek_tail(&req->cmd_q); 44523119ae95SJohan Hedberg bt_cb(skb)->req.complete = complete; 44533119ae95SJohan Hedberg 44543119ae95SJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 44553119ae95SJohan Hedberg skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q); 44563119ae95SJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 44573119ae95SJohan Hedberg 44583119ae95SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 44593119ae95SJohan Hedberg 44603119ae95SJohan Hedberg return 0; 44613119ae95SJohan Hedberg } 44623119ae95SJohan Hedberg 4463899de765SMarcel Holtmann bool hci_req_pending(struct hci_dev *hdev) 4464899de765SMarcel Holtmann { 4465899de765SMarcel Holtmann return (hdev->req_status == HCI_REQ_PEND); 4466899de765SMarcel Holtmann } 4467899de765SMarcel Holtmann 44681ca3a9d0SJohan Hedberg static struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, 446907dc93ddSJohan Hedberg u32 plen, const void *param) 44701da177e4SLinus Torvalds { 44711da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 44721da177e4SLinus Torvalds struct hci_command_hdr *hdr; 44731da177e4SLinus Torvalds struct sk_buff *skb; 44741da177e4SLinus Torvalds 44751da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 44761ca3a9d0SJohan Hedberg if (!skb) 44771ca3a9d0SJohan Hedberg return NULL; 44781da177e4SLinus Torvalds 44791da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 4480a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 44811da177e4SLinus Torvalds hdr->plen = plen; 44821da177e4SLinus Torvalds 44831da177e4SLinus Torvalds if (plen) 44841da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 44851da177e4SLinus Torvalds 44861da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 44871da177e4SLinus Torvalds 44880d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 4489c78ae283SMarcel Holtmann 44901ca3a9d0SJohan Hedberg return skb; 44911ca3a9d0SJohan Hedberg } 44921ca3a9d0SJohan Hedberg 44931ca3a9d0SJohan Hedberg /* Send HCI command */ 449407dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 449507dc93ddSJohan Hedberg const void *param) 44961ca3a9d0SJohan Hedberg { 44971ca3a9d0SJohan Hedberg struct sk_buff *skb; 44981ca3a9d0SJohan Hedberg 44991ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 45001ca3a9d0SJohan Hedberg 45011ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 45021ca3a9d0SJohan Hedberg if (!skb) { 45031ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 45041ca3a9d0SJohan Hedberg return -ENOMEM; 45051ca3a9d0SJohan Hedberg } 45061ca3a9d0SJohan Hedberg 450711714b3dSJohan Hedberg /* Stand-alone HCI commands must be flaged as 450811714b3dSJohan Hedberg * single-command requests. 450911714b3dSJohan Hedberg */ 451011714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 451111714b3dSJohan Hedberg 45121da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 4513c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 45141da177e4SLinus Torvalds 45151da177e4SLinus Torvalds return 0; 45161da177e4SLinus Torvalds } 45171da177e4SLinus Torvalds 451871c76a17SJohan Hedberg /* Queue a command to an asynchronous HCI request */ 451907dc93ddSJohan Hedberg void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen, 452007dc93ddSJohan Hedberg const void *param, u8 event) 452171c76a17SJohan Hedberg { 452271c76a17SJohan Hedberg struct hci_dev *hdev = req->hdev; 452371c76a17SJohan Hedberg struct sk_buff *skb; 452471c76a17SJohan Hedberg 452571c76a17SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 452671c76a17SJohan Hedberg 452734739c1eSAndre Guedes /* If an error occured during request building, there is no point in 452834739c1eSAndre Guedes * queueing the HCI command. We can simply return. 452934739c1eSAndre Guedes */ 453034739c1eSAndre Guedes if (req->err) 453134739c1eSAndre Guedes return; 453234739c1eSAndre Guedes 453371c76a17SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 453471c76a17SJohan Hedberg if (!skb) { 45355d73e034SAndre Guedes BT_ERR("%s no memory for command (opcode 0x%4.4x)", 45365d73e034SAndre Guedes hdev->name, opcode); 45375d73e034SAndre Guedes req->err = -ENOMEM; 4538e348fe6bSAndre Guedes return; 453971c76a17SJohan Hedberg } 454071c76a17SJohan Hedberg 454171c76a17SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 454271c76a17SJohan Hedberg bt_cb(skb)->req.start = true; 454371c76a17SJohan Hedberg 454402350a72SJohan Hedberg bt_cb(skb)->req.event = event; 454502350a72SJohan Hedberg 454671c76a17SJohan Hedberg skb_queue_tail(&req->cmd_q, skb); 454771c76a17SJohan Hedberg } 454871c76a17SJohan Hedberg 454907dc93ddSJohan Hedberg void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, 455007dc93ddSJohan Hedberg const void *param) 455102350a72SJohan Hedberg { 455202350a72SJohan Hedberg hci_req_add_ev(req, opcode, plen, param, 0); 455302350a72SJohan Hedberg } 455402350a72SJohan Hedberg 45551da177e4SLinus Torvalds /* Get data from the previously sent command */ 4556a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 45571da177e4SLinus Torvalds { 45581da177e4SLinus Torvalds struct hci_command_hdr *hdr; 45591da177e4SLinus Torvalds 45601da177e4SLinus Torvalds if (!hdev->sent_cmd) 45611da177e4SLinus Torvalds return NULL; 45621da177e4SLinus Torvalds 45631da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 45641da177e4SLinus Torvalds 4565a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 45661da177e4SLinus Torvalds return NULL; 45671da177e4SLinus Torvalds 4568f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 45691da177e4SLinus Torvalds 45701da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 45711da177e4SLinus Torvalds } 45721da177e4SLinus Torvalds 45731da177e4SLinus Torvalds /* Send ACL data */ 45741da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 45751da177e4SLinus Torvalds { 45761da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 45771da177e4SLinus Torvalds int len = skb->len; 45781da177e4SLinus Torvalds 4579badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 4580badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 45819c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 4582aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 4583aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 45841da177e4SLinus Torvalds } 45851da177e4SLinus Torvalds 4586ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 458773d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 45881da177e4SLinus Torvalds { 4589ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 45901da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 45911da177e4SLinus Torvalds struct sk_buff *list; 45921da177e4SLinus Torvalds 4593087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 4594087bfd99SGustavo Padovan skb->data_len = 0; 4595087bfd99SGustavo Padovan 4596087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4597204a6e54SAndrei Emeltchenko 4598204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 4599204a6e54SAndrei Emeltchenko case HCI_BREDR: 4600087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 4601204a6e54SAndrei Emeltchenko break; 4602204a6e54SAndrei Emeltchenko case HCI_AMP: 4603204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 4604204a6e54SAndrei Emeltchenko break; 4605204a6e54SAndrei Emeltchenko default: 4606204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 4607204a6e54SAndrei Emeltchenko return; 4608204a6e54SAndrei Emeltchenko } 4609087bfd99SGustavo Padovan 461070f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 461170f23020SAndrei Emeltchenko if (!list) { 46121da177e4SLinus Torvalds /* Non fragmented */ 46131da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 46141da177e4SLinus Torvalds 461573d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 46161da177e4SLinus Torvalds } else { 46171da177e4SLinus Torvalds /* Fragmented */ 46181da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 46191da177e4SLinus Torvalds 46201da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 46211da177e4SLinus Torvalds 46221da177e4SLinus Torvalds /* Queue all fragments atomically */ 4623af3e6359SGustavo F. Padovan spin_lock(&queue->lock); 46241da177e4SLinus Torvalds 462573d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 4626e702112fSAndrei Emeltchenko 4627e702112fSAndrei Emeltchenko flags &= ~ACL_START; 4628e702112fSAndrei Emeltchenko flags |= ACL_CONT; 46291da177e4SLinus Torvalds do { 46301da177e4SLinus Torvalds skb = list; list = list->next; 46311da177e4SLinus Torvalds 46320d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4633e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 46341da177e4SLinus Torvalds 46351da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 46361da177e4SLinus Torvalds 463773d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 46381da177e4SLinus Torvalds } while (list); 46391da177e4SLinus Torvalds 4640af3e6359SGustavo F. Padovan spin_unlock(&queue->lock); 46411da177e4SLinus Torvalds } 464273d80debSLuiz Augusto von Dentz } 464373d80debSLuiz Augusto von Dentz 464473d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 464573d80debSLuiz Augusto von Dentz { 4646ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 464773d80debSLuiz Augusto von Dentz 4648f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 464973d80debSLuiz Augusto von Dentz 4650ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 46511da177e4SLinus Torvalds 46523eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 46531da177e4SLinus Torvalds } 46541da177e4SLinus Torvalds 46551da177e4SLinus Torvalds /* Send SCO data */ 46560d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 46571da177e4SLinus Torvalds { 46581da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 46591da177e4SLinus Torvalds struct hci_sco_hdr hdr; 46601da177e4SLinus Torvalds 46611da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 46621da177e4SLinus Torvalds 4663aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 46641da177e4SLinus Torvalds hdr.dlen = skb->len; 46651da177e4SLinus Torvalds 4666badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 4667badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 46689c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 46691da177e4SLinus Torvalds 46700d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 4671c78ae283SMarcel Holtmann 46721da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 46733eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 46741da177e4SLinus Torvalds } 46751da177e4SLinus Torvalds 46761da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 46771da177e4SLinus Torvalds 46781da177e4SLinus Torvalds /* HCI Connection scheduler */ 46796039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 4680a8c5fb1aSGustavo Padovan int *quote) 46811da177e4SLinus Torvalds { 46821da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 46838035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 4684abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 46851da177e4SLinus Torvalds 46861da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 46871da177e4SLinus Torvalds * added and removed with TX task disabled. */ 4688bf4c6325SGustavo F. Padovan 4689bf4c6325SGustavo F. Padovan rcu_read_lock(); 4690bf4c6325SGustavo F. Padovan 4691bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4692769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 46931da177e4SLinus Torvalds continue; 4694769be974SMarcel Holtmann 4695769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 4696769be974SMarcel Holtmann continue; 4697769be974SMarcel Holtmann 46981da177e4SLinus Torvalds num++; 46991da177e4SLinus Torvalds 47001da177e4SLinus Torvalds if (c->sent < min) { 47011da177e4SLinus Torvalds min = c->sent; 47021da177e4SLinus Torvalds conn = c; 47031da177e4SLinus Torvalds } 470452087a79SLuiz Augusto von Dentz 470552087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 470652087a79SLuiz Augusto von Dentz break; 47071da177e4SLinus Torvalds } 47081da177e4SLinus Torvalds 4709bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4710bf4c6325SGustavo F. Padovan 47111da177e4SLinus Torvalds if (conn) { 47126ed58ec5SVille Tervo int cnt, q; 47136ed58ec5SVille Tervo 47146ed58ec5SVille Tervo switch (conn->type) { 47156ed58ec5SVille Tervo case ACL_LINK: 47166ed58ec5SVille Tervo cnt = hdev->acl_cnt; 47176ed58ec5SVille Tervo break; 47186ed58ec5SVille Tervo case SCO_LINK: 47196ed58ec5SVille Tervo case ESCO_LINK: 47206ed58ec5SVille Tervo cnt = hdev->sco_cnt; 47216ed58ec5SVille Tervo break; 47226ed58ec5SVille Tervo case LE_LINK: 47236ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 47246ed58ec5SVille Tervo break; 47256ed58ec5SVille Tervo default: 47266ed58ec5SVille Tervo cnt = 0; 47276ed58ec5SVille Tervo BT_ERR("Unknown link type"); 47286ed58ec5SVille Tervo } 47296ed58ec5SVille Tervo 47306ed58ec5SVille Tervo q = cnt / num; 47311da177e4SLinus Torvalds *quote = q ? q : 1; 47321da177e4SLinus Torvalds } else 47331da177e4SLinus Torvalds *quote = 0; 47341da177e4SLinus Torvalds 47351da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 47361da177e4SLinus Torvalds return conn; 47371da177e4SLinus Torvalds } 47381da177e4SLinus Torvalds 47396039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 47401da177e4SLinus Torvalds { 47411da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 47421da177e4SLinus Torvalds struct hci_conn *c; 47431da177e4SLinus Torvalds 4744bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 47451da177e4SLinus Torvalds 4746bf4c6325SGustavo F. Padovan rcu_read_lock(); 4747bf4c6325SGustavo F. Padovan 47481da177e4SLinus Torvalds /* Kill stalled connections */ 4749bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4750bae1f5d9SVille Tervo if (c->type == type && c->sent) { 47516ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 47526ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 4753bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 47541da177e4SLinus Torvalds } 47551da177e4SLinus Torvalds } 4756bf4c6325SGustavo F. Padovan 4757bf4c6325SGustavo F. Padovan rcu_read_unlock(); 47581da177e4SLinus Torvalds } 47591da177e4SLinus Torvalds 47606039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 476173d80debSLuiz Augusto von Dentz int *quote) 476273d80debSLuiz Augusto von Dentz { 476373d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 476473d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 4765abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 476673d80debSLuiz Augusto von Dentz struct hci_conn *conn; 476773d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 476873d80debSLuiz Augusto von Dentz 476973d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 477073d80debSLuiz Augusto von Dentz 4771bf4c6325SGustavo F. Padovan rcu_read_lock(); 4772bf4c6325SGustavo F. Padovan 4773bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 477473d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 477573d80debSLuiz Augusto von Dentz 477673d80debSLuiz Augusto von Dentz if (conn->type != type) 477773d80debSLuiz Augusto von Dentz continue; 477873d80debSLuiz Augusto von Dentz 477973d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 478073d80debSLuiz Augusto von Dentz continue; 478173d80debSLuiz Augusto von Dentz 478273d80debSLuiz Augusto von Dentz conn_num++; 478373d80debSLuiz Augusto von Dentz 47848192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 478573d80debSLuiz Augusto von Dentz struct sk_buff *skb; 478673d80debSLuiz Augusto von Dentz 478773d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 478873d80debSLuiz Augusto von Dentz continue; 478973d80debSLuiz Augusto von Dentz 479073d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 479173d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 479273d80debSLuiz Augusto von Dentz continue; 479373d80debSLuiz Augusto von Dentz 479473d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 479573d80debSLuiz Augusto von Dentz num = 0; 479673d80debSLuiz Augusto von Dentz min = ~0; 479773d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 479873d80debSLuiz Augusto von Dentz } 479973d80debSLuiz Augusto von Dentz 480073d80debSLuiz Augusto von Dentz num++; 480173d80debSLuiz Augusto von Dentz 480273d80debSLuiz Augusto von Dentz if (conn->sent < min) { 480373d80debSLuiz Augusto von Dentz min = conn->sent; 480473d80debSLuiz Augusto von Dentz chan = tmp; 480573d80debSLuiz Augusto von Dentz } 480673d80debSLuiz Augusto von Dentz } 480773d80debSLuiz Augusto von Dentz 480873d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 480973d80debSLuiz Augusto von Dentz break; 481073d80debSLuiz Augusto von Dentz } 481173d80debSLuiz Augusto von Dentz 4812bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4813bf4c6325SGustavo F. Padovan 481473d80debSLuiz Augusto von Dentz if (!chan) 481573d80debSLuiz Augusto von Dentz return NULL; 481673d80debSLuiz Augusto von Dentz 481773d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 481873d80debSLuiz Augusto von Dentz case ACL_LINK: 481973d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 482073d80debSLuiz Augusto von Dentz break; 4821bd1eb66bSAndrei Emeltchenko case AMP_LINK: 4822bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 4823bd1eb66bSAndrei Emeltchenko break; 482473d80debSLuiz Augusto von Dentz case SCO_LINK: 482573d80debSLuiz Augusto von Dentz case ESCO_LINK: 482673d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 482773d80debSLuiz Augusto von Dentz break; 482873d80debSLuiz Augusto von Dentz case LE_LINK: 482973d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 483073d80debSLuiz Augusto von Dentz break; 483173d80debSLuiz Augusto von Dentz default: 483273d80debSLuiz Augusto von Dentz cnt = 0; 483373d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 483473d80debSLuiz Augusto von Dentz } 483573d80debSLuiz Augusto von Dentz 483673d80debSLuiz Augusto von Dentz q = cnt / num; 483773d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 483873d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 483973d80debSLuiz Augusto von Dentz return chan; 484073d80debSLuiz Augusto von Dentz } 484173d80debSLuiz Augusto von Dentz 484202b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 484302b20f0bSLuiz Augusto von Dentz { 484402b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 484502b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 484602b20f0bSLuiz Augusto von Dentz int num = 0; 484702b20f0bSLuiz Augusto von Dentz 484802b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 484902b20f0bSLuiz Augusto von Dentz 4850bf4c6325SGustavo F. Padovan rcu_read_lock(); 4851bf4c6325SGustavo F. Padovan 4852bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 485302b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 485402b20f0bSLuiz Augusto von Dentz 485502b20f0bSLuiz Augusto von Dentz if (conn->type != type) 485602b20f0bSLuiz Augusto von Dentz continue; 485702b20f0bSLuiz Augusto von Dentz 485802b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 485902b20f0bSLuiz Augusto von Dentz continue; 486002b20f0bSLuiz Augusto von Dentz 486102b20f0bSLuiz Augusto von Dentz num++; 486202b20f0bSLuiz Augusto von Dentz 48638192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 486402b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 486502b20f0bSLuiz Augusto von Dentz 486602b20f0bSLuiz Augusto von Dentz if (chan->sent) { 486702b20f0bSLuiz Augusto von Dentz chan->sent = 0; 486802b20f0bSLuiz Augusto von Dentz continue; 486902b20f0bSLuiz Augusto von Dentz } 487002b20f0bSLuiz Augusto von Dentz 487102b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 487202b20f0bSLuiz Augusto von Dentz continue; 487302b20f0bSLuiz Augusto von Dentz 487402b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 487502b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 487602b20f0bSLuiz Augusto von Dentz continue; 487702b20f0bSLuiz Augusto von Dentz 487802b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 487902b20f0bSLuiz Augusto von Dentz 488002b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 488102b20f0bSLuiz Augusto von Dentz skb->priority); 488202b20f0bSLuiz Augusto von Dentz } 488302b20f0bSLuiz Augusto von Dentz 488402b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 488502b20f0bSLuiz Augusto von Dentz break; 488602b20f0bSLuiz Augusto von Dentz } 4887bf4c6325SGustavo F. Padovan 4888bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4889bf4c6325SGustavo F. Padovan 489002b20f0bSLuiz Augusto von Dentz } 489102b20f0bSLuiz Augusto von Dentz 4892b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 4893b71d385aSAndrei Emeltchenko { 4894b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 4895b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 4896b71d385aSAndrei Emeltchenko } 4897b71d385aSAndrei Emeltchenko 48986039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 48991da177e4SLinus Torvalds { 49004a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 49011da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 49021da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 490363d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 49045f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 4905bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 49061da177e4SLinus Torvalds } 490763d2bc1bSAndrei Emeltchenko } 49081da177e4SLinus Torvalds 49096039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 491063d2bc1bSAndrei Emeltchenko { 491163d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 491263d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 491363d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 491463d2bc1bSAndrei Emeltchenko int quote; 491563d2bc1bSAndrei Emeltchenko 491663d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 491704837f64SMarcel Holtmann 491873d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 491973d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 4920ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4921ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 492273d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 492373d80debSLuiz Augusto von Dentz skb->len, skb->priority); 492473d80debSLuiz Augusto von Dentz 4925ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4926ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4927ec1cce24SLuiz Augusto von Dentz break; 4928ec1cce24SLuiz Augusto von Dentz 4929ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4930ec1cce24SLuiz Augusto von Dentz 493173d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 493273d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 493304837f64SMarcel Holtmann 493457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 49351da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 49361da177e4SLinus Torvalds 49371da177e4SLinus Torvalds hdev->acl_cnt--; 493873d80debSLuiz Augusto von Dentz chan->sent++; 493973d80debSLuiz Augusto von Dentz chan->conn->sent++; 49401da177e4SLinus Torvalds } 49411da177e4SLinus Torvalds } 494202b20f0bSLuiz Augusto von Dentz 494302b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 494402b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 49451da177e4SLinus Torvalds } 49461da177e4SLinus Torvalds 49476039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 4948b71d385aSAndrei Emeltchenko { 494963d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 4950b71d385aSAndrei Emeltchenko struct hci_chan *chan; 4951b71d385aSAndrei Emeltchenko struct sk_buff *skb; 4952b71d385aSAndrei Emeltchenko int quote; 4953bd1eb66bSAndrei Emeltchenko u8 type; 4954b71d385aSAndrei Emeltchenko 495563d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 4956b71d385aSAndrei Emeltchenko 4957bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4958bd1eb66bSAndrei Emeltchenko 4959bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 4960bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 4961bd1eb66bSAndrei Emeltchenko else 4962bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 4963bd1eb66bSAndrei Emeltchenko 4964b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 4965bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 4966b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 4967b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 4968b71d385aSAndrei Emeltchenko int blocks; 4969b71d385aSAndrei Emeltchenko 4970b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 4971b71d385aSAndrei Emeltchenko skb->len, skb->priority); 4972b71d385aSAndrei Emeltchenko 4973b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 4974b71d385aSAndrei Emeltchenko if (skb->priority < priority) 4975b71d385aSAndrei Emeltchenko break; 4976b71d385aSAndrei Emeltchenko 4977b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 4978b71d385aSAndrei Emeltchenko 4979b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 4980b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 4981b71d385aSAndrei Emeltchenko return; 4982b71d385aSAndrei Emeltchenko 4983b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 4984b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 4985b71d385aSAndrei Emeltchenko 498657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4987b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 4988b71d385aSAndrei Emeltchenko 4989b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 4990b71d385aSAndrei Emeltchenko quote -= blocks; 4991b71d385aSAndrei Emeltchenko 4992b71d385aSAndrei Emeltchenko chan->sent += blocks; 4993b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 4994b71d385aSAndrei Emeltchenko } 4995b71d385aSAndrei Emeltchenko } 4996b71d385aSAndrei Emeltchenko 4997b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 4998bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 4999b71d385aSAndrei Emeltchenko } 5000b71d385aSAndrei Emeltchenko 50016039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 5002b71d385aSAndrei Emeltchenko { 5003b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 5004b71d385aSAndrei Emeltchenko 5005bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 5006bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 5007bd1eb66bSAndrei Emeltchenko return; 5008bd1eb66bSAndrei Emeltchenko 5009bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 5010bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 5011b71d385aSAndrei Emeltchenko return; 5012b71d385aSAndrei Emeltchenko 5013b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 5014b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 5015b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 5016b71d385aSAndrei Emeltchenko break; 5017b71d385aSAndrei Emeltchenko 5018b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 5019b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 5020b71d385aSAndrei Emeltchenko break; 5021b71d385aSAndrei Emeltchenko } 5022b71d385aSAndrei Emeltchenko } 5023b71d385aSAndrei Emeltchenko 50241da177e4SLinus Torvalds /* Schedule SCO */ 50256039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 50261da177e4SLinus Torvalds { 50271da177e4SLinus Torvalds struct hci_conn *conn; 50281da177e4SLinus Torvalds struct sk_buff *skb; 50291da177e4SLinus Torvalds int quote; 50301da177e4SLinus Torvalds 50311da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 50321da177e4SLinus Torvalds 503352087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 503452087a79SLuiz Augusto von Dentz return; 503552087a79SLuiz Augusto von Dentz 50361da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 50371da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 50381da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 503957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 50401da177e4SLinus Torvalds 50411da177e4SLinus Torvalds conn->sent++; 50421da177e4SLinus Torvalds if (conn->sent == ~0) 50431da177e4SLinus Torvalds conn->sent = 0; 50441da177e4SLinus Torvalds } 50451da177e4SLinus Torvalds } 50461da177e4SLinus Torvalds } 50471da177e4SLinus Torvalds 50486039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 5049b6a0dc82SMarcel Holtmann { 5050b6a0dc82SMarcel Holtmann struct hci_conn *conn; 5051b6a0dc82SMarcel Holtmann struct sk_buff *skb; 5052b6a0dc82SMarcel Holtmann int quote; 5053b6a0dc82SMarcel Holtmann 5054b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 5055b6a0dc82SMarcel Holtmann 505652087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 505752087a79SLuiz Augusto von Dentz return; 505852087a79SLuiz Augusto von Dentz 50598fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 50608fc9ced3SGustavo Padovan "e))) { 5061b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 5062b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 506357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 5064b6a0dc82SMarcel Holtmann 5065b6a0dc82SMarcel Holtmann conn->sent++; 5066b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 5067b6a0dc82SMarcel Holtmann conn->sent = 0; 5068b6a0dc82SMarcel Holtmann } 5069b6a0dc82SMarcel Holtmann } 5070b6a0dc82SMarcel Holtmann } 5071b6a0dc82SMarcel Holtmann 50726039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 50736ed58ec5SVille Tervo { 507473d80debSLuiz Augusto von Dentz struct hci_chan *chan; 50756ed58ec5SVille Tervo struct sk_buff *skb; 507602b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 50776ed58ec5SVille Tervo 50786ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 50796ed58ec5SVille Tervo 508052087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 508152087a79SLuiz Augusto von Dentz return; 508252087a79SLuiz Augusto von Dentz 50834a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 50846ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 50856ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 5086bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 50876ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 5088bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 50896ed58ec5SVille Tervo } 50906ed58ec5SVille Tervo 50916ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 509202b20f0bSLuiz Augusto von Dentz tmp = cnt; 509373d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 5094ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 5095ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 509673d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 509773d80debSLuiz Augusto von Dentz skb->len, skb->priority); 50986ed58ec5SVille Tervo 5099ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 5100ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 5101ec1cce24SLuiz Augusto von Dentz break; 5102ec1cce24SLuiz Augusto von Dentz 5103ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 5104ec1cce24SLuiz Augusto von Dentz 510557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 51066ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 51076ed58ec5SVille Tervo 51086ed58ec5SVille Tervo cnt--; 510973d80debSLuiz Augusto von Dentz chan->sent++; 511073d80debSLuiz Augusto von Dentz chan->conn->sent++; 51116ed58ec5SVille Tervo } 51126ed58ec5SVille Tervo } 511373d80debSLuiz Augusto von Dentz 51146ed58ec5SVille Tervo if (hdev->le_pkts) 51156ed58ec5SVille Tervo hdev->le_cnt = cnt; 51166ed58ec5SVille Tervo else 51176ed58ec5SVille Tervo hdev->acl_cnt = cnt; 511802b20f0bSLuiz Augusto von Dentz 511902b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 512002b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 51216ed58ec5SVille Tervo } 51226ed58ec5SVille Tervo 51233eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 51241da177e4SLinus Torvalds { 51253eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 51261da177e4SLinus Torvalds struct sk_buff *skb; 51271da177e4SLinus Torvalds 51286ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 51296ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 51301da177e4SLinus Torvalds 513152de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 51321da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 51331da177e4SLinus Torvalds hci_sched_acl(hdev); 51341da177e4SLinus Torvalds hci_sched_sco(hdev); 5135b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 51366ed58ec5SVille Tervo hci_sched_le(hdev); 513752de599eSMarcel Holtmann } 51386ed58ec5SVille Tervo 51391da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 51401da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 514157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 51421da177e4SLinus Torvalds } 51431da177e4SLinus Torvalds 514425985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 51451da177e4SLinus Torvalds 51461da177e4SLinus Torvalds /* ACL data packet */ 51476039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 51481da177e4SLinus Torvalds { 51491da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 51501da177e4SLinus Torvalds struct hci_conn *conn; 51511da177e4SLinus Torvalds __u16 handle, flags; 51521da177e4SLinus Torvalds 51531da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 51541da177e4SLinus Torvalds 51551da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 51561da177e4SLinus Torvalds flags = hci_flags(handle); 51571da177e4SLinus Torvalds handle = hci_handle(handle); 51581da177e4SLinus Torvalds 5159f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 5160a8c5fb1aSGustavo Padovan handle, flags); 51611da177e4SLinus Torvalds 51621da177e4SLinus Torvalds hdev->stat.acl_rx++; 51631da177e4SLinus Torvalds 51641da177e4SLinus Torvalds hci_dev_lock(hdev); 51651da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 51661da177e4SLinus Torvalds hci_dev_unlock(hdev); 51671da177e4SLinus Torvalds 51681da177e4SLinus Torvalds if (conn) { 516965983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 517004837f64SMarcel Holtmann 51711da177e4SLinus Torvalds /* Send to upper protocol */ 5172686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 51731da177e4SLinus Torvalds return; 51741da177e4SLinus Torvalds } else { 51751da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 51761da177e4SLinus Torvalds hdev->name, handle); 51771da177e4SLinus Torvalds } 51781da177e4SLinus Torvalds 51791da177e4SLinus Torvalds kfree_skb(skb); 51801da177e4SLinus Torvalds } 51811da177e4SLinus Torvalds 51821da177e4SLinus Torvalds /* SCO data packet */ 51836039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 51841da177e4SLinus Torvalds { 51851da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 51861da177e4SLinus Torvalds struct hci_conn *conn; 51871da177e4SLinus Torvalds __u16 handle; 51881da177e4SLinus Torvalds 51891da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 51901da177e4SLinus Torvalds 51911da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 51921da177e4SLinus Torvalds 5193f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 51941da177e4SLinus Torvalds 51951da177e4SLinus Torvalds hdev->stat.sco_rx++; 51961da177e4SLinus Torvalds 51971da177e4SLinus Torvalds hci_dev_lock(hdev); 51981da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 51991da177e4SLinus Torvalds hci_dev_unlock(hdev); 52001da177e4SLinus Torvalds 52011da177e4SLinus Torvalds if (conn) { 52021da177e4SLinus Torvalds /* Send to upper protocol */ 5203686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 52041da177e4SLinus Torvalds return; 52051da177e4SLinus Torvalds } else { 52061da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 52071da177e4SLinus Torvalds hdev->name, handle); 52081da177e4SLinus Torvalds } 52091da177e4SLinus Torvalds 52101da177e4SLinus Torvalds kfree_skb(skb); 52111da177e4SLinus Torvalds } 52121da177e4SLinus Torvalds 52139238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 52149238f36aSJohan Hedberg { 52159238f36aSJohan Hedberg struct sk_buff *skb; 52169238f36aSJohan Hedberg 52179238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 52189238f36aSJohan Hedberg if (!skb) 52199238f36aSJohan Hedberg return true; 52209238f36aSJohan Hedberg 52219238f36aSJohan Hedberg return bt_cb(skb)->req.start; 52229238f36aSJohan Hedberg } 52239238f36aSJohan Hedberg 522442c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 522542c6b129SJohan Hedberg { 522642c6b129SJohan Hedberg struct hci_command_hdr *sent; 522742c6b129SJohan Hedberg struct sk_buff *skb; 522842c6b129SJohan Hedberg u16 opcode; 522942c6b129SJohan Hedberg 523042c6b129SJohan Hedberg if (!hdev->sent_cmd) 523142c6b129SJohan Hedberg return; 523242c6b129SJohan Hedberg 523342c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 523442c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 523542c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 523642c6b129SJohan Hedberg return; 523742c6b129SJohan Hedberg 523842c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 523942c6b129SJohan Hedberg if (!skb) 524042c6b129SJohan Hedberg return; 524142c6b129SJohan Hedberg 524242c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 524342c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 524442c6b129SJohan Hedberg } 524542c6b129SJohan Hedberg 52469238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 52479238f36aSJohan Hedberg { 52489238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 52499238f36aSJohan Hedberg struct sk_buff *skb; 52509238f36aSJohan Hedberg unsigned long flags; 52519238f36aSJohan Hedberg 52529238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 52539238f36aSJohan Hedberg 525442c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 525542c6b129SJohan Hedberg * sent we need to do special handling of it. 52569238f36aSJohan Hedberg */ 525742c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 525842c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 525942c6b129SJohan Hedberg * reset complete event during init and any pending 526042c6b129SJohan Hedberg * command will never be completed. In such a case we 526142c6b129SJohan Hedberg * need to resend whatever was the last sent 526242c6b129SJohan Hedberg * command. 526342c6b129SJohan Hedberg */ 526442c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 526542c6b129SJohan Hedberg hci_resend_last(hdev); 526642c6b129SJohan Hedberg 52679238f36aSJohan Hedberg return; 526842c6b129SJohan Hedberg } 52699238f36aSJohan Hedberg 52709238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 52719238f36aSJohan Hedberg * this request the request is not yet complete. 52729238f36aSJohan Hedberg */ 52739238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 52749238f36aSJohan Hedberg return; 52759238f36aSJohan Hedberg 52769238f36aSJohan Hedberg /* If this was the last command in a request the complete 52779238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 52789238f36aSJohan Hedberg * command queue (hdev->cmd_q). 52799238f36aSJohan Hedberg */ 52809238f36aSJohan Hedberg if (hdev->sent_cmd) { 52819238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 528253e21fbcSJohan Hedberg 528353e21fbcSJohan Hedberg if (req_complete) { 528453e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 528553e21fbcSJohan Hedberg * avoid calling the callback more than once if 528653e21fbcSJohan Hedberg * this function gets called again. 528753e21fbcSJohan Hedberg */ 528853e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 528953e21fbcSJohan Hedberg 52909238f36aSJohan Hedberg goto call_complete; 52919238f36aSJohan Hedberg } 529253e21fbcSJohan Hedberg } 52939238f36aSJohan Hedberg 52949238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 52959238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 52969238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 52979238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 52989238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 52999238f36aSJohan Hedberg break; 53009238f36aSJohan Hedberg } 53019238f36aSJohan Hedberg 53029238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 53039238f36aSJohan Hedberg kfree_skb(skb); 53049238f36aSJohan Hedberg } 53059238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 53069238f36aSJohan Hedberg 53079238f36aSJohan Hedberg call_complete: 53089238f36aSJohan Hedberg if (req_complete) 53099238f36aSJohan Hedberg req_complete(hdev, status); 53109238f36aSJohan Hedberg } 53119238f36aSJohan Hedberg 5312b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 53131da177e4SLinus Torvalds { 5314b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 53151da177e4SLinus Torvalds struct sk_buff *skb; 53161da177e4SLinus Torvalds 53171da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 53181da177e4SLinus Torvalds 53191da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 5320cd82e61cSMarcel Holtmann /* Send copy to monitor */ 5321cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 5322cd82e61cSMarcel Holtmann 53231da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 53241da177e4SLinus Torvalds /* Send copy to the sockets */ 5325470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 53261da177e4SLinus Torvalds } 53271da177e4SLinus Torvalds 5328fee746b0SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 53291da177e4SLinus Torvalds kfree_skb(skb); 53301da177e4SLinus Torvalds continue; 53311da177e4SLinus Torvalds } 53321da177e4SLinus Torvalds 53331da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 53341da177e4SLinus Torvalds /* Don't process data packets in this states. */ 53350d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 53361da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 53371da177e4SLinus Torvalds case HCI_SCODATA_PKT: 53381da177e4SLinus Torvalds kfree_skb(skb); 53391da177e4SLinus Torvalds continue; 53403ff50b79SStephen Hemminger } 53411da177e4SLinus Torvalds } 53421da177e4SLinus Torvalds 53431da177e4SLinus Torvalds /* Process frame */ 53440d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 53451da177e4SLinus Torvalds case HCI_EVENT_PKT: 5346b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 53471da177e4SLinus Torvalds hci_event_packet(hdev, skb); 53481da177e4SLinus Torvalds break; 53491da177e4SLinus Torvalds 53501da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 53511da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 53521da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 53531da177e4SLinus Torvalds break; 53541da177e4SLinus Torvalds 53551da177e4SLinus Torvalds case HCI_SCODATA_PKT: 53561da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 53571da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 53581da177e4SLinus Torvalds break; 53591da177e4SLinus Torvalds 53601da177e4SLinus Torvalds default: 53611da177e4SLinus Torvalds kfree_skb(skb); 53621da177e4SLinus Torvalds break; 53631da177e4SLinus Torvalds } 53641da177e4SLinus Torvalds } 53651da177e4SLinus Torvalds } 53661da177e4SLinus Torvalds 5367c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 53681da177e4SLinus Torvalds { 5369c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 53701da177e4SLinus Torvalds struct sk_buff *skb; 53711da177e4SLinus Torvalds 53722104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 53732104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 53741da177e4SLinus Torvalds 53751da177e4SLinus Torvalds /* Send queued commands */ 53765a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 53775a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 53785a08ecceSAndrei Emeltchenko if (!skb) 53795a08ecceSAndrei Emeltchenko return; 53805a08ecceSAndrei Emeltchenko 53811da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 53821da177e4SLinus Torvalds 5383a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 538470f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 53851da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 538657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 53877bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 538865cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 53897bdb8a5cSSzymon Janc else 539065cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 539165cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 53921da177e4SLinus Torvalds } else { 53931da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 5394c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 53951da177e4SLinus Torvalds } 53961da177e4SLinus Torvalds } 53971da177e4SLinus Torvalds } 5398b1efcc28SAndre Guedes 5399b1efcc28SAndre Guedes void hci_req_add_le_scan_disable(struct hci_request *req) 5400b1efcc28SAndre Guedes { 5401b1efcc28SAndre Guedes struct hci_cp_le_set_scan_enable cp; 5402b1efcc28SAndre Guedes 5403b1efcc28SAndre Guedes memset(&cp, 0, sizeof(cp)); 5404b1efcc28SAndre Guedes cp.enable = LE_SCAN_DISABLE; 5405b1efcc28SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 5406b1efcc28SAndre Guedes } 5407a4790dbdSAndre Guedes 54088ef30fd3SAndre Guedes void hci_req_add_le_passive_scan(struct hci_request *req) 54098ef30fd3SAndre Guedes { 54108ef30fd3SAndre Guedes struct hci_cp_le_set_scan_param param_cp; 54118ef30fd3SAndre Guedes struct hci_cp_le_set_scan_enable enable_cp; 54128ef30fd3SAndre Guedes struct hci_dev *hdev = req->hdev; 54138ef30fd3SAndre Guedes u8 own_addr_type; 54148ef30fd3SAndre Guedes 54156ab535a7SMarcel Holtmann /* Set require_privacy to false since no SCAN_REQ are send 54166ab535a7SMarcel Holtmann * during passive scanning. Not using an unresolvable address 54176ab535a7SMarcel Holtmann * here is important so that peer devices using direct 54186ab535a7SMarcel Holtmann * advertising with our address will be correctly reported 54196ab535a7SMarcel Holtmann * by the controller. 54208ef30fd3SAndre Guedes */ 54216ab535a7SMarcel Holtmann if (hci_update_random_address(req, false, &own_addr_type)) 54228ef30fd3SAndre Guedes return; 54238ef30fd3SAndre Guedes 54248ef30fd3SAndre Guedes memset(¶m_cp, 0, sizeof(param_cp)); 54258ef30fd3SAndre Guedes param_cp.type = LE_SCAN_PASSIVE; 54268ef30fd3SAndre Guedes param_cp.interval = cpu_to_le16(hdev->le_scan_interval); 54278ef30fd3SAndre Guedes param_cp.window = cpu_to_le16(hdev->le_scan_window); 54288ef30fd3SAndre Guedes param_cp.own_address_type = own_addr_type; 54298ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_PARAM, sizeof(param_cp), 54308ef30fd3SAndre Guedes ¶m_cp); 54318ef30fd3SAndre Guedes 54328ef30fd3SAndre Guedes memset(&enable_cp, 0, sizeof(enable_cp)); 54338ef30fd3SAndre Guedes enable_cp.enable = LE_SCAN_ENABLE; 54344340a124SAndre Guedes enable_cp.filter_dup = LE_SCAN_FILTER_DUP_ENABLE; 54358ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(enable_cp), 54368ef30fd3SAndre Guedes &enable_cp); 54378ef30fd3SAndre Guedes } 54388ef30fd3SAndre Guedes 5439a4790dbdSAndre Guedes static void update_background_scan_complete(struct hci_dev *hdev, u8 status) 5440a4790dbdSAndre Guedes { 5441a4790dbdSAndre Guedes if (status) 5442a4790dbdSAndre Guedes BT_DBG("HCI request failed to update background scanning: " 5443a4790dbdSAndre Guedes "status 0x%2.2x", status); 5444a4790dbdSAndre Guedes } 5445a4790dbdSAndre Guedes 5446a4790dbdSAndre Guedes /* This function controls the background scanning based on hdev->pend_le_conns 5447a4790dbdSAndre Guedes * list. If there are pending LE connection we start the background scanning, 5448a4790dbdSAndre Guedes * otherwise we stop it. 5449a4790dbdSAndre Guedes * 5450a4790dbdSAndre Guedes * This function requires the caller holds hdev->lock. 5451a4790dbdSAndre Guedes */ 5452a4790dbdSAndre Guedes void hci_update_background_scan(struct hci_dev *hdev) 5453a4790dbdSAndre Guedes { 5454a4790dbdSAndre Guedes struct hci_request req; 5455a4790dbdSAndre Guedes struct hci_conn *conn; 5456a4790dbdSAndre Guedes int err; 5457a4790dbdSAndre Guedes 5458c20c02d5SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags) || 5459c20c02d5SMarcel Holtmann test_bit(HCI_INIT, &hdev->flags) || 5460c20c02d5SMarcel Holtmann test_bit(HCI_SETUP, &hdev->dev_flags) || 5461d603b76bSMarcel Holtmann test_bit(HCI_CONFIG, &hdev->dev_flags) || 5462b8221770SMarcel Holtmann test_bit(HCI_AUTO_OFF, &hdev->dev_flags) || 5463c20c02d5SMarcel Holtmann test_bit(HCI_UNREGISTER, &hdev->dev_flags)) 54641c1697c0SMarcel Holtmann return; 54651c1697c0SMarcel Holtmann 5466a70f4b5fSJohan Hedberg /* No point in doing scanning if LE support hasn't been enabled */ 5467a70f4b5fSJohan Hedberg if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 5468a70f4b5fSJohan Hedberg return; 5469a70f4b5fSJohan Hedberg 5470ae23ada4SJohan Hedberg /* If discovery is active don't interfere with it */ 5471ae23ada4SJohan Hedberg if (hdev->discovery.state != DISCOVERY_STOPPED) 5472ae23ada4SJohan Hedberg return; 5473ae23ada4SJohan Hedberg 5474a4790dbdSAndre Guedes hci_req_init(&req, hdev); 5475a4790dbdSAndre Guedes 5476d1d588c1SJohan Hedberg if (list_empty(&hdev->pend_le_conns) && 547766f8455aSJohan Hedberg list_empty(&hdev->pend_le_reports)) { 54780d2bf134SJohan Hedberg /* If there is no pending LE connections or devices 54790d2bf134SJohan Hedberg * to be scanned for, we should stop the background 54800d2bf134SJohan Hedberg * scanning. 5481a4790dbdSAndre Guedes */ 5482a4790dbdSAndre Guedes 5483a4790dbdSAndre Guedes /* If controller is not scanning we are done. */ 5484a4790dbdSAndre Guedes if (!test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 5485a4790dbdSAndre Guedes return; 5486a4790dbdSAndre Guedes 5487a4790dbdSAndre Guedes hci_req_add_le_scan_disable(&req); 5488a4790dbdSAndre Guedes 5489a4790dbdSAndre Guedes BT_DBG("%s stopping background scanning", hdev->name); 5490a4790dbdSAndre Guedes } else { 5491a4790dbdSAndre Guedes /* If there is at least one pending LE connection, we should 5492a4790dbdSAndre Guedes * keep the background scan running. 5493a4790dbdSAndre Guedes */ 5494a4790dbdSAndre Guedes 5495a4790dbdSAndre Guedes /* If controller is connecting, we should not start scanning 5496a4790dbdSAndre Guedes * since some controllers are not able to scan and connect at 5497a4790dbdSAndre Guedes * the same time. 5498a4790dbdSAndre Guedes */ 5499a4790dbdSAndre Guedes conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT); 5500a4790dbdSAndre Guedes if (conn) 5501a4790dbdSAndre Guedes return; 5502a4790dbdSAndre Guedes 55034340a124SAndre Guedes /* If controller is currently scanning, we stop it to ensure we 55044340a124SAndre Guedes * don't miss any advertising (due to duplicates filter). 55054340a124SAndre Guedes */ 55064340a124SAndre Guedes if (test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 55074340a124SAndre Guedes hci_req_add_le_scan_disable(&req); 55084340a124SAndre Guedes 55098ef30fd3SAndre Guedes hci_req_add_le_passive_scan(&req); 5510a4790dbdSAndre Guedes 5511a4790dbdSAndre Guedes BT_DBG("%s starting background scanning", hdev->name); 5512a4790dbdSAndre Guedes } 5513a4790dbdSAndre Guedes 5514a4790dbdSAndre Guedes err = hci_req_run(&req, update_background_scan_complete); 5515a4790dbdSAndre Guedes if (err) 5516a4790dbdSAndre Guedes BT_ERR("Failed to run HCI request: err %d", err); 5517a4790dbdSAndre Guedes } 5518