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 16895d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 169053b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 16915d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 1692a6d0d690SMarcel Holtmann 1693a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 16945afeac14SMarcel Holtmann if ((lmp_sc_capable(hdev) || 1695111902f7SMarcel Holtmann test_bit(HCI_FORCE_SC, &hdev->dbg_flags)) && 1696a6d0d690SMarcel Holtmann test_bit(HCI_SC_ENABLED, &hdev->dev_flags)) { 1697a6d0d690SMarcel Holtmann u8 support = 0x01; 1698a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 1699a6d0d690SMarcel Holtmann sizeof(support), &support); 1700a6d0d690SMarcel Holtmann } 17015d4e7e8dSJohan Hedberg } 17025d4e7e8dSJohan Hedberg 17032177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 17042177bab5SJohan Hedberg { 17052177bab5SJohan Hedberg int err; 17062177bab5SJohan Hedberg 17072177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 17082177bab5SJohan Hedberg if (err < 0) 17092177bab5SJohan Hedberg return err; 17102177bab5SJohan Hedberg 17114b4148e9SMarcel Holtmann /* The Device Under Test (DUT) mode is special and available for 17124b4148e9SMarcel Holtmann * all controller types. So just create it early on. 17134b4148e9SMarcel Holtmann */ 17144b4148e9SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 17154b4148e9SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 17164b4148e9SMarcel Holtmann &dut_mode_fops); 17174b4148e9SMarcel Holtmann } 17184b4148e9SMarcel Holtmann 17192177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 17202177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 17212177bab5SJohan Hedberg * first stage init. 17222177bab5SJohan Hedberg */ 17232177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 17242177bab5SJohan Hedberg return 0; 17252177bab5SJohan Hedberg 17262177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 17272177bab5SJohan Hedberg if (err < 0) 17282177bab5SJohan Hedberg return err; 17292177bab5SJohan Hedberg 17305d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 17315d4e7e8dSJohan Hedberg if (err < 0) 17325d4e7e8dSJohan Hedberg return err; 17335d4e7e8dSJohan Hedberg 1734baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 1735baf27f6eSMarcel Holtmann if (err < 0) 1736baf27f6eSMarcel Holtmann return err; 1737baf27f6eSMarcel Holtmann 1738baf27f6eSMarcel Holtmann /* Only create debugfs entries during the initial setup 1739baf27f6eSMarcel Holtmann * phase and not every time the controller gets powered on. 1740baf27f6eSMarcel Holtmann */ 1741baf27f6eSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 1742baf27f6eSMarcel Holtmann return 0; 1743baf27f6eSMarcel Holtmann 1744dfb826a8SMarcel Holtmann debugfs_create_file("features", 0444, hdev->debugfs, hdev, 1745dfb826a8SMarcel Holtmann &features_fops); 1746ceeb3bc0SMarcel Holtmann debugfs_create_u16("manufacturer", 0444, hdev->debugfs, 1747ceeb3bc0SMarcel Holtmann &hdev->manufacturer); 1748ceeb3bc0SMarcel Holtmann debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver); 1749ceeb3bc0SMarcel Holtmann debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev); 175070afe0b8SMarcel Holtmann debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev, 175170afe0b8SMarcel Holtmann &blacklist_fops); 17526659358eSJohan Hedberg debugfs_create_file("whitelist", 0444, hdev->debugfs, hdev, 17536659358eSJohan Hedberg &whitelist_fops); 175447219839SMarcel Holtmann debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 175547219839SMarcel Holtmann 175631ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_min_age", 0644, hdev->debugfs, hdev, 175731ad1691SAndrzej Kaczmarek &conn_info_min_age_fops); 175831ad1691SAndrzej Kaczmarek debugfs_create_file("conn_info_max_age", 0644, hdev->debugfs, hdev, 175931ad1691SAndrzej Kaczmarek &conn_info_max_age_fops); 176031ad1691SAndrzej Kaczmarek 1761baf27f6eSMarcel Holtmann if (lmp_bredr_capable(hdev)) { 1762baf27f6eSMarcel Holtmann debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, 1763baf27f6eSMarcel Holtmann hdev, &inquiry_cache_fops); 176402d08d15SMarcel Holtmann debugfs_create_file("link_keys", 0400, hdev->debugfs, 176502d08d15SMarcel Holtmann hdev, &link_keys_fops); 1766babdbb3cSMarcel Holtmann debugfs_create_file("dev_class", 0444, hdev->debugfs, 1767babdbb3cSMarcel Holtmann hdev, &dev_class_fops); 1768041000b9SMarcel Holtmann debugfs_create_file("voice_setting", 0444, hdev->debugfs, 1769041000b9SMarcel Holtmann hdev, &voice_setting_fops); 1770baf27f6eSMarcel Holtmann } 1771baf27f6eSMarcel Holtmann 177206f5b778SMarcel Holtmann if (lmp_ssp_capable(hdev)) { 1773ebd1e33bSMarcel Holtmann debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 1774ebd1e33bSMarcel Holtmann hdev, &auto_accept_delay_fops); 17755afeac14SMarcel Holtmann debugfs_create_file("force_sc_support", 0644, hdev->debugfs, 17765afeac14SMarcel Holtmann hdev, &force_sc_support_fops); 1777134c2a89SMarcel Holtmann debugfs_create_file("sc_only_mode", 0444, hdev->debugfs, 1778134c2a89SMarcel Holtmann hdev, &sc_only_mode_fops); 177906f5b778SMarcel Holtmann } 1780ebd1e33bSMarcel Holtmann 17812bfa3531SMarcel Holtmann if (lmp_sniff_capable(hdev)) { 17822bfa3531SMarcel Holtmann debugfs_create_file("idle_timeout", 0644, hdev->debugfs, 17832bfa3531SMarcel Holtmann hdev, &idle_timeout_fops); 17842bfa3531SMarcel Holtmann debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs, 17852bfa3531SMarcel Holtmann hdev, &sniff_min_interval_fops); 17862bfa3531SMarcel Holtmann debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs, 17872bfa3531SMarcel Holtmann hdev, &sniff_max_interval_fops); 17882bfa3531SMarcel Holtmann } 17892bfa3531SMarcel Holtmann 1790d0f729b8SMarcel Holtmann if (lmp_le_capable(hdev)) { 1791ac345813SMarcel Holtmann debugfs_create_file("identity", 0400, hdev->debugfs, 1792ac345813SMarcel Holtmann hdev, &identity_fops); 1793ac345813SMarcel Holtmann debugfs_create_file("rpa_timeout", 0644, hdev->debugfs, 1794ac345813SMarcel Holtmann hdev, &rpa_timeout_fops); 17957a4cd51dSMarcel Holtmann debugfs_create_file("random_address", 0444, hdev->debugfs, 17967a4cd51dSMarcel Holtmann hdev, &random_address_fops); 1797e7b8fc92SMarcel Holtmann debugfs_create_file("static_address", 0444, hdev->debugfs, 1798e7b8fc92SMarcel Holtmann hdev, &static_address_fops); 1799b32bba6cSMarcel Holtmann 1800b32bba6cSMarcel Holtmann /* For controllers with a public address, provide a debug 1801b32bba6cSMarcel Holtmann * option to force the usage of the configured static 1802b32bba6cSMarcel Holtmann * address. By default the public address is used. 1803b32bba6cSMarcel Holtmann */ 1804b32bba6cSMarcel Holtmann if (bacmp(&hdev->bdaddr, BDADDR_ANY)) 1805b32bba6cSMarcel Holtmann debugfs_create_file("force_static_address", 0644, 1806b32bba6cSMarcel Holtmann hdev->debugfs, hdev, 1807b32bba6cSMarcel Holtmann &force_static_address_fops); 1808b32bba6cSMarcel Holtmann 1809b32bba6cSMarcel Holtmann debugfs_create_u8("white_list_size", 0444, hdev->debugfs, 1810b32bba6cSMarcel Holtmann &hdev->le_white_list_size); 1811d2ab0ac1SMarcel Holtmann debugfs_create_file("white_list", 0444, hdev->debugfs, hdev, 1812d2ab0ac1SMarcel Holtmann &white_list_fops); 18133698d704SMarcel Holtmann debugfs_create_file("identity_resolving_keys", 0400, 18143698d704SMarcel Holtmann hdev->debugfs, hdev, 18153698d704SMarcel Holtmann &identity_resolving_keys_fops); 18168f8625cdSMarcel Holtmann debugfs_create_file("long_term_keys", 0400, hdev->debugfs, 18178f8625cdSMarcel Holtmann hdev, &long_term_keys_fops); 18184e70c7e7SMarcel Holtmann debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, 18194e70c7e7SMarcel Holtmann hdev, &conn_min_interval_fops); 18204e70c7e7SMarcel Holtmann debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, 18214e70c7e7SMarcel Holtmann hdev, &conn_max_interval_fops); 1822816a93d1SMarcel Holtmann debugfs_create_file("conn_latency", 0644, hdev->debugfs, 1823816a93d1SMarcel Holtmann hdev, &conn_latency_fops); 1824f1649577SMarcel Holtmann debugfs_create_file("supervision_timeout", 0644, hdev->debugfs, 1825f1649577SMarcel Holtmann hdev, &supervision_timeout_fops); 18263f959d46SMarcel Holtmann debugfs_create_file("adv_channel_map", 0644, hdev->debugfs, 18273f959d46SMarcel Holtmann hdev, &adv_channel_map_fops); 18280b3c7d37SMarcel Holtmann debugfs_create_file("device_list", 0444, hdev->debugfs, hdev, 18290b3c7d37SMarcel Holtmann &device_list_fops); 1830b9a7a61eSLukasz Rymanowski debugfs_create_u16("discov_interleaved_timeout", 0644, 1831b9a7a61eSLukasz Rymanowski hdev->debugfs, 1832b9a7a61eSLukasz Rymanowski &hdev->discov_interleaved_timeout); 1833d0f729b8SMarcel Holtmann } 1834e7b8fc92SMarcel Holtmann 1835baf27f6eSMarcel Holtmann return 0; 18362177bab5SJohan Hedberg } 18372177bab5SJohan Hedberg 18380ebca7d6SMarcel Holtmann static void hci_init0_req(struct hci_request *req, unsigned long opt) 18390ebca7d6SMarcel Holtmann { 18400ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 18410ebca7d6SMarcel Holtmann 18420ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 18430ebca7d6SMarcel Holtmann 18440ebca7d6SMarcel Holtmann /* Reset */ 18450ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 18460ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 18470ebca7d6SMarcel Holtmann 18480ebca7d6SMarcel Holtmann /* Read Local Version */ 18490ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 18500ebca7d6SMarcel Holtmann 18510ebca7d6SMarcel Holtmann /* Read BD Address */ 18520ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 18530ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 18540ebca7d6SMarcel Holtmann } 18550ebca7d6SMarcel Holtmann 18560ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 18570ebca7d6SMarcel Holtmann { 18580ebca7d6SMarcel Holtmann int err; 18590ebca7d6SMarcel Holtmann 1860cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 1861cc78b44bSMarcel Holtmann return 0; 1862cc78b44bSMarcel Holtmann 18630ebca7d6SMarcel Holtmann err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT); 18640ebca7d6SMarcel Holtmann if (err < 0) 18650ebca7d6SMarcel Holtmann return err; 18660ebca7d6SMarcel Holtmann 18670ebca7d6SMarcel Holtmann return 0; 18680ebca7d6SMarcel Holtmann } 18690ebca7d6SMarcel Holtmann 187042c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 18711da177e4SLinus Torvalds { 18721da177e4SLinus Torvalds __u8 scan = opt; 18731da177e4SLinus Torvalds 187442c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 18751da177e4SLinus Torvalds 18761da177e4SLinus Torvalds /* Inquiry and Page scans */ 187742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 18781da177e4SLinus Torvalds } 18791da177e4SLinus Torvalds 188042c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 18811da177e4SLinus Torvalds { 18821da177e4SLinus Torvalds __u8 auth = opt; 18831da177e4SLinus Torvalds 188442c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 18851da177e4SLinus Torvalds 18861da177e4SLinus Torvalds /* Authentication */ 188742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 18881da177e4SLinus Torvalds } 18891da177e4SLinus Torvalds 189042c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 18911da177e4SLinus Torvalds { 18921da177e4SLinus Torvalds __u8 encrypt = opt; 18931da177e4SLinus Torvalds 189442c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 18951da177e4SLinus Torvalds 1896e4e8e37cSMarcel Holtmann /* Encryption */ 189742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 18981da177e4SLinus Torvalds } 18991da177e4SLinus Torvalds 190042c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1901e4e8e37cSMarcel Holtmann { 1902e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1903e4e8e37cSMarcel Holtmann 190442c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1905e4e8e37cSMarcel Holtmann 1906e4e8e37cSMarcel Holtmann /* Default link policy */ 190742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1908e4e8e37cSMarcel Holtmann } 1909e4e8e37cSMarcel Holtmann 19101da177e4SLinus Torvalds /* Get HCI device by index. 19111da177e4SLinus Torvalds * Device is held on return. */ 19121da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 19131da177e4SLinus Torvalds { 19148035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 19151da177e4SLinus Torvalds 19161da177e4SLinus Torvalds BT_DBG("%d", index); 19171da177e4SLinus Torvalds 19181da177e4SLinus Torvalds if (index < 0) 19191da177e4SLinus Torvalds return NULL; 19201da177e4SLinus Torvalds 19211da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 19228035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 19231da177e4SLinus Torvalds if (d->id == index) { 19241da177e4SLinus Torvalds hdev = hci_dev_hold(d); 19251da177e4SLinus Torvalds break; 19261da177e4SLinus Torvalds } 19271da177e4SLinus Torvalds } 19281da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 19291da177e4SLinus Torvalds return hdev; 19301da177e4SLinus Torvalds } 19311da177e4SLinus Torvalds 19321da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1933ff9ef578SJohan Hedberg 193430dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 193530dc78e1SJohan Hedberg { 193630dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 193730dc78e1SJohan Hedberg 19386fbe195dSAndre Guedes switch (discov->state) { 1939343f935bSAndre Guedes case DISCOVERY_FINDING: 19406fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 194130dc78e1SJohan Hedberg return true; 194230dc78e1SJohan Hedberg 19436fbe195dSAndre Guedes default: 194430dc78e1SJohan Hedberg return false; 194530dc78e1SJohan Hedberg } 19466fbe195dSAndre Guedes } 194730dc78e1SJohan Hedberg 1948ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1949ff9ef578SJohan Hedberg { 1950bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 1951bb3e0a33SJohan Hedberg 1952ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1953ff9ef578SJohan Hedberg 1954bb3e0a33SJohan Hedberg if (old_state == state) 1955ff9ef578SJohan Hedberg return; 1956ff9ef578SJohan Hedberg 1957bb3e0a33SJohan Hedberg hdev->discovery.state = state; 1958bb3e0a33SJohan Hedberg 1959ff9ef578SJohan Hedberg switch (state) { 1960ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1961c54c3860SAndre Guedes hci_update_background_scan(hdev); 1962c54c3860SAndre Guedes 1963bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1964ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1965ff9ef578SJohan Hedberg break; 1966ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1967ff9ef578SJohan Hedberg break; 1968343f935bSAndre Guedes case DISCOVERY_FINDING: 1969ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1970ff9ef578SJohan Hedberg break; 197130dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 197230dc78e1SJohan Hedberg break; 1973ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1974ff9ef578SJohan Hedberg break; 1975ff9ef578SJohan Hedberg } 1976ff9ef578SJohan Hedberg } 1977ff9ef578SJohan Hedberg 19781f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 19791da177e4SLinus Torvalds { 198030883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1981b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 19821da177e4SLinus Torvalds 1983561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1984561aafbcSJohan Hedberg list_del(&p->all); 1985b57c1a56SJohan Hedberg kfree(p); 19861da177e4SLinus Torvalds } 1987561aafbcSJohan Hedberg 1988561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1989561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 19901da177e4SLinus Torvalds } 19911da177e4SLinus Torvalds 1992a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1993a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 19941da177e4SLinus Torvalds { 199530883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 19961da177e4SLinus Torvalds struct inquiry_entry *e; 19971da177e4SLinus Torvalds 19986ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 19991da177e4SLinus Torvalds 2000561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 20011da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 20021da177e4SLinus Torvalds return e; 20031da177e4SLinus Torvalds } 20041da177e4SLinus Torvalds 2005b57c1a56SJohan Hedberg return NULL; 2006b57c1a56SJohan Hedberg } 2007b57c1a56SJohan Hedberg 2008561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 2009561aafbcSJohan Hedberg bdaddr_t *bdaddr) 2010561aafbcSJohan Hedberg { 201130883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2012561aafbcSJohan Hedberg struct inquiry_entry *e; 2013561aafbcSJohan Hedberg 20146ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 2015561aafbcSJohan Hedberg 2016561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 2017561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 2018561aafbcSJohan Hedberg return e; 2019561aafbcSJohan Hedberg } 2020561aafbcSJohan Hedberg 2021561aafbcSJohan Hedberg return NULL; 2022561aafbcSJohan Hedberg } 2023561aafbcSJohan Hedberg 202430dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 202530dc78e1SJohan Hedberg bdaddr_t *bdaddr, 202630dc78e1SJohan Hedberg int state) 202730dc78e1SJohan Hedberg { 202830dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 202930dc78e1SJohan Hedberg struct inquiry_entry *e; 203030dc78e1SJohan Hedberg 20316ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 203230dc78e1SJohan Hedberg 203330dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 203430dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 203530dc78e1SJohan Hedberg return e; 203630dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 203730dc78e1SJohan Hedberg return e; 203830dc78e1SJohan Hedberg } 203930dc78e1SJohan Hedberg 204030dc78e1SJohan Hedberg return NULL; 204130dc78e1SJohan Hedberg } 204230dc78e1SJohan Hedberg 2043a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 2044a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 2045a3d4e20aSJohan Hedberg { 2046a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 2047a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 2048a3d4e20aSJohan Hedberg struct inquiry_entry *p; 2049a3d4e20aSJohan Hedberg 2050a3d4e20aSJohan Hedberg list_del(&ie->list); 2051a3d4e20aSJohan Hedberg 2052a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 2053a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 2054a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 2055a3d4e20aSJohan Hedberg break; 2056a3d4e20aSJohan Hedberg pos = &p->list; 2057a3d4e20aSJohan Hedberg } 2058a3d4e20aSJohan Hedberg 2059a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 2060a3d4e20aSJohan Hedberg } 2061a3d4e20aSJohan Hedberg 2062af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 2063af58925cSMarcel Holtmann bool name_known) 20641da177e4SLinus Torvalds { 206530883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 206670f23020SAndrei Emeltchenko struct inquiry_entry *ie; 2067af58925cSMarcel Holtmann u32 flags = 0; 20681da177e4SLinus Torvalds 20696ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 20701da177e4SLinus Torvalds 20712b2fec4dSSzymon Janc hci_remove_remote_oob_data(hdev, &data->bdaddr); 20722b2fec4dSSzymon Janc 2073af58925cSMarcel Holtmann if (!data->ssp_mode) 2074af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 2075388fc8faSJohan Hedberg 207670f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 2077a3d4e20aSJohan Hedberg if (ie) { 2078af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 2079af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 2080388fc8faSJohan Hedberg 2081a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 2082a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 2083a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 2084a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 2085a3d4e20aSJohan Hedberg } 2086a3d4e20aSJohan Hedberg 2087561aafbcSJohan Hedberg goto update; 2088a3d4e20aSJohan Hedberg } 2089561aafbcSJohan Hedberg 20901da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 2091395365eaSMarcel Holtmann ie = kzalloc(sizeof(struct inquiry_entry), GFP_KERNEL); 2092af58925cSMarcel Holtmann if (!ie) { 2093af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 2094af58925cSMarcel Holtmann goto done; 2095af58925cSMarcel Holtmann } 209670f23020SAndrei Emeltchenko 2097561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 2098561aafbcSJohan Hedberg 2099561aafbcSJohan Hedberg if (name_known) { 2100561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2101561aafbcSJohan Hedberg } else { 2102561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 2103561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 2104561aafbcSJohan Hedberg } 2105561aafbcSJohan Hedberg 2106561aafbcSJohan Hedberg update: 2107561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 2108561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 2109561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 2110561aafbcSJohan Hedberg list_del(&ie->list); 21111da177e4SLinus Torvalds } 21121da177e4SLinus Torvalds 211370f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 211470f23020SAndrei Emeltchenko ie->timestamp = jiffies; 21151da177e4SLinus Torvalds cache->timestamp = jiffies; 21163175405bSJohan Hedberg 21173175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 2118af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 21193175405bSJohan Hedberg 2120af58925cSMarcel Holtmann done: 2121af58925cSMarcel Holtmann return flags; 21221da177e4SLinus Torvalds } 21231da177e4SLinus Torvalds 21241da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 21251da177e4SLinus Torvalds { 212630883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 21271da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 21281da177e4SLinus Torvalds struct inquiry_entry *e; 21291da177e4SLinus Torvalds int copied = 0; 21301da177e4SLinus Torvalds 2131561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 21321da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 2133b57c1a56SJohan Hedberg 2134b57c1a56SJohan Hedberg if (copied >= num) 2135b57c1a56SJohan Hedberg break; 2136b57c1a56SJohan Hedberg 21371da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 21381da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 21391da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 21401da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 21411da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 21421da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 2143b57c1a56SJohan Hedberg 21441da177e4SLinus Torvalds info++; 2145b57c1a56SJohan Hedberg copied++; 21461da177e4SLinus Torvalds } 21471da177e4SLinus Torvalds 21481da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 21491da177e4SLinus Torvalds return copied; 21501da177e4SLinus Torvalds } 21511da177e4SLinus Torvalds 215242c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 21531da177e4SLinus Torvalds { 21541da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 215542c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 21561da177e4SLinus Torvalds struct hci_cp_inquiry cp; 21571da177e4SLinus Torvalds 21581da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 21591da177e4SLinus Torvalds 21601da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 21611da177e4SLinus Torvalds return; 21621da177e4SLinus Torvalds 21631da177e4SLinus Torvalds /* Start Inquiry */ 21641da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 21651da177e4SLinus Torvalds cp.length = ir->length; 21661da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 216742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 21681da177e4SLinus Torvalds } 21691da177e4SLinus Torvalds 21703e13fa1eSAndre Guedes static int wait_inquiry(void *word) 21713e13fa1eSAndre Guedes { 21723e13fa1eSAndre Guedes schedule(); 21733e13fa1eSAndre Guedes return signal_pending(current); 21743e13fa1eSAndre Guedes } 21753e13fa1eSAndre Guedes 21761da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 21771da177e4SLinus Torvalds { 21781da177e4SLinus Torvalds __u8 __user *ptr = arg; 21791da177e4SLinus Torvalds struct hci_inquiry_req ir; 21801da177e4SLinus Torvalds struct hci_dev *hdev; 21811da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 21821da177e4SLinus Torvalds long timeo; 21831da177e4SLinus Torvalds __u8 *buf; 21841da177e4SLinus Torvalds 21851da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 21861da177e4SLinus Torvalds return -EFAULT; 21871da177e4SLinus Torvalds 21885a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 21895a08ecceSAndrei Emeltchenko if (!hdev) 21901da177e4SLinus Torvalds return -ENODEV; 21911da177e4SLinus Torvalds 21920736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 21930736cfa8SMarcel Holtmann err = -EBUSY; 21940736cfa8SMarcel Holtmann goto done; 21950736cfa8SMarcel Holtmann } 21960736cfa8SMarcel Holtmann 21974a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2198fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2199fee746b0SMarcel Holtmann goto done; 2200fee746b0SMarcel Holtmann } 2201fee746b0SMarcel Holtmann 22025b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 22035b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 22045b69bef5SMarcel Holtmann goto done; 22055b69bef5SMarcel Holtmann } 22065b69bef5SMarcel Holtmann 220756f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 220856f87901SJohan Hedberg err = -EOPNOTSUPP; 220956f87901SJohan Hedberg goto done; 221056f87901SJohan Hedberg } 221156f87901SJohan Hedberg 221209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 22131da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 2214a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 22151f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 22161da177e4SLinus Torvalds do_inquiry = 1; 22171da177e4SLinus Torvalds } 221809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 22191da177e4SLinus Torvalds 222004837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 222170f23020SAndrei Emeltchenko 222270f23020SAndrei Emeltchenko if (do_inquiry) { 222301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 222401178cd4SJohan Hedberg timeo); 222570f23020SAndrei Emeltchenko if (err < 0) 22261da177e4SLinus Torvalds goto done; 22273e13fa1eSAndre Guedes 22283e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 22293e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 22303e13fa1eSAndre Guedes */ 22313e13fa1eSAndre Guedes if (wait_on_bit(&hdev->flags, HCI_INQUIRY, wait_inquiry, 22323e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 22333e13fa1eSAndre Guedes return -EINTR; 223470f23020SAndrei Emeltchenko } 22351da177e4SLinus Torvalds 22368fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 22378fc9ced3SGustavo Padovan * 255 entries 22388fc9ced3SGustavo Padovan */ 22391da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 22401da177e4SLinus Torvalds 22411da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 22421da177e4SLinus Torvalds * copy it to the user space. 22431da177e4SLinus Torvalds */ 224470f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 224570f23020SAndrei Emeltchenko if (!buf) { 22461da177e4SLinus Torvalds err = -ENOMEM; 22471da177e4SLinus Torvalds goto done; 22481da177e4SLinus Torvalds } 22491da177e4SLinus Torvalds 225009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 22511da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 225209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 22531da177e4SLinus Torvalds 22541da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 22551da177e4SLinus Torvalds 22561da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 22571da177e4SLinus Torvalds ptr += sizeof(ir); 22581da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 22591da177e4SLinus Torvalds ir.num_rsp)) 22601da177e4SLinus Torvalds err = -EFAULT; 22611da177e4SLinus Torvalds } else 22621da177e4SLinus Torvalds err = -EFAULT; 22631da177e4SLinus Torvalds 22641da177e4SLinus Torvalds kfree(buf); 22651da177e4SLinus Torvalds 22661da177e4SLinus Torvalds done: 22671da177e4SLinus Torvalds hci_dev_put(hdev); 22681da177e4SLinus Torvalds return err; 22691da177e4SLinus Torvalds } 22701da177e4SLinus Torvalds 2271cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 22721da177e4SLinus Torvalds { 22731da177e4SLinus Torvalds int ret = 0; 22741da177e4SLinus Torvalds 22751da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 22761da177e4SLinus Torvalds 22771da177e4SLinus Torvalds hci_req_lock(hdev); 22781da177e4SLinus Torvalds 227994324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 228094324962SJohan Hovold ret = -ENODEV; 228194324962SJohan Hovold goto done; 228294324962SJohan Hovold } 228394324962SJohan Hovold 2284d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2285d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 2286a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 2287a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 2288bf543036SJohan Hedberg */ 2289a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 2290611b30f7SMarcel Holtmann ret = -ERFKILL; 2291611b30f7SMarcel Holtmann goto done; 2292611b30f7SMarcel Holtmann } 2293611b30f7SMarcel Holtmann 2294a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 2295a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 2296a5c8f270SMarcel Holtmann * be able to determine if there is a public address 2297a5c8f270SMarcel Holtmann * or not. 2298a5c8f270SMarcel Holtmann * 2299c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 2300c6beca0eSMarcel Holtmann * if a public address or static random address is 2301c6beca0eSMarcel Holtmann * available. 2302c6beca0eSMarcel Holtmann * 2303a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 2304a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 2305a5c8f270SMarcel Holtmann */ 2306c6beca0eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 2307c6beca0eSMarcel Holtmann hdev->dev_type == HCI_BREDR && 2308a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2309a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 2310a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 2311a5c8f270SMarcel Holtmann goto done; 2312a5c8f270SMarcel Holtmann } 2313a5c8f270SMarcel Holtmann } 2314a5c8f270SMarcel Holtmann 23151da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 23161da177e4SLinus Torvalds ret = -EALREADY; 23171da177e4SLinus Torvalds goto done; 23181da177e4SLinus Torvalds } 23191da177e4SLinus Torvalds 23201da177e4SLinus Torvalds if (hdev->open(hdev)) { 23211da177e4SLinus Torvalds ret = -EIO; 23221da177e4SLinus Torvalds goto done; 23231da177e4SLinus Torvalds } 23241da177e4SLinus Torvalds 23251da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 23261da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 2327f41c70c4SMarcel Holtmann 2328af202f84SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 2329af202f84SMarcel Holtmann if (hdev->setup) 2330f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 2331f41c70c4SMarcel Holtmann 2332af202f84SMarcel Holtmann /* The transport driver can set these quirks before 2333af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 2334af202f84SMarcel Holtmann * 2335af202f84SMarcel Holtmann * In case any of them is set, the controller has to 2336af202f84SMarcel Holtmann * start up as unconfigured. 2337af202f84SMarcel Holtmann */ 2338eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 2339eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 234089bc22d2SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 23410ebca7d6SMarcel Holtmann 23420ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 23430ebca7d6SMarcel Holtmann * read at least the version information provided by 23440ebca7d6SMarcel Holtmann * the Read Local Version Information command. 23450ebca7d6SMarcel Holtmann * 23460ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 23470ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 23480ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 23490ebca7d6SMarcel Holtmann */ 23500ebca7d6SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 23510ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 235289bc22d2SMarcel Holtmann } 235389bc22d2SMarcel Holtmann 23549713c17bSMarcel Holtmann if (test_bit(HCI_CONFIG, &hdev->dev_flags)) { 23559713c17bSMarcel Holtmann /* If public address change is configured, ensure that 23569713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 23579713c17bSMarcel Holtmann * support changing the public address, fail the power 23589713c17bSMarcel Holtmann * on procedure. 235924c457e2SMarcel Holtmann */ 23609713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 23619713c17bSMarcel Holtmann hdev->set_bdaddr) 236224c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 236324c457e2SMarcel Holtmann else 236424c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 236524c457e2SMarcel Holtmann } 236624c457e2SMarcel Holtmann 2367f41c70c4SMarcel Holtmann if (!ret) { 23684a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 23690736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 23702177bab5SJohan Hedberg ret = __hci_init(hdev); 23711da177e4SLinus Torvalds } 23721da177e4SLinus Torvalds 2373f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 2374f41c70c4SMarcel Holtmann 23751da177e4SLinus Torvalds if (!ret) { 23761da177e4SLinus Torvalds hci_dev_hold(hdev); 2377d6bfd59cSJohan Hedberg set_bit(HCI_RPA_EXPIRED, &hdev->dev_flags); 23781da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 23791da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 2380bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2381d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags) && 23824a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 23830736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 23841514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 238509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2386744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 238709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 238856e5cb86SJohan Hedberg } 23891da177e4SLinus Torvalds } else { 23901da177e4SLinus Torvalds /* Init failed, cleanup */ 23913eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2392c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 2393b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 23941da177e4SLinus Torvalds 23951da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 23961da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 23971da177e4SLinus Torvalds 23981da177e4SLinus Torvalds if (hdev->flush) 23991da177e4SLinus Torvalds hdev->flush(hdev); 24001da177e4SLinus Torvalds 24011da177e4SLinus Torvalds if (hdev->sent_cmd) { 24021da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 24031da177e4SLinus Torvalds hdev->sent_cmd = NULL; 24041da177e4SLinus Torvalds } 24051da177e4SLinus Torvalds 24061da177e4SLinus Torvalds hdev->close(hdev); 2407fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 24081da177e4SLinus Torvalds } 24091da177e4SLinus Torvalds 24101da177e4SLinus Torvalds done: 24111da177e4SLinus Torvalds hci_req_unlock(hdev); 24121da177e4SLinus Torvalds return ret; 24131da177e4SLinus Torvalds } 24141da177e4SLinus Torvalds 2415cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 2416cbed0ca1SJohan Hedberg 2417cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 2418cbed0ca1SJohan Hedberg { 2419cbed0ca1SJohan Hedberg struct hci_dev *hdev; 2420cbed0ca1SJohan Hedberg int err; 2421cbed0ca1SJohan Hedberg 2422cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 2423cbed0ca1SJohan Hedberg if (!hdev) 2424cbed0ca1SJohan Hedberg return -ENODEV; 2425cbed0ca1SJohan Hedberg 24264a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 2427fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 2428fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 2429fee746b0SMarcel Holtmann * possible. 2430fee746b0SMarcel Holtmann * 2431fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 2432fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 2433fee746b0SMarcel Holtmann * open the device. 2434fee746b0SMarcel Holtmann */ 24354a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 2436fee746b0SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 2437fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2438fee746b0SMarcel Holtmann goto done; 2439fee746b0SMarcel Holtmann } 2440fee746b0SMarcel Holtmann 2441e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 2442e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 2443e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 2444e1d08f40SJohan Hedberg * completed. 2445e1d08f40SJohan Hedberg */ 2446e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 2447e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 2448e1d08f40SJohan Hedberg 2449a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 2450a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 2451a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 2452a5c8f270SMarcel Holtmann */ 2453e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 2454e1d08f40SJohan Hedberg 245512aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 245612aa4f0aSMarcel Holtmann * are brought up using legacy ioctl, set the HCI_PAIRABLE bit 245712aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 245812aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 245912aa4f0aSMarcel Holtmann * to explicitly enable it. 246012aa4f0aSMarcel Holtmann */ 246112aa4f0aSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 246212aa4f0aSMarcel Holtmann !test_bit(HCI_MGMT, &hdev->dev_flags)) 246312aa4f0aSMarcel Holtmann set_bit(HCI_PAIRABLE, &hdev->dev_flags); 246412aa4f0aSMarcel Holtmann 2465cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 2466cbed0ca1SJohan Hedberg 2467fee746b0SMarcel Holtmann done: 2468cbed0ca1SJohan Hedberg hci_dev_put(hdev); 2469cbed0ca1SJohan Hedberg return err; 2470cbed0ca1SJohan Hedberg } 2471cbed0ca1SJohan Hedberg 2472d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 2473d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 2474d7347f3cSJohan Hedberg { 2475d7347f3cSJohan Hedberg struct hci_conn_params *p; 2476d7347f3cSJohan Hedberg 2477d7347f3cSJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) 2478d7347f3cSJohan Hedberg list_del_init(&p->action); 2479d7347f3cSJohan Hedberg 2480d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 2481d7347f3cSJohan Hedberg } 2482d7347f3cSJohan Hedberg 24831da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 24841da177e4SLinus Torvalds { 24851da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 24861da177e4SLinus Torvalds 248778c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 248878c04c0bSVinicius Costa Gomes 24891da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 24901da177e4SLinus Torvalds hci_req_lock(hdev); 24911da177e4SLinus Torvalds 24921da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 249365cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 24941da177e4SLinus Torvalds hci_req_unlock(hdev); 24951da177e4SLinus Torvalds return 0; 24961da177e4SLinus Torvalds } 24971da177e4SLinus Torvalds 24983eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 24993eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 2500b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 25011da177e4SLinus Torvalds 250216ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 2503e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 250416ab91abSJohan Hedberg hdev->discov_timeout = 0; 25055e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 2506310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 250716ab91abSJohan Hedberg } 250816ab91abSJohan Hedberg 2509a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 25107d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 25117d78525dSJohan Hedberg 25127ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 25134518bb0fSJohan Hedberg 25144518bb0fSJohan Hedberg if (test_bit(HCI_MGMT, &hdev->dev_flags)) 2515d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 25167ba8b4beSAndre Guedes 251709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 25181f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 25191da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 2520d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 252109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 25221da177e4SLinus Torvalds 25231da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 25241da177e4SLinus Torvalds 25251da177e4SLinus Torvalds if (hdev->flush) 25261da177e4SLinus Torvalds hdev->flush(hdev); 25271da177e4SLinus Torvalds 25281da177e4SLinus Torvalds /* Reset device */ 25291da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 25301da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 25314a964404SMarcel Holtmann if (!test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 25324a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 2533a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 25341da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 253501178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 25361da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 25371da177e4SLinus Torvalds } 25381da177e4SLinus Torvalds 2539c347b765SGustavo F. Padovan /* flush cmd work */ 2540c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 25411da177e4SLinus Torvalds 25421da177e4SLinus Torvalds /* Drop queues */ 25431da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 25441da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 25451da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 25461da177e4SLinus Torvalds 25471da177e4SLinus Torvalds /* Drop last sent command */ 25481da177e4SLinus Torvalds if (hdev->sent_cmd) { 254965cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 25501da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 25511da177e4SLinus Torvalds hdev->sent_cmd = NULL; 25521da177e4SLinus Torvalds } 25531da177e4SLinus Torvalds 2554b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 2555b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 2556b6ddb638SJohan Hedberg 25571da177e4SLinus Torvalds /* After this point our queues are empty 25581da177e4SLinus Torvalds * and no tasks are scheduled. */ 25591da177e4SLinus Torvalds hdev->close(hdev); 25601da177e4SLinus Torvalds 256135b973c9SJohan Hedberg /* Clear flags */ 2562fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 256335b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 256435b973c9SJohan Hedberg 256593c311a0SMarcel Holtmann if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 256693c311a0SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 256709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2568744cf19eSJohan Hedberg mgmt_powered(hdev, 0); 256909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 25708ee56540SMarcel Holtmann } 257193c311a0SMarcel Holtmann } 25725add6af8SJohan Hedberg 2573ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 2574536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 2575ced5c338SAndrei Emeltchenko 2576e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 257709b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 25787a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 2579e59fda8dSJohan Hedberg 25801da177e4SLinus Torvalds hci_req_unlock(hdev); 25811da177e4SLinus Torvalds 25821da177e4SLinus Torvalds hci_dev_put(hdev); 25831da177e4SLinus Torvalds return 0; 25841da177e4SLinus Torvalds } 25851da177e4SLinus Torvalds 25861da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 25871da177e4SLinus Torvalds { 25881da177e4SLinus Torvalds struct hci_dev *hdev; 25891da177e4SLinus Torvalds int err; 25901da177e4SLinus Torvalds 259170f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 259270f23020SAndrei Emeltchenko if (!hdev) 25931da177e4SLinus Torvalds return -ENODEV; 25948ee56540SMarcel Holtmann 25950736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 25960736cfa8SMarcel Holtmann err = -EBUSY; 25970736cfa8SMarcel Holtmann goto done; 25980736cfa8SMarcel Holtmann } 25990736cfa8SMarcel Holtmann 26008ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 26018ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 26028ee56540SMarcel Holtmann 26031da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 26048ee56540SMarcel Holtmann 26050736cfa8SMarcel Holtmann done: 26061da177e4SLinus Torvalds hci_dev_put(hdev); 26071da177e4SLinus Torvalds return err; 26081da177e4SLinus Torvalds } 26091da177e4SLinus Torvalds 26101da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 26111da177e4SLinus Torvalds { 26121da177e4SLinus Torvalds struct hci_dev *hdev; 26131da177e4SLinus Torvalds int ret = 0; 26141da177e4SLinus Torvalds 261570f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 261670f23020SAndrei Emeltchenko if (!hdev) 26171da177e4SLinus Torvalds return -ENODEV; 26181da177e4SLinus Torvalds 26191da177e4SLinus Torvalds hci_req_lock(hdev); 26201da177e4SLinus Torvalds 2621808a049eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 2622808a049eSMarcel Holtmann ret = -ENETDOWN; 26231da177e4SLinus Torvalds goto done; 2624808a049eSMarcel Holtmann } 26251da177e4SLinus Torvalds 26260736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 26270736cfa8SMarcel Holtmann ret = -EBUSY; 26280736cfa8SMarcel Holtmann goto done; 26290736cfa8SMarcel Holtmann } 26300736cfa8SMarcel Holtmann 26314a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2632fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2633fee746b0SMarcel Holtmann goto done; 2634fee746b0SMarcel Holtmann } 2635fee746b0SMarcel Holtmann 26361da177e4SLinus Torvalds /* Drop queues */ 26371da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 26381da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 26391da177e4SLinus Torvalds 264009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 26411f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 26421da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 264309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 26441da177e4SLinus Torvalds 26451da177e4SLinus Torvalds if (hdev->flush) 26461da177e4SLinus Torvalds hdev->flush(hdev); 26471da177e4SLinus Torvalds 26481da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 26496ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 26501da177e4SLinus Torvalds 265101178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 26521da177e4SLinus Torvalds 26531da177e4SLinus Torvalds done: 26541da177e4SLinus Torvalds hci_req_unlock(hdev); 26551da177e4SLinus Torvalds hci_dev_put(hdev); 26561da177e4SLinus Torvalds return ret; 26571da177e4SLinus Torvalds } 26581da177e4SLinus Torvalds 26591da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 26601da177e4SLinus Torvalds { 26611da177e4SLinus Torvalds struct hci_dev *hdev; 26621da177e4SLinus Torvalds int ret = 0; 26631da177e4SLinus Torvalds 266470f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 266570f23020SAndrei Emeltchenko if (!hdev) 26661da177e4SLinus Torvalds return -ENODEV; 26671da177e4SLinus Torvalds 26680736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 26690736cfa8SMarcel Holtmann ret = -EBUSY; 26700736cfa8SMarcel Holtmann goto done; 26710736cfa8SMarcel Holtmann } 26720736cfa8SMarcel Holtmann 26734a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2674fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 2675fee746b0SMarcel Holtmann goto done; 2676fee746b0SMarcel Holtmann } 2677fee746b0SMarcel Holtmann 26781da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 26791da177e4SLinus Torvalds 26800736cfa8SMarcel Holtmann done: 26811da177e4SLinus Torvalds hci_dev_put(hdev); 26821da177e4SLinus Torvalds return ret; 26831da177e4SLinus Torvalds } 26841da177e4SLinus Torvalds 2685123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 2686123abc08SJohan Hedberg { 2687bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 2688123abc08SJohan Hedberg 2689123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 2690123abc08SJohan Hedberg 2691123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 2692123abc08SJohan Hedberg conn_changed = !test_and_set_bit(HCI_CONNECTABLE, 2693123abc08SJohan Hedberg &hdev->dev_flags); 2694123abc08SJohan Hedberg else 2695123abc08SJohan Hedberg conn_changed = test_and_clear_bit(HCI_CONNECTABLE, 2696123abc08SJohan Hedberg &hdev->dev_flags); 2697123abc08SJohan Hedberg 2698bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 2699bc6d2d04SJohan Hedberg discov_changed = !test_and_set_bit(HCI_DISCOVERABLE, 2700bc6d2d04SJohan Hedberg &hdev->dev_flags); 2701bc6d2d04SJohan Hedberg } else { 2702bc6d2d04SJohan Hedberg clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 2703bc6d2d04SJohan Hedberg discov_changed = test_and_clear_bit(HCI_DISCOVERABLE, 2704bc6d2d04SJohan Hedberg &hdev->dev_flags); 2705bc6d2d04SJohan Hedberg } 2706bc6d2d04SJohan Hedberg 2707123abc08SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 2708123abc08SJohan Hedberg return; 2709123abc08SJohan Hedberg 2710bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 2711bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 2712bc6d2d04SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 2713bc6d2d04SJohan Hedberg 2714bc6d2d04SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 2715bc6d2d04SJohan Hedberg mgmt_update_adv_data(hdev); 2716bc6d2d04SJohan Hedberg 2717123abc08SJohan Hedberg mgmt_new_settings(hdev); 2718123abc08SJohan Hedberg } 2719bc6d2d04SJohan Hedberg } 2720123abc08SJohan Hedberg 27211da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 27221da177e4SLinus Torvalds { 27231da177e4SLinus Torvalds struct hci_dev *hdev; 27241da177e4SLinus Torvalds struct hci_dev_req dr; 27251da177e4SLinus Torvalds int err = 0; 27261da177e4SLinus Torvalds 27271da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 27281da177e4SLinus Torvalds return -EFAULT; 27291da177e4SLinus Torvalds 273070f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 273170f23020SAndrei Emeltchenko if (!hdev) 27321da177e4SLinus Torvalds return -ENODEV; 27331da177e4SLinus Torvalds 27340736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 27350736cfa8SMarcel Holtmann err = -EBUSY; 27360736cfa8SMarcel Holtmann goto done; 27370736cfa8SMarcel Holtmann } 27380736cfa8SMarcel Holtmann 27394a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 2740fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 2741fee746b0SMarcel Holtmann goto done; 2742fee746b0SMarcel Holtmann } 2743fee746b0SMarcel Holtmann 27445b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 27455b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 27465b69bef5SMarcel Holtmann goto done; 27475b69bef5SMarcel Holtmann } 27485b69bef5SMarcel Holtmann 274956f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 275056f87901SJohan Hedberg err = -EOPNOTSUPP; 275156f87901SJohan Hedberg goto done; 275256f87901SJohan Hedberg } 275356f87901SJohan Hedberg 27541da177e4SLinus Torvalds switch (cmd) { 27551da177e4SLinus Torvalds case HCISETAUTH: 275601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 27575f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27581da177e4SLinus Torvalds break; 27591da177e4SLinus Torvalds 27601da177e4SLinus Torvalds case HCISETENCRYPT: 27611da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 27621da177e4SLinus Torvalds err = -EOPNOTSUPP; 27631da177e4SLinus Torvalds break; 27641da177e4SLinus Torvalds } 27651da177e4SLinus Torvalds 27661da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 27671da177e4SLinus Torvalds /* Auth must be enabled first */ 276801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 27695f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27701da177e4SLinus Torvalds if (err) 27711da177e4SLinus Torvalds break; 27721da177e4SLinus Torvalds } 27731da177e4SLinus Torvalds 277401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 27755f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27761da177e4SLinus Torvalds break; 27771da177e4SLinus Torvalds 27781da177e4SLinus Torvalds case HCISETSCAN: 277901178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 27805f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 278191a668b0SJohan Hedberg 2782bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 2783bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 278491a668b0SJohan Hedberg */ 2785123abc08SJohan Hedberg if (!err) 2786123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 27871da177e4SLinus Torvalds break; 27881da177e4SLinus Torvalds 27891da177e4SLinus Torvalds case HCISETLINKPOL: 279001178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 27915f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 27921da177e4SLinus Torvalds break; 27931da177e4SLinus Torvalds 27941da177e4SLinus Torvalds case HCISETLINKMODE: 2795e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 2796e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 2797e4e8e37cSMarcel Holtmann break; 2798e4e8e37cSMarcel Holtmann 2799e4e8e37cSMarcel Holtmann case HCISETPTYPE: 2800e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 28011da177e4SLinus Torvalds break; 28021da177e4SLinus Torvalds 28031da177e4SLinus Torvalds case HCISETACLMTU: 28041da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 28051da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 28061da177e4SLinus Torvalds break; 28071da177e4SLinus Torvalds 28081da177e4SLinus Torvalds case HCISETSCOMTU: 28091da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 28101da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 28111da177e4SLinus Torvalds break; 28121da177e4SLinus Torvalds 28131da177e4SLinus Torvalds default: 28141da177e4SLinus Torvalds err = -EINVAL; 28151da177e4SLinus Torvalds break; 28161da177e4SLinus Torvalds } 2817e4e8e37cSMarcel Holtmann 28180736cfa8SMarcel Holtmann done: 28191da177e4SLinus Torvalds hci_dev_put(hdev); 28201da177e4SLinus Torvalds return err; 28211da177e4SLinus Torvalds } 28221da177e4SLinus Torvalds 28231da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 28241da177e4SLinus Torvalds { 28258035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 28261da177e4SLinus Torvalds struct hci_dev_list_req *dl; 28271da177e4SLinus Torvalds struct hci_dev_req *dr; 28281da177e4SLinus Torvalds int n = 0, size, err; 28291da177e4SLinus Torvalds __u16 dev_num; 28301da177e4SLinus Torvalds 28311da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 28321da177e4SLinus Torvalds return -EFAULT; 28331da177e4SLinus Torvalds 28341da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 28351da177e4SLinus Torvalds return -EINVAL; 28361da177e4SLinus Torvalds 28371da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 28381da177e4SLinus Torvalds 283970f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 284070f23020SAndrei Emeltchenko if (!dl) 28411da177e4SLinus Torvalds return -ENOMEM; 28421da177e4SLinus Torvalds 28431da177e4SLinus Torvalds dr = dl->dev_req; 28441da177e4SLinus Torvalds 2845f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 28468035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 28472e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 28482e84d8dbSMarcel Holtmann 28492e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 28502e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 28512e84d8dbSMarcel Holtmann * device is actually down. 28522e84d8dbSMarcel Holtmann */ 28532e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 28542e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 2855c542a06cSJohan Hedberg 28561da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 28572e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 2858c542a06cSJohan Hedberg 28591da177e4SLinus Torvalds if (++n >= dev_num) 28601da177e4SLinus Torvalds break; 28611da177e4SLinus Torvalds } 2862f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 28631da177e4SLinus Torvalds 28641da177e4SLinus Torvalds dl->dev_num = n; 28651da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 28661da177e4SLinus Torvalds 28671da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 28681da177e4SLinus Torvalds kfree(dl); 28691da177e4SLinus Torvalds 28701da177e4SLinus Torvalds return err ? -EFAULT : 0; 28711da177e4SLinus Torvalds } 28721da177e4SLinus Torvalds 28731da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 28741da177e4SLinus Torvalds { 28751da177e4SLinus Torvalds struct hci_dev *hdev; 28761da177e4SLinus Torvalds struct hci_dev_info di; 28772e84d8dbSMarcel Holtmann unsigned long flags; 28781da177e4SLinus Torvalds int err = 0; 28791da177e4SLinus Torvalds 28801da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 28811da177e4SLinus Torvalds return -EFAULT; 28821da177e4SLinus Torvalds 288370f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 288470f23020SAndrei Emeltchenko if (!hdev) 28851da177e4SLinus Torvalds return -ENODEV; 28861da177e4SLinus Torvalds 28872e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 28882e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 28892e84d8dbSMarcel Holtmann * device is actually down. 28902e84d8dbSMarcel Holtmann */ 28912e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 28922e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 28932e84d8dbSMarcel Holtmann else 28942e84d8dbSMarcel Holtmann flags = hdev->flags; 2895ab81cbf9SJohan Hedberg 28961da177e4SLinus Torvalds strcpy(di.name, hdev->name); 28971da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 289860f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 28992e84d8dbSMarcel Holtmann di.flags = flags; 29001da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2901572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 29021da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 29031da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 29041da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 29051da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2906572c7f84SJohan Hedberg } else { 2907572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2908572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2909572c7f84SJohan Hedberg di.sco_mtu = 0; 2910572c7f84SJohan Hedberg di.sco_pkts = 0; 2911572c7f84SJohan Hedberg } 29121da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 29131da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 29141da177e4SLinus Torvalds 29151da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 29161da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 29171da177e4SLinus Torvalds 29181da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 29191da177e4SLinus Torvalds err = -EFAULT; 29201da177e4SLinus Torvalds 29211da177e4SLinus Torvalds hci_dev_put(hdev); 29221da177e4SLinus Torvalds 29231da177e4SLinus Torvalds return err; 29241da177e4SLinus Torvalds } 29251da177e4SLinus Torvalds 29261da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 29271da177e4SLinus Torvalds 2928611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2929611b30f7SMarcel Holtmann { 2930611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2931611b30f7SMarcel Holtmann 2932611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2933611b30f7SMarcel Holtmann 29340736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 29350736cfa8SMarcel Holtmann return -EBUSY; 29360736cfa8SMarcel Holtmann 29375e130367SJohan Hedberg if (blocked) { 29385e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 2939d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2940d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) 2941611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 29425e130367SJohan Hedberg } else { 29435e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 29445e130367SJohan Hedberg } 2945611b30f7SMarcel Holtmann 2946611b30f7SMarcel Holtmann return 0; 2947611b30f7SMarcel Holtmann } 2948611b30f7SMarcel Holtmann 2949611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2950611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2951611b30f7SMarcel Holtmann }; 2952611b30f7SMarcel Holtmann 2953ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2954ab81cbf9SJohan Hedberg { 2955ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 295696570ffcSJohan Hedberg int err; 2957ab81cbf9SJohan Hedberg 2958ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2959ab81cbf9SJohan Hedberg 2960cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 296196570ffcSJohan Hedberg if (err < 0) { 296296570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 2963ab81cbf9SJohan Hedberg return; 296496570ffcSJohan Hedberg } 2965ab81cbf9SJohan Hedberg 2966a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2967a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2968a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2969a5c8f270SMarcel Holtmann */ 2970a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 29714a964404SMarcel Holtmann test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) || 2972a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 2973a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2974a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2975bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2976bf543036SJohan Hedberg hci_dev_do_close(hdev); 2977bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 297819202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 297919202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2980bf543036SJohan Hedberg } 2981ab81cbf9SJohan Hedberg 2982fee746b0SMarcel Holtmann if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) { 29834a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 29844a964404SMarcel Holtmann * so that userspace can easily identify them. 29854a964404SMarcel Holtmann */ 29864a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 29874a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 29880602a8adSMarcel Holtmann 29890602a8adSMarcel Holtmann /* For fully configured devices, this will send 29900602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 29910602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 29920602a8adSMarcel Holtmann * 29930602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 29940602a8adSMarcel Holtmann * and no event will be send. 29950602a8adSMarcel Holtmann */ 2996744cf19eSJohan Hedberg mgmt_index_added(hdev); 2997d603b76bSMarcel Holtmann } else if (test_and_clear_bit(HCI_CONFIG, &hdev->dev_flags)) { 29985ea234d3SMarcel Holtmann /* When the controller is now configured, then it 29995ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 30005ea234d3SMarcel Holtmann */ 30015ea234d3SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 30025ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 30035ea234d3SMarcel Holtmann 3004d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 3005d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 3006d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 3007d603b76bSMarcel Holtmann */ 3008d603b76bSMarcel Holtmann mgmt_index_added(hdev); 3009ab81cbf9SJohan Hedberg } 3010fee746b0SMarcel Holtmann } 3011ab81cbf9SJohan Hedberg 3012ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 3013ab81cbf9SJohan Hedberg { 30143243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 30153243553fSJohan Hedberg power_off.work); 3016ab81cbf9SJohan Hedberg 3017ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 3018ab81cbf9SJohan Hedberg 30198ee56540SMarcel Holtmann hci_dev_do_close(hdev); 3020ab81cbf9SJohan Hedberg } 3021ab81cbf9SJohan Hedberg 302216ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 302316ab91abSJohan Hedberg { 302416ab91abSJohan Hedberg struct hci_dev *hdev; 302516ab91abSJohan Hedberg 302616ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 302716ab91abSJohan Hedberg 302816ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 302916ab91abSJohan Hedberg 3030d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 303116ab91abSJohan Hedberg } 303216ab91abSJohan Hedberg 303335f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 30342aeb9a1aSJohan Hedberg { 30354821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 30362aeb9a1aSJohan Hedberg 30374821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 30384821002cSJohan Hedberg list_del(&uuid->list); 30392aeb9a1aSJohan Hedberg kfree(uuid); 30402aeb9a1aSJohan Hedberg } 30412aeb9a1aSJohan Hedberg } 30422aeb9a1aSJohan Hedberg 304335f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 304455ed8ca1SJohan Hedberg { 304555ed8ca1SJohan Hedberg struct list_head *p, *n; 304655ed8ca1SJohan Hedberg 304755ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 304855ed8ca1SJohan Hedberg struct link_key *key; 304955ed8ca1SJohan Hedberg 305055ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 305155ed8ca1SJohan Hedberg 305255ed8ca1SJohan Hedberg list_del(p); 305355ed8ca1SJohan Hedberg kfree(key); 305455ed8ca1SJohan Hedberg } 305555ed8ca1SJohan Hedberg } 305655ed8ca1SJohan Hedberg 305735f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 3058b899efafSVinicius Costa Gomes { 3059b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 3060b899efafSVinicius Costa Gomes 3061b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 3062b899efafSVinicius Costa Gomes list_del(&k->list); 3063b899efafSVinicius Costa Gomes kfree(k); 3064b899efafSVinicius Costa Gomes } 3065b899efafSVinicius Costa Gomes } 3066b899efafSVinicius Costa Gomes 3067970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 3068970c4e46SJohan Hedberg { 3069970c4e46SJohan Hedberg struct smp_irk *k, *tmp; 3070970c4e46SJohan Hedberg 3071970c4e46SJohan Hedberg list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) { 3072970c4e46SJohan Hedberg list_del(&k->list); 3073970c4e46SJohan Hedberg kfree(k); 3074970c4e46SJohan Hedberg } 3075970c4e46SJohan Hedberg } 3076970c4e46SJohan Hedberg 307755ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 307855ed8ca1SJohan Hedberg { 307955ed8ca1SJohan Hedberg struct link_key *k; 308055ed8ca1SJohan Hedberg 30818035ded4SLuiz Augusto von Dentz list_for_each_entry(k, &hdev->link_keys, list) 308255ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 308355ed8ca1SJohan Hedberg return k; 308455ed8ca1SJohan Hedberg 308555ed8ca1SJohan Hedberg return NULL; 308655ed8ca1SJohan Hedberg } 308755ed8ca1SJohan Hedberg 3088745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 3089d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 3090d25e28abSJohan Hedberg { 3091d25e28abSJohan Hedberg /* Legacy key */ 3092d25e28abSJohan Hedberg if (key_type < 0x03) 3093745c0ce3SVishal Agarwal return true; 3094d25e28abSJohan Hedberg 3095d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 3096d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 3097745c0ce3SVishal Agarwal return false; 3098d25e28abSJohan Hedberg 3099d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 3100d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 3101745c0ce3SVishal Agarwal return false; 3102d25e28abSJohan Hedberg 3103d25e28abSJohan Hedberg /* Security mode 3 case */ 3104d25e28abSJohan Hedberg if (!conn) 3105745c0ce3SVishal Agarwal return true; 3106d25e28abSJohan Hedberg 3107d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 3108d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 3109745c0ce3SVishal Agarwal return true; 3110d25e28abSJohan Hedberg 3111d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 3112d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 3113745c0ce3SVishal Agarwal return true; 3114d25e28abSJohan Hedberg 3115d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 3116d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 3117745c0ce3SVishal Agarwal return true; 3118d25e28abSJohan Hedberg 3119d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 3120d25e28abSJohan Hedberg * persistently */ 3121745c0ce3SVishal Agarwal return false; 3122d25e28abSJohan Hedberg } 3123d25e28abSJohan Hedberg 3124e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 312598a0b845SJohan Hedberg { 3126e804d25dSJohan Hedberg if (type == SMP_LTK) 3127e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 3128e804d25dSJohan Hedberg 3129e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 313098a0b845SJohan Hedberg } 313198a0b845SJohan Hedberg 3132fe39c7b2SMarcel Holtmann struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, __le64 rand, 3133e804d25dSJohan Hedberg u8 role) 313475d262c2SVinicius Costa Gomes { 3135c9839a11SVinicius Costa Gomes struct smp_ltk *k; 313675d262c2SVinicius Costa Gomes 3137c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) { 3138fe39c7b2SMarcel Holtmann if (k->ediv != ediv || k->rand != rand) 313975d262c2SVinicius Costa Gomes continue; 314075d262c2SVinicius Costa Gomes 3141e804d25dSJohan Hedberg if (ltk_role(k->type) != role) 314298a0b845SJohan Hedberg continue; 314398a0b845SJohan Hedberg 314475d262c2SVinicius Costa Gomes return k; 314575d262c2SVinicius Costa Gomes } 314675d262c2SVinicius Costa Gomes 314775d262c2SVinicius Costa Gomes return NULL; 314875d262c2SVinicius Costa Gomes } 314975d262c2SVinicius Costa Gomes 3150c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 3151e804d25dSJohan Hedberg u8 addr_type, u8 role) 315275d262c2SVinicius Costa Gomes { 3153c9839a11SVinicius Costa Gomes struct smp_ltk *k; 315475d262c2SVinicius Costa Gomes 3155c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) 3156c9839a11SVinicius Costa Gomes if (addr_type == k->bdaddr_type && 315798a0b845SJohan Hedberg bacmp(bdaddr, &k->bdaddr) == 0 && 3158e804d25dSJohan Hedberg ltk_role(k->type) == role) 315975d262c2SVinicius Costa Gomes return k; 316075d262c2SVinicius Costa Gomes 316175d262c2SVinicius Costa Gomes return NULL; 316275d262c2SVinicius Costa Gomes } 316375d262c2SVinicius Costa Gomes 3164970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 3165970c4e46SJohan Hedberg { 3166970c4e46SJohan Hedberg struct smp_irk *irk; 3167970c4e46SJohan Hedberg 3168970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3169970c4e46SJohan Hedberg if (!bacmp(&irk->rpa, rpa)) 3170970c4e46SJohan Hedberg return irk; 3171970c4e46SJohan Hedberg } 3172970c4e46SJohan Hedberg 3173970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3174970c4e46SJohan Hedberg if (smp_irk_matches(hdev->tfm_aes, irk->val, rpa)) { 3175970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 3176970c4e46SJohan Hedberg return irk; 3177970c4e46SJohan Hedberg } 3178970c4e46SJohan Hedberg } 3179970c4e46SJohan Hedberg 3180970c4e46SJohan Hedberg return NULL; 3181970c4e46SJohan Hedberg } 3182970c4e46SJohan Hedberg 3183970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 3184970c4e46SJohan Hedberg u8 addr_type) 3185970c4e46SJohan Hedberg { 3186970c4e46SJohan Hedberg struct smp_irk *irk; 3187970c4e46SJohan Hedberg 31886cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 31896cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 31906cfc9988SJohan Hedberg return NULL; 31916cfc9988SJohan Hedberg 3192970c4e46SJohan Hedberg list_for_each_entry(irk, &hdev->identity_resolving_keys, list) { 3193970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 3194970c4e46SJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) 3195970c4e46SJohan Hedberg return irk; 3196970c4e46SJohan Hedberg } 3197970c4e46SJohan Hedberg 3198970c4e46SJohan Hedberg return NULL; 3199970c4e46SJohan Hedberg } 3200970c4e46SJohan Hedberg 3201567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 32027652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 32037652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 320455ed8ca1SJohan Hedberg { 320555ed8ca1SJohan Hedberg struct link_key *key, *old_key; 3206745c0ce3SVishal Agarwal u8 old_key_type; 320755ed8ca1SJohan Hedberg 320855ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 320955ed8ca1SJohan Hedberg if (old_key) { 321055ed8ca1SJohan Hedberg old_key_type = old_key->type; 321155ed8ca1SJohan Hedberg key = old_key; 321255ed8ca1SJohan Hedberg } else { 321312adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 32140a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 321555ed8ca1SJohan Hedberg if (!key) 3216567fa2aaSJohan Hedberg return NULL; 321755ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 321855ed8ca1SJohan Hedberg } 321955ed8ca1SJohan Hedberg 32206ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 322155ed8ca1SJohan Hedberg 3222d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 3223d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 3224d25e28abSJohan Hedberg * previous key */ 3225d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 3226a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 3227d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 3228655fe6ecSJohan Hedberg if (conn) 3229655fe6ecSJohan Hedberg conn->key_type = type; 3230655fe6ecSJohan Hedberg } 3231d25e28abSJohan Hedberg 323255ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 32339b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 323455ed8ca1SJohan Hedberg key->pin_len = pin_len; 323555ed8ca1SJohan Hedberg 3236b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 323755ed8ca1SJohan Hedberg key->type = old_key_type; 32384748fed2SJohan Hedberg else 32394748fed2SJohan Hedberg key->type = type; 32404748fed2SJohan Hedberg 32417652ff6aSJohan Hedberg if (persistent) 32427652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 32437652ff6aSJohan Hedberg old_key_type); 324455ed8ca1SJohan Hedberg 3245567fa2aaSJohan Hedberg return key; 324655ed8ca1SJohan Hedberg } 324755ed8ca1SJohan Hedberg 3248ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 324935d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 3250fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 325175d262c2SVinicius Costa Gomes { 3252c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 3253e804d25dSJohan Hedberg u8 role = ltk_role(type); 325475d262c2SVinicius Costa Gomes 3255e804d25dSJohan Hedberg old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type, role); 3256c9839a11SVinicius Costa Gomes if (old_key) 325775d262c2SVinicius Costa Gomes key = old_key; 3258c9839a11SVinicius Costa Gomes else { 32590a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 326075d262c2SVinicius Costa Gomes if (!key) 3261ca9142b8SJohan Hedberg return NULL; 3262c9839a11SVinicius Costa Gomes list_add(&key->list, &hdev->long_term_keys); 326375d262c2SVinicius Costa Gomes } 326475d262c2SVinicius Costa Gomes 326575d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 3266c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 3267c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 3268c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 3269c9839a11SVinicius Costa Gomes key->ediv = ediv; 3270fe39c7b2SMarcel Holtmann key->rand = rand; 3271c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 3272c9839a11SVinicius Costa Gomes key->type = type; 327375d262c2SVinicius Costa Gomes 3274ca9142b8SJohan Hedberg return key; 327575d262c2SVinicius Costa Gomes } 327675d262c2SVinicius Costa Gomes 3277ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 3278ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 3279970c4e46SJohan Hedberg { 3280970c4e46SJohan Hedberg struct smp_irk *irk; 3281970c4e46SJohan Hedberg 3282970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 3283970c4e46SJohan Hedberg if (!irk) { 3284970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 3285970c4e46SJohan Hedberg if (!irk) 3286ca9142b8SJohan Hedberg return NULL; 3287970c4e46SJohan Hedberg 3288970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 3289970c4e46SJohan Hedberg irk->addr_type = addr_type; 3290970c4e46SJohan Hedberg 3291970c4e46SJohan Hedberg list_add(&irk->list, &hdev->identity_resolving_keys); 3292970c4e46SJohan Hedberg } 3293970c4e46SJohan Hedberg 3294970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 3295970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 3296970c4e46SJohan Hedberg 3297ca9142b8SJohan Hedberg return irk; 3298970c4e46SJohan Hedberg } 3299970c4e46SJohan Hedberg 330055ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 330155ed8ca1SJohan Hedberg { 330255ed8ca1SJohan Hedberg struct link_key *key; 330355ed8ca1SJohan Hedberg 330455ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 330555ed8ca1SJohan Hedberg if (!key) 330655ed8ca1SJohan Hedberg return -ENOENT; 330755ed8ca1SJohan Hedberg 33086ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 330955ed8ca1SJohan Hedberg 331055ed8ca1SJohan Hedberg list_del(&key->list); 331155ed8ca1SJohan Hedberg kfree(key); 331255ed8ca1SJohan Hedberg 331355ed8ca1SJohan Hedberg return 0; 331455ed8ca1SJohan Hedberg } 331555ed8ca1SJohan Hedberg 3316e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 3317b899efafSVinicius Costa Gomes { 3318b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 3319c51ffa0bSJohan Hedberg int removed = 0; 3320b899efafSVinicius Costa Gomes 3321b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 3322e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 3323b899efafSVinicius Costa Gomes continue; 3324b899efafSVinicius Costa Gomes 33256ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3326b899efafSVinicius Costa Gomes 3327b899efafSVinicius Costa Gomes list_del(&k->list); 3328b899efafSVinicius Costa Gomes kfree(k); 3329c51ffa0bSJohan Hedberg removed++; 3330b899efafSVinicius Costa Gomes } 3331b899efafSVinicius Costa Gomes 3332c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 3333b899efafSVinicius Costa Gomes } 3334b899efafSVinicius Costa Gomes 3335a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 3336a7ec7338SJohan Hedberg { 3337a7ec7338SJohan Hedberg struct smp_irk *k, *tmp; 3338a7ec7338SJohan Hedberg 3339668b7b19SJohan Hedberg list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) { 3340a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 3341a7ec7338SJohan Hedberg continue; 3342a7ec7338SJohan Hedberg 3343a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 3344a7ec7338SJohan Hedberg 3345a7ec7338SJohan Hedberg list_del(&k->list); 3346a7ec7338SJohan Hedberg kfree(k); 3347a7ec7338SJohan Hedberg } 3348a7ec7338SJohan Hedberg } 3349a7ec7338SJohan Hedberg 33506bd32326SVille Tervo /* HCI command timer function */ 335165cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 33526bd32326SVille Tervo { 335365cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 335465cc2b49SMarcel Holtmann cmd_timer.work); 33556bd32326SVille Tervo 3356bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 3357bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 3358bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 3359bda4f23aSAndrei Emeltchenko 3360bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 3361bda4f23aSAndrei Emeltchenko } else { 33626bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 3363bda4f23aSAndrei Emeltchenko } 3364bda4f23aSAndrei Emeltchenko 33656bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 3366c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 33676bd32326SVille Tervo } 33686bd32326SVille Tervo 33692763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 33702763eda6SSzymon Janc bdaddr_t *bdaddr) 33712763eda6SSzymon Janc { 33722763eda6SSzymon Janc struct oob_data *data; 33732763eda6SSzymon Janc 33742763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 33752763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 33762763eda6SSzymon Janc return data; 33772763eda6SSzymon Janc 33782763eda6SSzymon Janc return NULL; 33792763eda6SSzymon Janc } 33802763eda6SSzymon Janc 33812763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 33822763eda6SSzymon Janc { 33832763eda6SSzymon Janc struct oob_data *data; 33842763eda6SSzymon Janc 33852763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 33862763eda6SSzymon Janc if (!data) 33872763eda6SSzymon Janc return -ENOENT; 33882763eda6SSzymon Janc 33896ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 33902763eda6SSzymon Janc 33912763eda6SSzymon Janc list_del(&data->list); 33922763eda6SSzymon Janc kfree(data); 33932763eda6SSzymon Janc 33942763eda6SSzymon Janc return 0; 33952763eda6SSzymon Janc } 33962763eda6SSzymon Janc 339735f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 33982763eda6SSzymon Janc { 33992763eda6SSzymon Janc struct oob_data *data, *n; 34002763eda6SSzymon Janc 34012763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 34022763eda6SSzymon Janc list_del(&data->list); 34032763eda6SSzymon Janc kfree(data); 34042763eda6SSzymon Janc } 34052763eda6SSzymon Janc } 34062763eda6SSzymon Janc 34070798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 34080798872eSMarcel Holtmann u8 *hash, u8 *randomizer) 34092763eda6SSzymon Janc { 34102763eda6SSzymon Janc struct oob_data *data; 34112763eda6SSzymon Janc 34122763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 34132763eda6SSzymon Janc if (!data) { 34140a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 34152763eda6SSzymon Janc if (!data) 34162763eda6SSzymon Janc return -ENOMEM; 34172763eda6SSzymon Janc 34182763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 34192763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 34202763eda6SSzymon Janc } 34212763eda6SSzymon Janc 3422519ca9d0SMarcel Holtmann memcpy(data->hash192, hash, sizeof(data->hash192)); 3423519ca9d0SMarcel Holtmann memcpy(data->randomizer192, randomizer, sizeof(data->randomizer192)); 34242763eda6SSzymon Janc 34250798872eSMarcel Holtmann memset(data->hash256, 0, sizeof(data->hash256)); 34260798872eSMarcel Holtmann memset(data->randomizer256, 0, sizeof(data->randomizer256)); 34270798872eSMarcel Holtmann 34280798872eSMarcel Holtmann BT_DBG("%s for %pMR", hdev->name, bdaddr); 34290798872eSMarcel Holtmann 34300798872eSMarcel Holtmann return 0; 34310798872eSMarcel Holtmann } 34320798872eSMarcel Holtmann 34330798872eSMarcel Holtmann int hci_add_remote_oob_ext_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 34340798872eSMarcel Holtmann u8 *hash192, u8 *randomizer192, 34350798872eSMarcel Holtmann u8 *hash256, u8 *randomizer256) 34360798872eSMarcel Holtmann { 34370798872eSMarcel Holtmann struct oob_data *data; 34380798872eSMarcel Holtmann 34390798872eSMarcel Holtmann data = hci_find_remote_oob_data(hdev, bdaddr); 34400798872eSMarcel Holtmann if (!data) { 34410a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 34420798872eSMarcel Holtmann if (!data) 34430798872eSMarcel Holtmann return -ENOMEM; 34440798872eSMarcel Holtmann 34450798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 34460798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 34470798872eSMarcel Holtmann } 34480798872eSMarcel Holtmann 34490798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 34500798872eSMarcel Holtmann memcpy(data->randomizer192, randomizer192, sizeof(data->randomizer192)); 34510798872eSMarcel Holtmann 34520798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 34530798872eSMarcel Holtmann memcpy(data->randomizer256, randomizer256, sizeof(data->randomizer256)); 34540798872eSMarcel Holtmann 34556ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 34562763eda6SSzymon Janc 34572763eda6SSzymon Janc return 0; 34582763eda6SSzymon Janc } 34592763eda6SSzymon Janc 3460dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 3461b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 3462b2a66aadSAntti Julku { 3463b2a66aadSAntti Julku struct bdaddr_list *b; 3464b2a66aadSAntti Julku 3465dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 3466b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 3467b2a66aadSAntti Julku return b; 3468b9ee0a78SMarcel Holtmann } 3469b2a66aadSAntti Julku 3470b2a66aadSAntti Julku return NULL; 3471b2a66aadSAntti Julku } 3472b2a66aadSAntti Julku 3473dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 3474b2a66aadSAntti Julku { 3475b2a66aadSAntti Julku struct list_head *p, *n; 3476b2a66aadSAntti Julku 3477dcc36c16SJohan Hedberg list_for_each_safe(p, n, bdaddr_list) { 3478b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 3479b2a66aadSAntti Julku 3480b2a66aadSAntti Julku list_del(p); 3481b2a66aadSAntti Julku kfree(b); 3482b2a66aadSAntti Julku } 3483b2a66aadSAntti Julku } 3484b2a66aadSAntti Julku 3485dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3486b2a66aadSAntti Julku { 3487b2a66aadSAntti Julku struct bdaddr_list *entry; 3488b2a66aadSAntti Julku 3489b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 3490b2a66aadSAntti Julku return -EBADF; 3491b2a66aadSAntti Julku 3492dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 34935e762444SAntti Julku return -EEXIST; 3494b2a66aadSAntti Julku 3495b2a66aadSAntti Julku entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL); 34965e762444SAntti Julku if (!entry) 34975e762444SAntti Julku return -ENOMEM; 3498b2a66aadSAntti Julku 3499b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 3500b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 3501b2a66aadSAntti Julku 3502dcc36c16SJohan Hedberg list_add(&entry->list, list); 3503b2a66aadSAntti Julku 35042a8357f2SJohan Hedberg return 0; 3505b2a66aadSAntti Julku } 3506b2a66aadSAntti Julku 3507dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 3508b2a66aadSAntti Julku { 3509b2a66aadSAntti Julku struct bdaddr_list *entry; 3510b2a66aadSAntti Julku 351135f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 3512dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 351335f7498aSJohan Hedberg return 0; 351435f7498aSJohan Hedberg } 3515b2a66aadSAntti Julku 3516dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 3517d2ab0ac1SMarcel Holtmann if (!entry) 3518d2ab0ac1SMarcel Holtmann return -ENOENT; 3519d2ab0ac1SMarcel Holtmann 3520d2ab0ac1SMarcel Holtmann list_del(&entry->list); 3521d2ab0ac1SMarcel Holtmann kfree(entry); 3522d2ab0ac1SMarcel Holtmann 3523d2ab0ac1SMarcel Holtmann return 0; 3524d2ab0ac1SMarcel Holtmann } 3525d2ab0ac1SMarcel Holtmann 352615819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 352715819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 352815819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 352915819a70SAndre Guedes { 353015819a70SAndre Guedes struct hci_conn_params *params; 353115819a70SAndre Guedes 3532738f6185SJohan Hedberg /* The conn params list only contains identity addresses */ 3533738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 3534738f6185SJohan Hedberg return NULL; 3535738f6185SJohan Hedberg 353615819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 353715819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 353815819a70SAndre Guedes params->addr_type == addr_type) { 353915819a70SAndre Guedes return params; 354015819a70SAndre Guedes } 354115819a70SAndre Guedes } 354215819a70SAndre Guedes 354315819a70SAndre Guedes return NULL; 354415819a70SAndre Guedes } 354515819a70SAndre Guedes 3546cef952ceSAndre Guedes static bool is_connected(struct hci_dev *hdev, bdaddr_t *addr, u8 type) 3547cef952ceSAndre Guedes { 3548cef952ceSAndre Guedes struct hci_conn *conn; 3549cef952ceSAndre Guedes 3550cef952ceSAndre Guedes conn = hci_conn_hash_lookup_ba(hdev, LE_LINK, addr); 3551cef952ceSAndre Guedes if (!conn) 3552cef952ceSAndre Guedes return false; 3553cef952ceSAndre Guedes 3554cef952ceSAndre Guedes if (conn->dst_type != type) 3555cef952ceSAndre Guedes return false; 3556cef952ceSAndre Guedes 3557cef952ceSAndre Guedes if (conn->state != BT_CONNECTED) 3558cef952ceSAndre Guedes return false; 3559cef952ceSAndre Guedes 3560cef952ceSAndre Guedes return true; 3561cef952ceSAndre Guedes } 3562cef952ceSAndre Guedes 356315819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 3564501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 35654b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 35664b10966fSMarcel Holtmann { 3567912b42efSJohan Hedberg struct hci_conn_params *param; 35684b10966fSMarcel Holtmann 3569738f6185SJohan Hedberg /* The list only contains identity addresses */ 3570738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 3571738f6185SJohan Hedberg return NULL; 3572738f6185SJohan Hedberg 3573501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 3574912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 3575912b42efSJohan Hedberg param->addr_type == addr_type) 3576912b42efSJohan Hedberg return param; 35774b10966fSMarcel Holtmann } 35784b10966fSMarcel Holtmann 35794b10966fSMarcel Holtmann return NULL; 35804b10966fSMarcel Holtmann } 35814b10966fSMarcel Holtmann 35824b10966fSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 358351d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 358451d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 3585bf5b3c8bSMarcel Holtmann { 3586bf5b3c8bSMarcel Holtmann struct hci_conn_params *params; 3587bf5b3c8bSMarcel Holtmann 3588c46245b3SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 358951d167c0SMarcel Holtmann return NULL; 3590bf5b3c8bSMarcel Holtmann 3591bf5b3c8bSMarcel Holtmann params = hci_conn_params_lookup(hdev, addr, addr_type); 3592bf5b3c8bSMarcel Holtmann if (params) 359351d167c0SMarcel Holtmann return params; 3594bf5b3c8bSMarcel Holtmann 3595bf5b3c8bSMarcel Holtmann params = kzalloc(sizeof(*params), GFP_KERNEL); 3596bf5b3c8bSMarcel Holtmann if (!params) { 3597bf5b3c8bSMarcel Holtmann BT_ERR("Out of memory"); 359851d167c0SMarcel Holtmann return NULL; 3599bf5b3c8bSMarcel Holtmann } 3600bf5b3c8bSMarcel Holtmann 3601bf5b3c8bSMarcel Holtmann bacpy(¶ms->addr, addr); 3602bf5b3c8bSMarcel Holtmann params->addr_type = addr_type; 3603bf5b3c8bSMarcel Holtmann 3604bf5b3c8bSMarcel Holtmann list_add(¶ms->list, &hdev->le_conn_params); 360593450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 3606bf5b3c8bSMarcel Holtmann 3607bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 3608bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 3609bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 3610bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 3611bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 3612bf5b3c8bSMarcel Holtmann 3613bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 3614bf5b3c8bSMarcel Holtmann 361551d167c0SMarcel Holtmann return params; 3616bf5b3c8bSMarcel Holtmann } 3617bf5b3c8bSMarcel Holtmann 3618bf5b3c8bSMarcel Holtmann /* This function requires the caller holds hdev->lock */ 3619bf5b3c8bSMarcel Holtmann int hci_conn_params_set(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type, 3620d06b50ceSMarcel Holtmann u8 auto_connect) 362115819a70SAndre Guedes { 362215819a70SAndre Guedes struct hci_conn_params *params; 362315819a70SAndre Guedes 36248c87aae1SMarcel Holtmann params = hci_conn_params_add(hdev, addr, addr_type); 36258c87aae1SMarcel Holtmann if (!params) 36268c87aae1SMarcel Holtmann return -EIO; 3627a9b0a04cSAndre Guedes 362842ce26deSJohan Hedberg if (params->auto_connect == auto_connect) 362942ce26deSJohan Hedberg return 0; 363042ce26deSJohan Hedberg 363166f8455aSJohan Hedberg list_del_init(¶ms->action); 363215819a70SAndre Guedes 3633cef952ceSAndre Guedes switch (auto_connect) { 3634cef952ceSAndre Guedes case HCI_AUTO_CONN_DISABLED: 3635cef952ceSAndre Guedes case HCI_AUTO_CONN_LINK_LOSS: 363695305baaSJohan Hedberg hci_update_background_scan(hdev); 3637cef952ceSAndre Guedes break; 3638851efca8SJohan Hedberg case HCI_AUTO_CONN_REPORT: 363995305baaSJohan Hedberg list_add(¶ms->action, &hdev->pend_le_reports); 364095305baaSJohan Hedberg hci_update_background_scan(hdev); 3641851efca8SJohan Hedberg break; 3642cef952ceSAndre Guedes case HCI_AUTO_CONN_ALWAYS: 364395305baaSJohan Hedberg if (!is_connected(hdev, addr, addr_type)) { 364495305baaSJohan Hedberg list_add(¶ms->action, &hdev->pend_le_conns); 364595305baaSJohan Hedberg hci_update_background_scan(hdev); 364695305baaSJohan Hedberg } 3647cef952ceSAndre Guedes break; 3648cef952ceSAndre Guedes } 364915819a70SAndre Guedes 3650851efca8SJohan Hedberg params->auto_connect = auto_connect; 3651851efca8SJohan Hedberg 3652d06b50ceSMarcel Holtmann BT_DBG("addr %pMR (type %u) auto_connect %u", addr, addr_type, 3653d06b50ceSMarcel Holtmann auto_connect); 3654a9b0a04cSAndre Guedes 3655a9b0a04cSAndre Guedes return 0; 365615819a70SAndre Guedes } 365715819a70SAndre Guedes 365815819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 365915819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 366015819a70SAndre Guedes { 366115819a70SAndre Guedes struct hci_conn_params *params; 366215819a70SAndre Guedes 366315819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 366415819a70SAndre Guedes if (!params) 366515819a70SAndre Guedes return; 366615819a70SAndre Guedes 366795305baaSJohan Hedberg list_del(¶ms->action); 366815819a70SAndre Guedes list_del(¶ms->list); 366915819a70SAndre Guedes kfree(params); 367015819a70SAndre Guedes 367195305baaSJohan Hedberg hci_update_background_scan(hdev); 367295305baaSJohan Hedberg 367315819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 367415819a70SAndre Guedes } 367515819a70SAndre Guedes 367615819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 367755af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 367855af49a8SJohan Hedberg { 367955af49a8SJohan Hedberg struct hci_conn_params *params, *tmp; 368055af49a8SJohan Hedberg 368155af49a8SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 368255af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 368355af49a8SJohan Hedberg continue; 368455af49a8SJohan Hedberg list_del(¶ms->list); 368555af49a8SJohan Hedberg kfree(params); 368655af49a8SJohan Hedberg } 368755af49a8SJohan Hedberg 368855af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 368955af49a8SJohan Hedberg } 369055af49a8SJohan Hedberg 369155af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 3692373110c5SJohan Hedberg void hci_conn_params_clear_all(struct hci_dev *hdev) 369315819a70SAndre Guedes { 369415819a70SAndre Guedes struct hci_conn_params *params, *tmp; 369515819a70SAndre Guedes 369615819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 3697a2f41a8fSJohan Hedberg list_del(¶ms->action); 369815819a70SAndre Guedes list_del(¶ms->list); 369915819a70SAndre Guedes kfree(params); 370015819a70SAndre Guedes } 370115819a70SAndre Guedes 3702a2f41a8fSJohan Hedberg hci_update_background_scan(hdev); 37031089b67dSMarcel Holtmann 370415819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 370515819a70SAndre Guedes } 370615819a70SAndre Guedes 37074c87eaabSAndre Guedes static void inquiry_complete(struct hci_dev *hdev, u8 status) 37087ba8b4beSAndre Guedes { 37094c87eaabSAndre Guedes if (status) { 37104c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 37117ba8b4beSAndre Guedes 37124c87eaabSAndre Guedes hci_dev_lock(hdev); 37134c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37144c87eaabSAndre Guedes hci_dev_unlock(hdev); 37154c87eaabSAndre Guedes return; 37164c87eaabSAndre Guedes } 37177ba8b4beSAndre Guedes } 37187ba8b4beSAndre Guedes 37194c87eaabSAndre Guedes static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status) 37207ba8b4beSAndre Guedes { 37214c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 37224c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 37234c87eaabSAndre Guedes struct hci_request req; 37244c87eaabSAndre Guedes struct hci_cp_inquiry cp; 37257ba8b4beSAndre Guedes int err; 37267ba8b4beSAndre Guedes 37274c87eaabSAndre Guedes if (status) { 37284c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 37294c87eaabSAndre Guedes return; 37307ba8b4beSAndre Guedes } 37317ba8b4beSAndre Guedes 37324c87eaabSAndre Guedes switch (hdev->discovery.type) { 37334c87eaabSAndre Guedes case DISCOV_TYPE_LE: 37344c87eaabSAndre Guedes hci_dev_lock(hdev); 37354c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37364c87eaabSAndre Guedes hci_dev_unlock(hdev); 37374c87eaabSAndre Guedes break; 37387dbfac1dSAndre Guedes 37394c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 37404c87eaabSAndre Guedes hci_req_init(&req, hdev); 37417dbfac1dSAndre Guedes 37427dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 37434c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 37444c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 37454c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 37464c87eaabSAndre Guedes 37474c87eaabSAndre Guedes hci_dev_lock(hdev); 37484c87eaabSAndre Guedes 37494c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 37504c87eaabSAndre Guedes 37514c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 37524c87eaabSAndre Guedes if (err) { 37534c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 37544c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 37557dbfac1dSAndre Guedes } 37567dbfac1dSAndre Guedes 37574c87eaabSAndre Guedes hci_dev_unlock(hdev); 37584c87eaabSAndre Guedes break; 37594c87eaabSAndre Guedes } 37607dbfac1dSAndre Guedes } 37617dbfac1dSAndre Guedes 37627ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 37637ba8b4beSAndre Guedes { 37647ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 37657ba8b4beSAndre Guedes le_scan_disable.work); 37664c87eaabSAndre Guedes struct hci_request req; 37674c87eaabSAndre Guedes int err; 37687ba8b4beSAndre Guedes 37697ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 37707ba8b4beSAndre Guedes 37714c87eaabSAndre Guedes hci_req_init(&req, hdev); 37727ba8b4beSAndre Guedes 3773b1efcc28SAndre Guedes hci_req_add_le_scan_disable(&req); 37747ba8b4beSAndre Guedes 37754c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 37764c87eaabSAndre Guedes if (err) 37774c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 377828b75a89SAndre Guedes } 377928b75a89SAndre Guedes 37808d97250eSJohan Hedberg static void set_random_addr(struct hci_request *req, bdaddr_t *rpa) 37818d97250eSJohan Hedberg { 37828d97250eSJohan Hedberg struct hci_dev *hdev = req->hdev; 37838d97250eSJohan Hedberg 37848d97250eSJohan Hedberg /* If we're advertising or initiating an LE connection we can't 37858d97250eSJohan Hedberg * go ahead and change the random address at this time. This is 37868d97250eSJohan Hedberg * because the eventual initiator address used for the 37878d97250eSJohan Hedberg * subsequently created connection will be undefined (some 37888d97250eSJohan Hedberg * controllers use the new address and others the one we had 37898d97250eSJohan Hedberg * when the operation started). 37908d97250eSJohan Hedberg * 37918d97250eSJohan Hedberg * In this kind of scenario skip the update and let the random 37928d97250eSJohan Hedberg * address be updated at the next cycle. 37938d97250eSJohan Hedberg */ 37945ce194c4SJohan Hedberg if (test_bit(HCI_LE_ADV, &hdev->dev_flags) || 37958d97250eSJohan Hedberg hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT)) { 37968d97250eSJohan Hedberg BT_DBG("Deferring random address update"); 37978d97250eSJohan Hedberg return; 37988d97250eSJohan Hedberg } 37998d97250eSJohan Hedberg 38008d97250eSJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, rpa); 38018d97250eSJohan Hedberg } 38028d97250eSJohan Hedberg 380394b1fc92SMarcel Holtmann int hci_update_random_address(struct hci_request *req, bool require_privacy, 380494b1fc92SMarcel Holtmann u8 *own_addr_type) 3805ebd3a747SJohan Hedberg { 3806ebd3a747SJohan Hedberg struct hci_dev *hdev = req->hdev; 3807ebd3a747SJohan Hedberg int err; 3808ebd3a747SJohan Hedberg 3809ebd3a747SJohan Hedberg /* If privacy is enabled use a resolvable private address. If 38102b5224dcSMarcel Holtmann * current RPA has expired or there is something else than 38112b5224dcSMarcel Holtmann * the current RPA in use, then generate a new one. 3812ebd3a747SJohan Hedberg */ 3813ebd3a747SJohan Hedberg if (test_bit(HCI_PRIVACY, &hdev->dev_flags)) { 3814ebd3a747SJohan Hedberg int to; 3815ebd3a747SJohan Hedberg 3816ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3817ebd3a747SJohan Hedberg 3818ebd3a747SJohan Hedberg if (!test_and_clear_bit(HCI_RPA_EXPIRED, &hdev->dev_flags) && 38192b5224dcSMarcel Holtmann !bacmp(&hdev->random_addr, &hdev->rpa)) 3820ebd3a747SJohan Hedberg return 0; 3821ebd3a747SJohan Hedberg 38222b5224dcSMarcel Holtmann err = smp_generate_rpa(hdev->tfm_aes, hdev->irk, &hdev->rpa); 3823ebd3a747SJohan Hedberg if (err < 0) { 3824ebd3a747SJohan Hedberg BT_ERR("%s failed to generate new RPA", hdev->name); 3825ebd3a747SJohan Hedberg return err; 3826ebd3a747SJohan Hedberg } 3827ebd3a747SJohan Hedberg 38288d97250eSJohan Hedberg set_random_addr(req, &hdev->rpa); 3829ebd3a747SJohan Hedberg 3830ebd3a747SJohan Hedberg to = msecs_to_jiffies(hdev->rpa_timeout * 1000); 3831ebd3a747SJohan Hedberg queue_delayed_work(hdev->workqueue, &hdev->rpa_expired, to); 3832ebd3a747SJohan Hedberg 3833ebd3a747SJohan Hedberg return 0; 3834ebd3a747SJohan Hedberg } 3835ebd3a747SJohan Hedberg 383694b1fc92SMarcel Holtmann /* In case of required privacy without resolvable private address, 383794b1fc92SMarcel Holtmann * use an unresolvable private address. This is useful for active 383894b1fc92SMarcel Holtmann * scanning and non-connectable advertising. 383994b1fc92SMarcel Holtmann */ 384094b1fc92SMarcel Holtmann if (require_privacy) { 384194b1fc92SMarcel Holtmann bdaddr_t urpa; 384294b1fc92SMarcel Holtmann 384394b1fc92SMarcel Holtmann get_random_bytes(&urpa, 6); 384494b1fc92SMarcel Holtmann urpa.b[5] &= 0x3f; /* Clear two most significant bits */ 384594b1fc92SMarcel Holtmann 384694b1fc92SMarcel Holtmann *own_addr_type = ADDR_LE_DEV_RANDOM; 38478d97250eSJohan Hedberg set_random_addr(req, &urpa); 384894b1fc92SMarcel Holtmann return 0; 384994b1fc92SMarcel Holtmann } 385094b1fc92SMarcel Holtmann 3851ebd3a747SJohan Hedberg /* If forcing static address is in use or there is no public 3852ebd3a747SJohan Hedberg * address use the static address as random address (but skip 3853ebd3a747SJohan Hedberg * the HCI command if the current random address is already the 3854ebd3a747SJohan Hedberg * static one. 3855ebd3a747SJohan Hedberg */ 3856111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3857ebd3a747SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3858ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_RANDOM; 3859ebd3a747SJohan Hedberg if (bacmp(&hdev->static_addr, &hdev->random_addr)) 3860ebd3a747SJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_RANDOM_ADDR, 6, 3861ebd3a747SJohan Hedberg &hdev->static_addr); 3862ebd3a747SJohan Hedberg return 0; 3863ebd3a747SJohan Hedberg } 3864ebd3a747SJohan Hedberg 3865ebd3a747SJohan Hedberg /* Neither privacy nor static address is being used so use a 3866ebd3a747SJohan Hedberg * public address. 3867ebd3a747SJohan Hedberg */ 3868ebd3a747SJohan Hedberg *own_addr_type = ADDR_LE_DEV_PUBLIC; 3869ebd3a747SJohan Hedberg 3870ebd3a747SJohan Hedberg return 0; 3871ebd3a747SJohan Hedberg } 3872ebd3a747SJohan Hedberg 3873a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 3874a1f4c318SJohan Hedberg * 3875a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 3876a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 3877a1f4c318SJohan Hedberg * the static random address. 3878a1f4c318SJohan Hedberg * 3879a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 3880a1f4c318SJohan Hedberg * public address to use the static random address instead. 3881a1f4c318SJohan Hedberg */ 3882a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 3883a1f4c318SJohan Hedberg u8 *bdaddr_type) 3884a1f4c318SJohan Hedberg { 3885111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 3886a1f4c318SJohan Hedberg !bacmp(&hdev->bdaddr, BDADDR_ANY)) { 3887a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 3888a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 3889a1f4c318SJohan Hedberg } else { 3890a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 3891a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 3892a1f4c318SJohan Hedberg } 3893a1f4c318SJohan Hedberg } 3894a1f4c318SJohan Hedberg 38959be0dab7SDavid Herrmann /* Alloc HCI device */ 38969be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 38979be0dab7SDavid Herrmann { 38989be0dab7SDavid Herrmann struct hci_dev *hdev; 38999be0dab7SDavid Herrmann 39009be0dab7SDavid Herrmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 39019be0dab7SDavid Herrmann if (!hdev) 39029be0dab7SDavid Herrmann return NULL; 39039be0dab7SDavid Herrmann 3904b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 3905b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 3906b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3907b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3908b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 390996c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3910bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3911bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3912b1b813d4SDavid Herrmann 3913b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3914b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3915b1b813d4SDavid Herrmann 39163f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3917bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3918bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 39194e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 39204e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 392104fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 392204fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3923bef64738SMarcel Holtmann 3924d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3925b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 392631ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 392731ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3928d6bfd59cSJohan Hedberg 3929b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3930b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3931b1b813d4SDavid Herrmann 3932b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3933b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 39346659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 3935b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3936b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3937b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3938970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3939b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3940d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 394115819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 394277a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 394366f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 39446b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3945b1b813d4SDavid Herrmann 3946b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3947b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3948b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3949b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3950b1b813d4SDavid Herrmann 3951b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3952b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 3953b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 3954b1b813d4SDavid Herrmann 3955b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3956b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3957b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3958b1b813d4SDavid Herrmann 3959b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3960b1b813d4SDavid Herrmann 396165cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3962b1b813d4SDavid Herrmann 3963b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3964b1b813d4SDavid Herrmann discovery_init(hdev); 39659be0dab7SDavid Herrmann 39669be0dab7SDavid Herrmann return hdev; 39679be0dab7SDavid Herrmann } 39689be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 39699be0dab7SDavid Herrmann 39709be0dab7SDavid Herrmann /* Free HCI device */ 39719be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 39729be0dab7SDavid Herrmann { 39739be0dab7SDavid Herrmann /* will free via device release */ 39749be0dab7SDavid Herrmann put_device(&hdev->dev); 39759be0dab7SDavid Herrmann } 39769be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 39779be0dab7SDavid Herrmann 39781da177e4SLinus Torvalds /* Register HCI device */ 39791da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 39801da177e4SLinus Torvalds { 3981b1b813d4SDavid Herrmann int id, error; 39821da177e4SLinus Torvalds 398374292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 39841da177e4SLinus Torvalds return -EINVAL; 39851da177e4SLinus Torvalds 398608add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 398708add513SMat Martineau * so the index can be used as the AMP controller ID. 398808add513SMat Martineau */ 39893df92b31SSasha Levin switch (hdev->dev_type) { 39903df92b31SSasha Levin case HCI_BREDR: 39913df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 39921da177e4SLinus Torvalds break; 39933df92b31SSasha Levin case HCI_AMP: 39943df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 39953df92b31SSasha Levin break; 39963df92b31SSasha Levin default: 39973df92b31SSasha Levin return -EINVAL; 39981da177e4SLinus Torvalds } 39991da177e4SLinus Torvalds 40003df92b31SSasha Levin if (id < 0) 40013df92b31SSasha Levin return id; 40023df92b31SSasha Levin 40031da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 40041da177e4SLinus Torvalds hdev->id = id; 40052d8b3a11SAndrei Emeltchenko 40062d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 40072d8b3a11SAndrei Emeltchenko 4008d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 4009d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 401033ca954dSDavid Herrmann if (!hdev->workqueue) { 401133ca954dSDavid Herrmann error = -ENOMEM; 401233ca954dSDavid Herrmann goto err; 401333ca954dSDavid Herrmann } 4014f48fd9c8SMarcel Holtmann 4015d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 4016d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 40176ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 40186ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 40196ead1bbcSJohan Hedberg error = -ENOMEM; 40206ead1bbcSJohan Hedberg goto err; 40216ead1bbcSJohan Hedberg } 40226ead1bbcSJohan Hedberg 40230153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 40240153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 40250153e2ecSMarcel Holtmann 4026bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 4027bdc3e0f1SMarcel Holtmann 402899780a7bSJohan Hedberg hdev->tfm_aes = crypto_alloc_blkcipher("ecb(aes)", 0, 402999780a7bSJohan Hedberg CRYPTO_ALG_ASYNC); 403099780a7bSJohan Hedberg if (IS_ERR(hdev->tfm_aes)) { 403199780a7bSJohan Hedberg BT_ERR("Unable to create crypto context"); 403299780a7bSJohan Hedberg error = PTR_ERR(hdev->tfm_aes); 403399780a7bSJohan Hedberg hdev->tfm_aes = NULL; 403499780a7bSJohan Hedberg goto err_wqueue; 403599780a7bSJohan Hedberg } 403699780a7bSJohan Hedberg 4037bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 403833ca954dSDavid Herrmann if (error < 0) 403999780a7bSJohan Hedberg goto err_tfm; 40401da177e4SLinus Torvalds 4041611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 4042a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 4043a8c5fb1aSGustavo Padovan hdev); 4044611b30f7SMarcel Holtmann if (hdev->rfkill) { 4045611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 4046611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 4047611b30f7SMarcel Holtmann hdev->rfkill = NULL; 4048611b30f7SMarcel Holtmann } 4049611b30f7SMarcel Holtmann } 4050611b30f7SMarcel Holtmann 40515e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 40525e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 40535e130367SJohan Hedberg 4054a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 4055004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 4056ce2be9acSAndrei Emeltchenko 405701cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 405856f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 405956f87901SJohan Hedberg * through reading supported features during init. 406056f87901SJohan Hedberg */ 406156f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 406256f87901SJohan Hedberg } 4063ce2be9acSAndrei Emeltchenko 4064fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 4065fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 4066fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 4067fcee3377SGustavo Padovan 40684a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 40694a964404SMarcel Holtmann * and should not be included in normal operation. 4070fee746b0SMarcel Holtmann */ 4071fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 40724a964404SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 4073fee746b0SMarcel Holtmann 40741da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 4075dc946bd8SDavid Herrmann hci_dev_hold(hdev); 40761da177e4SLinus Torvalds 407719202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 4078fbe96d6fSMarcel Holtmann 40791da177e4SLinus Torvalds return id; 4080f48fd9c8SMarcel Holtmann 408199780a7bSJohan Hedberg err_tfm: 408299780a7bSJohan Hedberg crypto_free_blkcipher(hdev->tfm_aes); 408333ca954dSDavid Herrmann err_wqueue: 408433ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 40856ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 408633ca954dSDavid Herrmann err: 40873df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 4088f48fd9c8SMarcel Holtmann 408933ca954dSDavid Herrmann return error; 40901da177e4SLinus Torvalds } 40911da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 40921da177e4SLinus Torvalds 40931da177e4SLinus Torvalds /* Unregister HCI device */ 409459735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 40951da177e4SLinus Torvalds { 40963df92b31SSasha Levin int i, id; 4097ef222013SMarcel Holtmann 4098c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 40991da177e4SLinus Torvalds 410094324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 410194324962SJohan Hovold 41023df92b31SSasha Levin id = hdev->id; 41033df92b31SSasha Levin 4104f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 41051da177e4SLinus Torvalds list_del(&hdev->list); 4106f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 41071da177e4SLinus Torvalds 41081da177e4SLinus Torvalds hci_dev_do_close(hdev); 41091da177e4SLinus Torvalds 4110cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 4111ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 4112ef222013SMarcel Holtmann 4113b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 4114b9b5ef18SGustavo Padovan 4115ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 4116d603b76bSMarcel Holtmann !test_bit(HCI_SETUP, &hdev->dev_flags) && 4117d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 411809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 4119744cf19eSJohan Hedberg mgmt_index_removed(hdev); 412009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 412156e5cb86SJohan Hedberg } 4122ab81cbf9SJohan Hedberg 41232e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 41242e58ef3eSJohan Hedberg * pending list */ 41252e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 41262e58ef3eSJohan Hedberg 41271da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 41281da177e4SLinus Torvalds 4129611b30f7SMarcel Holtmann if (hdev->rfkill) { 4130611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 4131611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 4132611b30f7SMarcel Holtmann } 4133611b30f7SMarcel Holtmann 413499780a7bSJohan Hedberg if (hdev->tfm_aes) 413599780a7bSJohan Hedberg crypto_free_blkcipher(hdev->tfm_aes); 413699780a7bSJohan Hedberg 4137bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 4138147e2d59SDave Young 41390153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 41400153e2ecSMarcel Holtmann 4141f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 41426ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 4143f48fd9c8SMarcel Holtmann 414409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 4145dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 41466659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 41472aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 414855ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 4149b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 4150970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 41512763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 4152dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 4153373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 415409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 4155e2e0cacbSJohan Hedberg 4156dc946bd8SDavid Herrmann hci_dev_put(hdev); 41573df92b31SSasha Levin 41583df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 41591da177e4SLinus Torvalds } 41601da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 41611da177e4SLinus Torvalds 41621da177e4SLinus Torvalds /* Suspend HCI device */ 41631da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 41641da177e4SLinus Torvalds { 41651da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 41661da177e4SLinus Torvalds return 0; 41671da177e4SLinus Torvalds } 41681da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 41691da177e4SLinus Torvalds 41701da177e4SLinus Torvalds /* Resume HCI device */ 41711da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 41721da177e4SLinus Torvalds { 41731da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 41741da177e4SLinus Torvalds return 0; 41751da177e4SLinus Torvalds } 41761da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 41771da177e4SLinus Torvalds 417876bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 4179e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 418076bca880SMarcel Holtmann { 418176bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 418276bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 418376bca880SMarcel Holtmann kfree_skb(skb); 418476bca880SMarcel Holtmann return -ENXIO; 418576bca880SMarcel Holtmann } 418676bca880SMarcel Holtmann 4187d82603c6SJorrit Schippers /* Incoming skb */ 418876bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 418976bca880SMarcel Holtmann 419076bca880SMarcel Holtmann /* Time stamp */ 419176bca880SMarcel Holtmann __net_timestamp(skb); 419276bca880SMarcel Holtmann 419376bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 4194b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 4195c78ae283SMarcel Holtmann 419676bca880SMarcel Holtmann return 0; 419776bca880SMarcel Holtmann } 419876bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 419976bca880SMarcel Holtmann 420033e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 42011e429f38SGustavo F. Padovan int count, __u8 index) 420233e882a5SSuraj Sumangala { 420333e882a5SSuraj Sumangala int len = 0; 420433e882a5SSuraj Sumangala int hlen = 0; 420533e882a5SSuraj Sumangala int remain = count; 420633e882a5SSuraj Sumangala struct sk_buff *skb; 420733e882a5SSuraj Sumangala struct bt_skb_cb *scb; 420833e882a5SSuraj Sumangala 420933e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 421033e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 421133e882a5SSuraj Sumangala return -EILSEQ; 421233e882a5SSuraj Sumangala 421333e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 421433e882a5SSuraj Sumangala 421533e882a5SSuraj Sumangala if (!skb) { 421633e882a5SSuraj Sumangala switch (type) { 421733e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 421833e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 421933e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 422033e882a5SSuraj Sumangala break; 422133e882a5SSuraj Sumangala case HCI_EVENT_PKT: 422233e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 422333e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 422433e882a5SSuraj Sumangala break; 422533e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 422633e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 422733e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 422833e882a5SSuraj Sumangala break; 422933e882a5SSuraj Sumangala } 423033e882a5SSuraj Sumangala 42311e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 423233e882a5SSuraj Sumangala if (!skb) 423333e882a5SSuraj Sumangala return -ENOMEM; 423433e882a5SSuraj Sumangala 423533e882a5SSuraj Sumangala scb = (void *) skb->cb; 423633e882a5SSuraj Sumangala scb->expect = hlen; 423733e882a5SSuraj Sumangala scb->pkt_type = type; 423833e882a5SSuraj Sumangala 423933e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 424033e882a5SSuraj Sumangala } 424133e882a5SSuraj Sumangala 424233e882a5SSuraj Sumangala while (count) { 424333e882a5SSuraj Sumangala scb = (void *) skb->cb; 424489bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 424533e882a5SSuraj Sumangala 424633e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 424733e882a5SSuraj Sumangala 424833e882a5SSuraj Sumangala count -= len; 424933e882a5SSuraj Sumangala data += len; 425033e882a5SSuraj Sumangala scb->expect -= len; 425133e882a5SSuraj Sumangala remain = count; 425233e882a5SSuraj Sumangala 425333e882a5SSuraj Sumangala switch (type) { 425433e882a5SSuraj Sumangala case HCI_EVENT_PKT: 425533e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 425633e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 425733e882a5SSuraj Sumangala scb->expect = h->plen; 425833e882a5SSuraj Sumangala 425933e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 426033e882a5SSuraj Sumangala kfree_skb(skb); 426133e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 426233e882a5SSuraj Sumangala return -ENOMEM; 426333e882a5SSuraj Sumangala } 426433e882a5SSuraj Sumangala } 426533e882a5SSuraj Sumangala break; 426633e882a5SSuraj Sumangala 426733e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 426833e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 426933e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 427033e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 427133e882a5SSuraj Sumangala 427233e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 427333e882a5SSuraj Sumangala kfree_skb(skb); 427433e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 427533e882a5SSuraj Sumangala return -ENOMEM; 427633e882a5SSuraj Sumangala } 427733e882a5SSuraj Sumangala } 427833e882a5SSuraj Sumangala break; 427933e882a5SSuraj Sumangala 428033e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 428133e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 428233e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 428333e882a5SSuraj Sumangala scb->expect = h->dlen; 428433e882a5SSuraj Sumangala 428533e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 428633e882a5SSuraj Sumangala kfree_skb(skb); 428733e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 428833e882a5SSuraj Sumangala return -ENOMEM; 428933e882a5SSuraj Sumangala } 429033e882a5SSuraj Sumangala } 429133e882a5SSuraj Sumangala break; 429233e882a5SSuraj Sumangala } 429333e882a5SSuraj Sumangala 429433e882a5SSuraj Sumangala if (scb->expect == 0) { 429533e882a5SSuraj Sumangala /* Complete frame */ 429633e882a5SSuraj Sumangala 429733e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 4298e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 429933e882a5SSuraj Sumangala 430033e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 430133e882a5SSuraj Sumangala return remain; 430233e882a5SSuraj Sumangala } 430333e882a5SSuraj Sumangala } 430433e882a5SSuraj Sumangala 430533e882a5SSuraj Sumangala return remain; 430633e882a5SSuraj Sumangala } 430733e882a5SSuraj Sumangala 4308ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 4309ef222013SMarcel Holtmann { 4310f39a3c06SSuraj Sumangala int rem = 0; 4311f39a3c06SSuraj Sumangala 4312ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 4313ef222013SMarcel Holtmann return -EILSEQ; 4314ef222013SMarcel Holtmann 4315da5f6c37SGustavo F. Padovan while (count) { 43161e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, type - 1); 4317f39a3c06SSuraj Sumangala if (rem < 0) 4318f39a3c06SSuraj Sumangala return rem; 4319ef222013SMarcel Holtmann 4320f39a3c06SSuraj Sumangala data += (count - rem); 4321f39a3c06SSuraj Sumangala count = rem; 4322f81c6224SJoe Perches } 4323ef222013SMarcel Holtmann 4324f39a3c06SSuraj Sumangala return rem; 4325ef222013SMarcel Holtmann } 4326ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 4327ef222013SMarcel Holtmann 432899811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 432999811510SSuraj Sumangala 433099811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 433199811510SSuraj Sumangala { 433299811510SSuraj Sumangala int type; 433399811510SSuraj Sumangala int rem = 0; 433499811510SSuraj Sumangala 4335da5f6c37SGustavo F. Padovan while (count) { 433699811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 433799811510SSuraj Sumangala 433899811510SSuraj Sumangala if (!skb) { 433999811510SSuraj Sumangala struct { char type; } *pkt; 434099811510SSuraj Sumangala 434199811510SSuraj Sumangala /* Start of the frame */ 434299811510SSuraj Sumangala pkt = data; 434399811510SSuraj Sumangala type = pkt->type; 434499811510SSuraj Sumangala 434599811510SSuraj Sumangala data++; 434699811510SSuraj Sumangala count--; 434799811510SSuraj Sumangala } else 434899811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 434999811510SSuraj Sumangala 43501e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 43511e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 435299811510SSuraj Sumangala if (rem < 0) 435399811510SSuraj Sumangala return rem; 435499811510SSuraj Sumangala 435599811510SSuraj Sumangala data += (count - rem); 435699811510SSuraj Sumangala count = rem; 4357f81c6224SJoe Perches } 435899811510SSuraj Sumangala 435999811510SSuraj Sumangala return rem; 436099811510SSuraj Sumangala } 436199811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 436299811510SSuraj Sumangala 43631da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 43641da177e4SLinus Torvalds 43651da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 43661da177e4SLinus Torvalds { 43671da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 43681da177e4SLinus Torvalds 4369f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 43701da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 4371f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 43721da177e4SLinus Torvalds 43731da177e4SLinus Torvalds return 0; 43741da177e4SLinus Torvalds } 43751da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 43761da177e4SLinus Torvalds 43771da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 43781da177e4SLinus Torvalds { 43791da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 43801da177e4SLinus Torvalds 4381f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 43821da177e4SLinus Torvalds list_del(&cb->list); 4383f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 43841da177e4SLinus Torvalds 43851da177e4SLinus Torvalds return 0; 43861da177e4SLinus Torvalds } 43871da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 43881da177e4SLinus Torvalds 438951086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 43901da177e4SLinus Torvalds { 4391cdc52faaSMarcel Holtmann int err; 4392cdc52faaSMarcel Holtmann 43930d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 43941da177e4SLinus Torvalds 43951da177e4SLinus Torvalds /* Time stamp */ 4396a61bbcf2SPatrick McHardy __net_timestamp(skb); 43971da177e4SLinus Torvalds 4398cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4399cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4400cd82e61cSMarcel Holtmann 4401cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 4402cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 4403470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 44041da177e4SLinus Torvalds } 44051da177e4SLinus Torvalds 44061da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 44071da177e4SLinus Torvalds skb_orphan(skb); 44081da177e4SLinus Torvalds 4409cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 4410cdc52faaSMarcel Holtmann if (err < 0) { 4411cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 4412cdc52faaSMarcel Holtmann kfree_skb(skb); 4413cdc52faaSMarcel Holtmann } 44141da177e4SLinus Torvalds } 44151da177e4SLinus Torvalds 44163119ae95SJohan Hedberg void hci_req_init(struct hci_request *req, struct hci_dev *hdev) 44173119ae95SJohan Hedberg { 44183119ae95SJohan Hedberg skb_queue_head_init(&req->cmd_q); 44193119ae95SJohan Hedberg req->hdev = hdev; 44205d73e034SAndre Guedes req->err = 0; 44213119ae95SJohan Hedberg } 44223119ae95SJohan Hedberg 44233119ae95SJohan Hedberg int hci_req_run(struct hci_request *req, hci_req_complete_t complete) 44243119ae95SJohan Hedberg { 44253119ae95SJohan Hedberg struct hci_dev *hdev = req->hdev; 44263119ae95SJohan Hedberg struct sk_buff *skb; 44273119ae95SJohan Hedberg unsigned long flags; 44283119ae95SJohan Hedberg 44293119ae95SJohan Hedberg BT_DBG("length %u", skb_queue_len(&req->cmd_q)); 44303119ae95SJohan Hedberg 44315d73e034SAndre Guedes /* If an error occured during request building, remove all HCI 44325d73e034SAndre Guedes * commands queued on the HCI request queue. 44335d73e034SAndre Guedes */ 44345d73e034SAndre Guedes if (req->err) { 44355d73e034SAndre Guedes skb_queue_purge(&req->cmd_q); 44365d73e034SAndre Guedes return req->err; 44375d73e034SAndre Guedes } 44385d73e034SAndre Guedes 44393119ae95SJohan Hedberg /* Do not allow empty requests */ 44403119ae95SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 4441382b0c39SAndre Guedes return -ENODATA; 44423119ae95SJohan Hedberg 44433119ae95SJohan Hedberg skb = skb_peek_tail(&req->cmd_q); 44443119ae95SJohan Hedberg bt_cb(skb)->req.complete = complete; 44453119ae95SJohan Hedberg 44463119ae95SJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 44473119ae95SJohan Hedberg skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q); 44483119ae95SJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 44493119ae95SJohan Hedberg 44503119ae95SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 44513119ae95SJohan Hedberg 44523119ae95SJohan Hedberg return 0; 44533119ae95SJohan Hedberg } 44543119ae95SJohan Hedberg 4455899de765SMarcel Holtmann bool hci_req_pending(struct hci_dev *hdev) 4456899de765SMarcel Holtmann { 4457899de765SMarcel Holtmann return (hdev->req_status == HCI_REQ_PEND); 4458899de765SMarcel Holtmann } 4459899de765SMarcel Holtmann 44601ca3a9d0SJohan Hedberg static struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, 446107dc93ddSJohan Hedberg u32 plen, const void *param) 44621da177e4SLinus Torvalds { 44631da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 44641da177e4SLinus Torvalds struct hci_command_hdr *hdr; 44651da177e4SLinus Torvalds struct sk_buff *skb; 44661da177e4SLinus Torvalds 44671da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 44681ca3a9d0SJohan Hedberg if (!skb) 44691ca3a9d0SJohan Hedberg return NULL; 44701da177e4SLinus Torvalds 44711da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 4472a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 44731da177e4SLinus Torvalds hdr->plen = plen; 44741da177e4SLinus Torvalds 44751da177e4SLinus Torvalds if (plen) 44761da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 44771da177e4SLinus Torvalds 44781da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 44791da177e4SLinus Torvalds 44800d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 4481c78ae283SMarcel Holtmann 44821ca3a9d0SJohan Hedberg return skb; 44831ca3a9d0SJohan Hedberg } 44841ca3a9d0SJohan Hedberg 44851ca3a9d0SJohan Hedberg /* Send HCI command */ 448607dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 448707dc93ddSJohan Hedberg const void *param) 44881ca3a9d0SJohan Hedberg { 44891ca3a9d0SJohan Hedberg struct sk_buff *skb; 44901ca3a9d0SJohan Hedberg 44911ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 44921ca3a9d0SJohan Hedberg 44931ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 44941ca3a9d0SJohan Hedberg if (!skb) { 44951ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 44961ca3a9d0SJohan Hedberg return -ENOMEM; 44971ca3a9d0SJohan Hedberg } 44981ca3a9d0SJohan Hedberg 449911714b3dSJohan Hedberg /* Stand-alone HCI commands must be flaged as 450011714b3dSJohan Hedberg * single-command requests. 450111714b3dSJohan Hedberg */ 450211714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 450311714b3dSJohan Hedberg 45041da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 4505c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 45061da177e4SLinus Torvalds 45071da177e4SLinus Torvalds return 0; 45081da177e4SLinus Torvalds } 45091da177e4SLinus Torvalds 451071c76a17SJohan Hedberg /* Queue a command to an asynchronous HCI request */ 451107dc93ddSJohan Hedberg void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen, 451207dc93ddSJohan Hedberg const void *param, u8 event) 451371c76a17SJohan Hedberg { 451471c76a17SJohan Hedberg struct hci_dev *hdev = req->hdev; 451571c76a17SJohan Hedberg struct sk_buff *skb; 451671c76a17SJohan Hedberg 451771c76a17SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 451871c76a17SJohan Hedberg 451934739c1eSAndre Guedes /* If an error occured during request building, there is no point in 452034739c1eSAndre Guedes * queueing the HCI command. We can simply return. 452134739c1eSAndre Guedes */ 452234739c1eSAndre Guedes if (req->err) 452334739c1eSAndre Guedes return; 452434739c1eSAndre Guedes 452571c76a17SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 452671c76a17SJohan Hedberg if (!skb) { 45275d73e034SAndre Guedes BT_ERR("%s no memory for command (opcode 0x%4.4x)", 45285d73e034SAndre Guedes hdev->name, opcode); 45295d73e034SAndre Guedes req->err = -ENOMEM; 4530e348fe6bSAndre Guedes return; 453171c76a17SJohan Hedberg } 453271c76a17SJohan Hedberg 453371c76a17SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 453471c76a17SJohan Hedberg bt_cb(skb)->req.start = true; 453571c76a17SJohan Hedberg 453602350a72SJohan Hedberg bt_cb(skb)->req.event = event; 453702350a72SJohan Hedberg 453871c76a17SJohan Hedberg skb_queue_tail(&req->cmd_q, skb); 453971c76a17SJohan Hedberg } 454071c76a17SJohan Hedberg 454107dc93ddSJohan Hedberg void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, 454207dc93ddSJohan Hedberg const void *param) 454302350a72SJohan Hedberg { 454402350a72SJohan Hedberg hci_req_add_ev(req, opcode, plen, param, 0); 454502350a72SJohan Hedberg } 454602350a72SJohan Hedberg 45471da177e4SLinus Torvalds /* Get data from the previously sent command */ 4548a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 45491da177e4SLinus Torvalds { 45501da177e4SLinus Torvalds struct hci_command_hdr *hdr; 45511da177e4SLinus Torvalds 45521da177e4SLinus Torvalds if (!hdev->sent_cmd) 45531da177e4SLinus Torvalds return NULL; 45541da177e4SLinus Torvalds 45551da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 45561da177e4SLinus Torvalds 4557a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 45581da177e4SLinus Torvalds return NULL; 45591da177e4SLinus Torvalds 4560f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 45611da177e4SLinus Torvalds 45621da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 45631da177e4SLinus Torvalds } 45641da177e4SLinus Torvalds 45651da177e4SLinus Torvalds /* Send ACL data */ 45661da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 45671da177e4SLinus Torvalds { 45681da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 45691da177e4SLinus Torvalds int len = skb->len; 45701da177e4SLinus Torvalds 4571badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 4572badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 45739c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 4574aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 4575aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 45761da177e4SLinus Torvalds } 45771da177e4SLinus Torvalds 4578ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 457973d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 45801da177e4SLinus Torvalds { 4581ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 45821da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 45831da177e4SLinus Torvalds struct sk_buff *list; 45841da177e4SLinus Torvalds 4585087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 4586087bfd99SGustavo Padovan skb->data_len = 0; 4587087bfd99SGustavo Padovan 4588087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4589204a6e54SAndrei Emeltchenko 4590204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 4591204a6e54SAndrei Emeltchenko case HCI_BREDR: 4592087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 4593204a6e54SAndrei Emeltchenko break; 4594204a6e54SAndrei Emeltchenko case HCI_AMP: 4595204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 4596204a6e54SAndrei Emeltchenko break; 4597204a6e54SAndrei Emeltchenko default: 4598204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 4599204a6e54SAndrei Emeltchenko return; 4600204a6e54SAndrei Emeltchenko } 4601087bfd99SGustavo Padovan 460270f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 460370f23020SAndrei Emeltchenko if (!list) { 46041da177e4SLinus Torvalds /* Non fragmented */ 46051da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 46061da177e4SLinus Torvalds 460773d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 46081da177e4SLinus Torvalds } else { 46091da177e4SLinus Torvalds /* Fragmented */ 46101da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 46111da177e4SLinus Torvalds 46121da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 46131da177e4SLinus Torvalds 46141da177e4SLinus Torvalds /* Queue all fragments atomically */ 4615af3e6359SGustavo F. Padovan spin_lock(&queue->lock); 46161da177e4SLinus Torvalds 461773d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 4618e702112fSAndrei Emeltchenko 4619e702112fSAndrei Emeltchenko flags &= ~ACL_START; 4620e702112fSAndrei Emeltchenko flags |= ACL_CONT; 46211da177e4SLinus Torvalds do { 46221da177e4SLinus Torvalds skb = list; list = list->next; 46231da177e4SLinus Torvalds 46240d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 4625e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 46261da177e4SLinus Torvalds 46271da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 46281da177e4SLinus Torvalds 462973d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 46301da177e4SLinus Torvalds } while (list); 46311da177e4SLinus Torvalds 4632af3e6359SGustavo F. Padovan spin_unlock(&queue->lock); 46331da177e4SLinus Torvalds } 463473d80debSLuiz Augusto von Dentz } 463573d80debSLuiz Augusto von Dentz 463673d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 463773d80debSLuiz Augusto von Dentz { 4638ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 463973d80debSLuiz Augusto von Dentz 4640f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 464173d80debSLuiz Augusto von Dentz 4642ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 46431da177e4SLinus Torvalds 46443eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 46451da177e4SLinus Torvalds } 46461da177e4SLinus Torvalds 46471da177e4SLinus Torvalds /* Send SCO data */ 46480d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 46491da177e4SLinus Torvalds { 46501da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 46511da177e4SLinus Torvalds struct hci_sco_hdr hdr; 46521da177e4SLinus Torvalds 46531da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 46541da177e4SLinus Torvalds 4655aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 46561da177e4SLinus Torvalds hdr.dlen = skb->len; 46571da177e4SLinus Torvalds 4658badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 4659badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 46609c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 46611da177e4SLinus Torvalds 46620d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 4663c78ae283SMarcel Holtmann 46641da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 46653eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 46661da177e4SLinus Torvalds } 46671da177e4SLinus Torvalds 46681da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 46691da177e4SLinus Torvalds 46701da177e4SLinus Torvalds /* HCI Connection scheduler */ 46716039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 4672a8c5fb1aSGustavo Padovan int *quote) 46731da177e4SLinus Torvalds { 46741da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 46758035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 4676abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 46771da177e4SLinus Torvalds 46781da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 46791da177e4SLinus Torvalds * added and removed with TX task disabled. */ 4680bf4c6325SGustavo F. Padovan 4681bf4c6325SGustavo F. Padovan rcu_read_lock(); 4682bf4c6325SGustavo F. Padovan 4683bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4684769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 46851da177e4SLinus Torvalds continue; 4686769be974SMarcel Holtmann 4687769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 4688769be974SMarcel Holtmann continue; 4689769be974SMarcel Holtmann 46901da177e4SLinus Torvalds num++; 46911da177e4SLinus Torvalds 46921da177e4SLinus Torvalds if (c->sent < min) { 46931da177e4SLinus Torvalds min = c->sent; 46941da177e4SLinus Torvalds conn = c; 46951da177e4SLinus Torvalds } 469652087a79SLuiz Augusto von Dentz 469752087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 469852087a79SLuiz Augusto von Dentz break; 46991da177e4SLinus Torvalds } 47001da177e4SLinus Torvalds 4701bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4702bf4c6325SGustavo F. Padovan 47031da177e4SLinus Torvalds if (conn) { 47046ed58ec5SVille Tervo int cnt, q; 47056ed58ec5SVille Tervo 47066ed58ec5SVille Tervo switch (conn->type) { 47076ed58ec5SVille Tervo case ACL_LINK: 47086ed58ec5SVille Tervo cnt = hdev->acl_cnt; 47096ed58ec5SVille Tervo break; 47106ed58ec5SVille Tervo case SCO_LINK: 47116ed58ec5SVille Tervo case ESCO_LINK: 47126ed58ec5SVille Tervo cnt = hdev->sco_cnt; 47136ed58ec5SVille Tervo break; 47146ed58ec5SVille Tervo case LE_LINK: 47156ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 47166ed58ec5SVille Tervo break; 47176ed58ec5SVille Tervo default: 47186ed58ec5SVille Tervo cnt = 0; 47196ed58ec5SVille Tervo BT_ERR("Unknown link type"); 47206ed58ec5SVille Tervo } 47216ed58ec5SVille Tervo 47226ed58ec5SVille Tervo q = cnt / num; 47231da177e4SLinus Torvalds *quote = q ? q : 1; 47241da177e4SLinus Torvalds } else 47251da177e4SLinus Torvalds *quote = 0; 47261da177e4SLinus Torvalds 47271da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 47281da177e4SLinus Torvalds return conn; 47291da177e4SLinus Torvalds } 47301da177e4SLinus Torvalds 47316039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 47321da177e4SLinus Torvalds { 47331da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 47341da177e4SLinus Torvalds struct hci_conn *c; 47351da177e4SLinus Torvalds 4736bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 47371da177e4SLinus Torvalds 4738bf4c6325SGustavo F. Padovan rcu_read_lock(); 4739bf4c6325SGustavo F. Padovan 47401da177e4SLinus Torvalds /* Kill stalled connections */ 4741bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 4742bae1f5d9SVille Tervo if (c->type == type && c->sent) { 47436ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 47446ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 4745bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 47461da177e4SLinus Torvalds } 47471da177e4SLinus Torvalds } 4748bf4c6325SGustavo F. Padovan 4749bf4c6325SGustavo F. Padovan rcu_read_unlock(); 47501da177e4SLinus Torvalds } 47511da177e4SLinus Torvalds 47526039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 475373d80debSLuiz Augusto von Dentz int *quote) 475473d80debSLuiz Augusto von Dentz { 475573d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 475673d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 4757abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 475873d80debSLuiz Augusto von Dentz struct hci_conn *conn; 475973d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 476073d80debSLuiz Augusto von Dentz 476173d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 476273d80debSLuiz Augusto von Dentz 4763bf4c6325SGustavo F. Padovan rcu_read_lock(); 4764bf4c6325SGustavo F. Padovan 4765bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 476673d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 476773d80debSLuiz Augusto von Dentz 476873d80debSLuiz Augusto von Dentz if (conn->type != type) 476973d80debSLuiz Augusto von Dentz continue; 477073d80debSLuiz Augusto von Dentz 477173d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 477273d80debSLuiz Augusto von Dentz continue; 477373d80debSLuiz Augusto von Dentz 477473d80debSLuiz Augusto von Dentz conn_num++; 477573d80debSLuiz Augusto von Dentz 47768192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 477773d80debSLuiz Augusto von Dentz struct sk_buff *skb; 477873d80debSLuiz Augusto von Dentz 477973d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 478073d80debSLuiz Augusto von Dentz continue; 478173d80debSLuiz Augusto von Dentz 478273d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 478373d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 478473d80debSLuiz Augusto von Dentz continue; 478573d80debSLuiz Augusto von Dentz 478673d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 478773d80debSLuiz Augusto von Dentz num = 0; 478873d80debSLuiz Augusto von Dentz min = ~0; 478973d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 479073d80debSLuiz Augusto von Dentz } 479173d80debSLuiz Augusto von Dentz 479273d80debSLuiz Augusto von Dentz num++; 479373d80debSLuiz Augusto von Dentz 479473d80debSLuiz Augusto von Dentz if (conn->sent < min) { 479573d80debSLuiz Augusto von Dentz min = conn->sent; 479673d80debSLuiz Augusto von Dentz chan = tmp; 479773d80debSLuiz Augusto von Dentz } 479873d80debSLuiz Augusto von Dentz } 479973d80debSLuiz Augusto von Dentz 480073d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 480173d80debSLuiz Augusto von Dentz break; 480273d80debSLuiz Augusto von Dentz } 480373d80debSLuiz Augusto von Dentz 4804bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4805bf4c6325SGustavo F. Padovan 480673d80debSLuiz Augusto von Dentz if (!chan) 480773d80debSLuiz Augusto von Dentz return NULL; 480873d80debSLuiz Augusto von Dentz 480973d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 481073d80debSLuiz Augusto von Dentz case ACL_LINK: 481173d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 481273d80debSLuiz Augusto von Dentz break; 4813bd1eb66bSAndrei Emeltchenko case AMP_LINK: 4814bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 4815bd1eb66bSAndrei Emeltchenko break; 481673d80debSLuiz Augusto von Dentz case SCO_LINK: 481773d80debSLuiz Augusto von Dentz case ESCO_LINK: 481873d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 481973d80debSLuiz Augusto von Dentz break; 482073d80debSLuiz Augusto von Dentz case LE_LINK: 482173d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 482273d80debSLuiz Augusto von Dentz break; 482373d80debSLuiz Augusto von Dentz default: 482473d80debSLuiz Augusto von Dentz cnt = 0; 482573d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 482673d80debSLuiz Augusto von Dentz } 482773d80debSLuiz Augusto von Dentz 482873d80debSLuiz Augusto von Dentz q = cnt / num; 482973d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 483073d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 483173d80debSLuiz Augusto von Dentz return chan; 483273d80debSLuiz Augusto von Dentz } 483373d80debSLuiz Augusto von Dentz 483402b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 483502b20f0bSLuiz Augusto von Dentz { 483602b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 483702b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 483802b20f0bSLuiz Augusto von Dentz int num = 0; 483902b20f0bSLuiz Augusto von Dentz 484002b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 484102b20f0bSLuiz Augusto von Dentz 4842bf4c6325SGustavo F. Padovan rcu_read_lock(); 4843bf4c6325SGustavo F. Padovan 4844bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 484502b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 484602b20f0bSLuiz Augusto von Dentz 484702b20f0bSLuiz Augusto von Dentz if (conn->type != type) 484802b20f0bSLuiz Augusto von Dentz continue; 484902b20f0bSLuiz Augusto von Dentz 485002b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 485102b20f0bSLuiz Augusto von Dentz continue; 485202b20f0bSLuiz Augusto von Dentz 485302b20f0bSLuiz Augusto von Dentz num++; 485402b20f0bSLuiz Augusto von Dentz 48558192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 485602b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 485702b20f0bSLuiz Augusto von Dentz 485802b20f0bSLuiz Augusto von Dentz if (chan->sent) { 485902b20f0bSLuiz Augusto von Dentz chan->sent = 0; 486002b20f0bSLuiz Augusto von Dentz continue; 486102b20f0bSLuiz Augusto von Dentz } 486202b20f0bSLuiz Augusto von Dentz 486302b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 486402b20f0bSLuiz Augusto von Dentz continue; 486502b20f0bSLuiz Augusto von Dentz 486602b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 486702b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 486802b20f0bSLuiz Augusto von Dentz continue; 486902b20f0bSLuiz Augusto von Dentz 487002b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 487102b20f0bSLuiz Augusto von Dentz 487202b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 487302b20f0bSLuiz Augusto von Dentz skb->priority); 487402b20f0bSLuiz Augusto von Dentz } 487502b20f0bSLuiz Augusto von Dentz 487602b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 487702b20f0bSLuiz Augusto von Dentz break; 487802b20f0bSLuiz Augusto von Dentz } 4879bf4c6325SGustavo F. Padovan 4880bf4c6325SGustavo F. Padovan rcu_read_unlock(); 4881bf4c6325SGustavo F. Padovan 488202b20f0bSLuiz Augusto von Dentz } 488302b20f0bSLuiz Augusto von Dentz 4884b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 4885b71d385aSAndrei Emeltchenko { 4886b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 4887b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 4888b71d385aSAndrei Emeltchenko } 4889b71d385aSAndrei Emeltchenko 48906039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 48911da177e4SLinus Torvalds { 48924a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 48931da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 48941da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 489563d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 48965f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 4897bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 48981da177e4SLinus Torvalds } 489963d2bc1bSAndrei Emeltchenko } 49001da177e4SLinus Torvalds 49016039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 490263d2bc1bSAndrei Emeltchenko { 490363d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 490463d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 490563d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 490663d2bc1bSAndrei Emeltchenko int quote; 490763d2bc1bSAndrei Emeltchenko 490863d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 490904837f64SMarcel Holtmann 491073d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 491173d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 4912ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4913ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 491473d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 491573d80debSLuiz Augusto von Dentz skb->len, skb->priority); 491673d80debSLuiz Augusto von Dentz 4917ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4918ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4919ec1cce24SLuiz Augusto von Dentz break; 4920ec1cce24SLuiz Augusto von Dentz 4921ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4922ec1cce24SLuiz Augusto von Dentz 492373d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 492473d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 492504837f64SMarcel Holtmann 492657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 49271da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 49281da177e4SLinus Torvalds 49291da177e4SLinus Torvalds hdev->acl_cnt--; 493073d80debSLuiz Augusto von Dentz chan->sent++; 493173d80debSLuiz Augusto von Dentz chan->conn->sent++; 49321da177e4SLinus Torvalds } 49331da177e4SLinus Torvalds } 493402b20f0bSLuiz Augusto von Dentz 493502b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 493602b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 49371da177e4SLinus Torvalds } 49381da177e4SLinus Torvalds 49396039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 4940b71d385aSAndrei Emeltchenko { 494163d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 4942b71d385aSAndrei Emeltchenko struct hci_chan *chan; 4943b71d385aSAndrei Emeltchenko struct sk_buff *skb; 4944b71d385aSAndrei Emeltchenko int quote; 4945bd1eb66bSAndrei Emeltchenko u8 type; 4946b71d385aSAndrei Emeltchenko 494763d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 4948b71d385aSAndrei Emeltchenko 4949bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4950bd1eb66bSAndrei Emeltchenko 4951bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 4952bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 4953bd1eb66bSAndrei Emeltchenko else 4954bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 4955bd1eb66bSAndrei Emeltchenko 4956b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 4957bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 4958b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 4959b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 4960b71d385aSAndrei Emeltchenko int blocks; 4961b71d385aSAndrei Emeltchenko 4962b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 4963b71d385aSAndrei Emeltchenko skb->len, skb->priority); 4964b71d385aSAndrei Emeltchenko 4965b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 4966b71d385aSAndrei Emeltchenko if (skb->priority < priority) 4967b71d385aSAndrei Emeltchenko break; 4968b71d385aSAndrei Emeltchenko 4969b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 4970b71d385aSAndrei Emeltchenko 4971b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 4972b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 4973b71d385aSAndrei Emeltchenko return; 4974b71d385aSAndrei Emeltchenko 4975b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 4976b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 4977b71d385aSAndrei Emeltchenko 497857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4979b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 4980b71d385aSAndrei Emeltchenko 4981b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 4982b71d385aSAndrei Emeltchenko quote -= blocks; 4983b71d385aSAndrei Emeltchenko 4984b71d385aSAndrei Emeltchenko chan->sent += blocks; 4985b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 4986b71d385aSAndrei Emeltchenko } 4987b71d385aSAndrei Emeltchenko } 4988b71d385aSAndrei Emeltchenko 4989b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 4990bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 4991b71d385aSAndrei Emeltchenko } 4992b71d385aSAndrei Emeltchenko 49936039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 4994b71d385aSAndrei Emeltchenko { 4995b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 4996b71d385aSAndrei Emeltchenko 4997bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 4998bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 4999bd1eb66bSAndrei Emeltchenko return; 5000bd1eb66bSAndrei Emeltchenko 5001bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 5002bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 5003b71d385aSAndrei Emeltchenko return; 5004b71d385aSAndrei Emeltchenko 5005b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 5006b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 5007b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 5008b71d385aSAndrei Emeltchenko break; 5009b71d385aSAndrei Emeltchenko 5010b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 5011b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 5012b71d385aSAndrei Emeltchenko break; 5013b71d385aSAndrei Emeltchenko } 5014b71d385aSAndrei Emeltchenko } 5015b71d385aSAndrei Emeltchenko 50161da177e4SLinus Torvalds /* Schedule SCO */ 50176039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 50181da177e4SLinus Torvalds { 50191da177e4SLinus Torvalds struct hci_conn *conn; 50201da177e4SLinus Torvalds struct sk_buff *skb; 50211da177e4SLinus Torvalds int quote; 50221da177e4SLinus Torvalds 50231da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 50241da177e4SLinus Torvalds 502552087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 502652087a79SLuiz Augusto von Dentz return; 502752087a79SLuiz Augusto von Dentz 50281da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 50291da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 50301da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 503157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 50321da177e4SLinus Torvalds 50331da177e4SLinus Torvalds conn->sent++; 50341da177e4SLinus Torvalds if (conn->sent == ~0) 50351da177e4SLinus Torvalds conn->sent = 0; 50361da177e4SLinus Torvalds } 50371da177e4SLinus Torvalds } 50381da177e4SLinus Torvalds } 50391da177e4SLinus Torvalds 50406039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 5041b6a0dc82SMarcel Holtmann { 5042b6a0dc82SMarcel Holtmann struct hci_conn *conn; 5043b6a0dc82SMarcel Holtmann struct sk_buff *skb; 5044b6a0dc82SMarcel Holtmann int quote; 5045b6a0dc82SMarcel Holtmann 5046b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 5047b6a0dc82SMarcel Holtmann 504852087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 504952087a79SLuiz Augusto von Dentz return; 505052087a79SLuiz Augusto von Dentz 50518fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 50528fc9ced3SGustavo Padovan "e))) { 5053b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 5054b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 505557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 5056b6a0dc82SMarcel Holtmann 5057b6a0dc82SMarcel Holtmann conn->sent++; 5058b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 5059b6a0dc82SMarcel Holtmann conn->sent = 0; 5060b6a0dc82SMarcel Holtmann } 5061b6a0dc82SMarcel Holtmann } 5062b6a0dc82SMarcel Holtmann } 5063b6a0dc82SMarcel Holtmann 50646039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 50656ed58ec5SVille Tervo { 506673d80debSLuiz Augusto von Dentz struct hci_chan *chan; 50676ed58ec5SVille Tervo struct sk_buff *skb; 506802b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 50696ed58ec5SVille Tervo 50706ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 50716ed58ec5SVille Tervo 507252087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 507352087a79SLuiz Augusto von Dentz return; 507452087a79SLuiz Augusto von Dentz 50754a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 50766ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 50776ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 5078bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 50796ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 5080bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 50816ed58ec5SVille Tervo } 50826ed58ec5SVille Tervo 50836ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 508402b20f0bSLuiz Augusto von Dentz tmp = cnt; 508573d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 5086ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 5087ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 508873d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 508973d80debSLuiz Augusto von Dentz skb->len, skb->priority); 50906ed58ec5SVille Tervo 5091ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 5092ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 5093ec1cce24SLuiz Augusto von Dentz break; 5094ec1cce24SLuiz Augusto von Dentz 5095ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 5096ec1cce24SLuiz Augusto von Dentz 509757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 50986ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 50996ed58ec5SVille Tervo 51006ed58ec5SVille Tervo cnt--; 510173d80debSLuiz Augusto von Dentz chan->sent++; 510273d80debSLuiz Augusto von Dentz chan->conn->sent++; 51036ed58ec5SVille Tervo } 51046ed58ec5SVille Tervo } 510573d80debSLuiz Augusto von Dentz 51066ed58ec5SVille Tervo if (hdev->le_pkts) 51076ed58ec5SVille Tervo hdev->le_cnt = cnt; 51086ed58ec5SVille Tervo else 51096ed58ec5SVille Tervo hdev->acl_cnt = cnt; 511002b20f0bSLuiz Augusto von Dentz 511102b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 511202b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 51136ed58ec5SVille Tervo } 51146ed58ec5SVille Tervo 51153eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 51161da177e4SLinus Torvalds { 51173eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 51181da177e4SLinus Torvalds struct sk_buff *skb; 51191da177e4SLinus Torvalds 51206ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 51216ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 51221da177e4SLinus Torvalds 512352de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 51241da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 51251da177e4SLinus Torvalds hci_sched_acl(hdev); 51261da177e4SLinus Torvalds hci_sched_sco(hdev); 5127b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 51286ed58ec5SVille Tervo hci_sched_le(hdev); 512952de599eSMarcel Holtmann } 51306ed58ec5SVille Tervo 51311da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 51321da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 513357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 51341da177e4SLinus Torvalds } 51351da177e4SLinus Torvalds 513625985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 51371da177e4SLinus Torvalds 51381da177e4SLinus Torvalds /* ACL data packet */ 51396039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 51401da177e4SLinus Torvalds { 51411da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 51421da177e4SLinus Torvalds struct hci_conn *conn; 51431da177e4SLinus Torvalds __u16 handle, flags; 51441da177e4SLinus Torvalds 51451da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 51461da177e4SLinus Torvalds 51471da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 51481da177e4SLinus Torvalds flags = hci_flags(handle); 51491da177e4SLinus Torvalds handle = hci_handle(handle); 51501da177e4SLinus Torvalds 5151f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 5152a8c5fb1aSGustavo Padovan handle, flags); 51531da177e4SLinus Torvalds 51541da177e4SLinus Torvalds hdev->stat.acl_rx++; 51551da177e4SLinus Torvalds 51561da177e4SLinus Torvalds hci_dev_lock(hdev); 51571da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 51581da177e4SLinus Torvalds hci_dev_unlock(hdev); 51591da177e4SLinus Torvalds 51601da177e4SLinus Torvalds if (conn) { 516165983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 516204837f64SMarcel Holtmann 51631da177e4SLinus Torvalds /* Send to upper protocol */ 5164686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 51651da177e4SLinus Torvalds return; 51661da177e4SLinus Torvalds } else { 51671da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 51681da177e4SLinus Torvalds hdev->name, handle); 51691da177e4SLinus Torvalds } 51701da177e4SLinus Torvalds 51711da177e4SLinus Torvalds kfree_skb(skb); 51721da177e4SLinus Torvalds } 51731da177e4SLinus Torvalds 51741da177e4SLinus Torvalds /* SCO data packet */ 51756039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 51761da177e4SLinus Torvalds { 51771da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 51781da177e4SLinus Torvalds struct hci_conn *conn; 51791da177e4SLinus Torvalds __u16 handle; 51801da177e4SLinus Torvalds 51811da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 51821da177e4SLinus Torvalds 51831da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 51841da177e4SLinus Torvalds 5185f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 51861da177e4SLinus Torvalds 51871da177e4SLinus Torvalds hdev->stat.sco_rx++; 51881da177e4SLinus Torvalds 51891da177e4SLinus Torvalds hci_dev_lock(hdev); 51901da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 51911da177e4SLinus Torvalds hci_dev_unlock(hdev); 51921da177e4SLinus Torvalds 51931da177e4SLinus Torvalds if (conn) { 51941da177e4SLinus Torvalds /* Send to upper protocol */ 5195686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 51961da177e4SLinus Torvalds return; 51971da177e4SLinus Torvalds } else { 51981da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 51991da177e4SLinus Torvalds hdev->name, handle); 52001da177e4SLinus Torvalds } 52011da177e4SLinus Torvalds 52021da177e4SLinus Torvalds kfree_skb(skb); 52031da177e4SLinus Torvalds } 52041da177e4SLinus Torvalds 52059238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 52069238f36aSJohan Hedberg { 52079238f36aSJohan Hedberg struct sk_buff *skb; 52089238f36aSJohan Hedberg 52099238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 52109238f36aSJohan Hedberg if (!skb) 52119238f36aSJohan Hedberg return true; 52129238f36aSJohan Hedberg 52139238f36aSJohan Hedberg return bt_cb(skb)->req.start; 52149238f36aSJohan Hedberg } 52159238f36aSJohan Hedberg 521642c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 521742c6b129SJohan Hedberg { 521842c6b129SJohan Hedberg struct hci_command_hdr *sent; 521942c6b129SJohan Hedberg struct sk_buff *skb; 522042c6b129SJohan Hedberg u16 opcode; 522142c6b129SJohan Hedberg 522242c6b129SJohan Hedberg if (!hdev->sent_cmd) 522342c6b129SJohan Hedberg return; 522442c6b129SJohan Hedberg 522542c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 522642c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 522742c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 522842c6b129SJohan Hedberg return; 522942c6b129SJohan Hedberg 523042c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 523142c6b129SJohan Hedberg if (!skb) 523242c6b129SJohan Hedberg return; 523342c6b129SJohan Hedberg 523442c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 523542c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 523642c6b129SJohan Hedberg } 523742c6b129SJohan Hedberg 52389238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 52399238f36aSJohan Hedberg { 52409238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 52419238f36aSJohan Hedberg struct sk_buff *skb; 52429238f36aSJohan Hedberg unsigned long flags; 52439238f36aSJohan Hedberg 52449238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 52459238f36aSJohan Hedberg 524642c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 524742c6b129SJohan Hedberg * sent we need to do special handling of it. 52489238f36aSJohan Hedberg */ 524942c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 525042c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 525142c6b129SJohan Hedberg * reset complete event during init and any pending 525242c6b129SJohan Hedberg * command will never be completed. In such a case we 525342c6b129SJohan Hedberg * need to resend whatever was the last sent 525442c6b129SJohan Hedberg * command. 525542c6b129SJohan Hedberg */ 525642c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 525742c6b129SJohan Hedberg hci_resend_last(hdev); 525842c6b129SJohan Hedberg 52599238f36aSJohan Hedberg return; 526042c6b129SJohan Hedberg } 52619238f36aSJohan Hedberg 52629238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 52639238f36aSJohan Hedberg * this request the request is not yet complete. 52649238f36aSJohan Hedberg */ 52659238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 52669238f36aSJohan Hedberg return; 52679238f36aSJohan Hedberg 52689238f36aSJohan Hedberg /* If this was the last command in a request the complete 52699238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 52709238f36aSJohan Hedberg * command queue (hdev->cmd_q). 52719238f36aSJohan Hedberg */ 52729238f36aSJohan Hedberg if (hdev->sent_cmd) { 52739238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 527453e21fbcSJohan Hedberg 527553e21fbcSJohan Hedberg if (req_complete) { 527653e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 527753e21fbcSJohan Hedberg * avoid calling the callback more than once if 527853e21fbcSJohan Hedberg * this function gets called again. 527953e21fbcSJohan Hedberg */ 528053e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 528153e21fbcSJohan Hedberg 52829238f36aSJohan Hedberg goto call_complete; 52839238f36aSJohan Hedberg } 528453e21fbcSJohan Hedberg } 52859238f36aSJohan Hedberg 52869238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 52879238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 52889238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 52899238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 52909238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 52919238f36aSJohan Hedberg break; 52929238f36aSJohan Hedberg } 52939238f36aSJohan Hedberg 52949238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 52959238f36aSJohan Hedberg kfree_skb(skb); 52969238f36aSJohan Hedberg } 52979238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 52989238f36aSJohan Hedberg 52999238f36aSJohan Hedberg call_complete: 53009238f36aSJohan Hedberg if (req_complete) 53019238f36aSJohan Hedberg req_complete(hdev, status); 53029238f36aSJohan Hedberg } 53039238f36aSJohan Hedberg 5304b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 53051da177e4SLinus Torvalds { 5306b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 53071da177e4SLinus Torvalds struct sk_buff *skb; 53081da177e4SLinus Torvalds 53091da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 53101da177e4SLinus Torvalds 53111da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 5312cd82e61cSMarcel Holtmann /* Send copy to monitor */ 5313cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 5314cd82e61cSMarcel Holtmann 53151da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 53161da177e4SLinus Torvalds /* Send copy to the sockets */ 5317470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 53181da177e4SLinus Torvalds } 53191da177e4SLinus Torvalds 5320fee746b0SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 53211da177e4SLinus Torvalds kfree_skb(skb); 53221da177e4SLinus Torvalds continue; 53231da177e4SLinus Torvalds } 53241da177e4SLinus Torvalds 53251da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 53261da177e4SLinus Torvalds /* Don't process data packets in this states. */ 53270d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 53281da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 53291da177e4SLinus Torvalds case HCI_SCODATA_PKT: 53301da177e4SLinus Torvalds kfree_skb(skb); 53311da177e4SLinus Torvalds continue; 53323ff50b79SStephen Hemminger } 53331da177e4SLinus Torvalds } 53341da177e4SLinus Torvalds 53351da177e4SLinus Torvalds /* Process frame */ 53360d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 53371da177e4SLinus Torvalds case HCI_EVENT_PKT: 5338b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 53391da177e4SLinus Torvalds hci_event_packet(hdev, skb); 53401da177e4SLinus Torvalds break; 53411da177e4SLinus Torvalds 53421da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 53431da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 53441da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 53451da177e4SLinus Torvalds break; 53461da177e4SLinus Torvalds 53471da177e4SLinus Torvalds case HCI_SCODATA_PKT: 53481da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 53491da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 53501da177e4SLinus Torvalds break; 53511da177e4SLinus Torvalds 53521da177e4SLinus Torvalds default: 53531da177e4SLinus Torvalds kfree_skb(skb); 53541da177e4SLinus Torvalds break; 53551da177e4SLinus Torvalds } 53561da177e4SLinus Torvalds } 53571da177e4SLinus Torvalds } 53581da177e4SLinus Torvalds 5359c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 53601da177e4SLinus Torvalds { 5361c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 53621da177e4SLinus Torvalds struct sk_buff *skb; 53631da177e4SLinus Torvalds 53642104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 53652104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 53661da177e4SLinus Torvalds 53671da177e4SLinus Torvalds /* Send queued commands */ 53685a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 53695a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 53705a08ecceSAndrei Emeltchenko if (!skb) 53715a08ecceSAndrei Emeltchenko return; 53725a08ecceSAndrei Emeltchenko 53731da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 53741da177e4SLinus Torvalds 5375a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 537670f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 53771da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 537857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 53797bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 538065cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 53817bdb8a5cSSzymon Janc else 538265cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 538365cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 53841da177e4SLinus Torvalds } else { 53851da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 5386c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 53871da177e4SLinus Torvalds } 53881da177e4SLinus Torvalds } 53891da177e4SLinus Torvalds } 5390b1efcc28SAndre Guedes 5391b1efcc28SAndre Guedes void hci_req_add_le_scan_disable(struct hci_request *req) 5392b1efcc28SAndre Guedes { 5393b1efcc28SAndre Guedes struct hci_cp_le_set_scan_enable cp; 5394b1efcc28SAndre Guedes 5395b1efcc28SAndre Guedes memset(&cp, 0, sizeof(cp)); 5396b1efcc28SAndre Guedes cp.enable = LE_SCAN_DISABLE; 5397b1efcc28SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 5398b1efcc28SAndre Guedes } 5399a4790dbdSAndre Guedes 54008ef30fd3SAndre Guedes void hci_req_add_le_passive_scan(struct hci_request *req) 54018ef30fd3SAndre Guedes { 54028ef30fd3SAndre Guedes struct hci_cp_le_set_scan_param param_cp; 54038ef30fd3SAndre Guedes struct hci_cp_le_set_scan_enable enable_cp; 54048ef30fd3SAndre Guedes struct hci_dev *hdev = req->hdev; 54058ef30fd3SAndre Guedes u8 own_addr_type; 54068ef30fd3SAndre Guedes 54076ab535a7SMarcel Holtmann /* Set require_privacy to false since no SCAN_REQ are send 54086ab535a7SMarcel Holtmann * during passive scanning. Not using an unresolvable address 54096ab535a7SMarcel Holtmann * here is important so that peer devices using direct 54106ab535a7SMarcel Holtmann * advertising with our address will be correctly reported 54116ab535a7SMarcel Holtmann * by the controller. 54128ef30fd3SAndre Guedes */ 54136ab535a7SMarcel Holtmann if (hci_update_random_address(req, false, &own_addr_type)) 54148ef30fd3SAndre Guedes return; 54158ef30fd3SAndre Guedes 54168ef30fd3SAndre Guedes memset(¶m_cp, 0, sizeof(param_cp)); 54178ef30fd3SAndre Guedes param_cp.type = LE_SCAN_PASSIVE; 54188ef30fd3SAndre Guedes param_cp.interval = cpu_to_le16(hdev->le_scan_interval); 54198ef30fd3SAndre Guedes param_cp.window = cpu_to_le16(hdev->le_scan_window); 54208ef30fd3SAndre Guedes param_cp.own_address_type = own_addr_type; 54218ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_PARAM, sizeof(param_cp), 54228ef30fd3SAndre Guedes ¶m_cp); 54238ef30fd3SAndre Guedes 54248ef30fd3SAndre Guedes memset(&enable_cp, 0, sizeof(enable_cp)); 54258ef30fd3SAndre Guedes enable_cp.enable = LE_SCAN_ENABLE; 54264340a124SAndre Guedes enable_cp.filter_dup = LE_SCAN_FILTER_DUP_ENABLE; 54278ef30fd3SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(enable_cp), 54288ef30fd3SAndre Guedes &enable_cp); 54298ef30fd3SAndre Guedes } 54308ef30fd3SAndre Guedes 5431a4790dbdSAndre Guedes static void update_background_scan_complete(struct hci_dev *hdev, u8 status) 5432a4790dbdSAndre Guedes { 5433a4790dbdSAndre Guedes if (status) 5434a4790dbdSAndre Guedes BT_DBG("HCI request failed to update background scanning: " 5435a4790dbdSAndre Guedes "status 0x%2.2x", status); 5436a4790dbdSAndre Guedes } 5437a4790dbdSAndre Guedes 5438a4790dbdSAndre Guedes /* This function controls the background scanning based on hdev->pend_le_conns 5439a4790dbdSAndre Guedes * list. If there are pending LE connection we start the background scanning, 5440a4790dbdSAndre Guedes * otherwise we stop it. 5441a4790dbdSAndre Guedes * 5442a4790dbdSAndre Guedes * This function requires the caller holds hdev->lock. 5443a4790dbdSAndre Guedes */ 5444a4790dbdSAndre Guedes void hci_update_background_scan(struct hci_dev *hdev) 5445a4790dbdSAndre Guedes { 5446a4790dbdSAndre Guedes struct hci_request req; 5447a4790dbdSAndre Guedes struct hci_conn *conn; 5448a4790dbdSAndre Guedes int err; 5449a4790dbdSAndre Guedes 5450c20c02d5SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags) || 5451c20c02d5SMarcel Holtmann test_bit(HCI_INIT, &hdev->flags) || 5452c20c02d5SMarcel Holtmann test_bit(HCI_SETUP, &hdev->dev_flags) || 5453d603b76bSMarcel Holtmann test_bit(HCI_CONFIG, &hdev->dev_flags) || 5454b8221770SMarcel Holtmann test_bit(HCI_AUTO_OFF, &hdev->dev_flags) || 5455c20c02d5SMarcel Holtmann test_bit(HCI_UNREGISTER, &hdev->dev_flags)) 54561c1697c0SMarcel Holtmann return; 54571c1697c0SMarcel Holtmann 5458a70f4b5fSJohan Hedberg /* No point in doing scanning if LE support hasn't been enabled */ 5459a70f4b5fSJohan Hedberg if (!test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 5460a70f4b5fSJohan Hedberg return; 5461a70f4b5fSJohan Hedberg 5462ae23ada4SJohan Hedberg /* If discovery is active don't interfere with it */ 5463ae23ada4SJohan Hedberg if (hdev->discovery.state != DISCOVERY_STOPPED) 5464ae23ada4SJohan Hedberg return; 5465ae23ada4SJohan Hedberg 5466a4790dbdSAndre Guedes hci_req_init(&req, hdev); 5467a4790dbdSAndre Guedes 5468d1d588c1SJohan Hedberg if (list_empty(&hdev->pend_le_conns) && 546966f8455aSJohan Hedberg list_empty(&hdev->pend_le_reports)) { 54700d2bf134SJohan Hedberg /* If there is no pending LE connections or devices 54710d2bf134SJohan Hedberg * to be scanned for, we should stop the background 54720d2bf134SJohan Hedberg * scanning. 5473a4790dbdSAndre Guedes */ 5474a4790dbdSAndre Guedes 5475a4790dbdSAndre Guedes /* If controller is not scanning we are done. */ 5476a4790dbdSAndre Guedes if (!test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 5477a4790dbdSAndre Guedes return; 5478a4790dbdSAndre Guedes 5479a4790dbdSAndre Guedes hci_req_add_le_scan_disable(&req); 5480a4790dbdSAndre Guedes 5481a4790dbdSAndre Guedes BT_DBG("%s stopping background scanning", hdev->name); 5482a4790dbdSAndre Guedes } else { 5483a4790dbdSAndre Guedes /* If there is at least one pending LE connection, we should 5484a4790dbdSAndre Guedes * keep the background scan running. 5485a4790dbdSAndre Guedes */ 5486a4790dbdSAndre Guedes 5487a4790dbdSAndre Guedes /* If controller is connecting, we should not start scanning 5488a4790dbdSAndre Guedes * since some controllers are not able to scan and connect at 5489a4790dbdSAndre Guedes * the same time. 5490a4790dbdSAndre Guedes */ 5491a4790dbdSAndre Guedes conn = hci_conn_hash_lookup_state(hdev, LE_LINK, BT_CONNECT); 5492a4790dbdSAndre Guedes if (conn) 5493a4790dbdSAndre Guedes return; 5494a4790dbdSAndre Guedes 54954340a124SAndre Guedes /* If controller is currently scanning, we stop it to ensure we 54964340a124SAndre Guedes * don't miss any advertising (due to duplicates filter). 54974340a124SAndre Guedes */ 54984340a124SAndre Guedes if (test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 54994340a124SAndre Guedes hci_req_add_le_scan_disable(&req); 55004340a124SAndre Guedes 55018ef30fd3SAndre Guedes hci_req_add_le_passive_scan(&req); 5502a4790dbdSAndre Guedes 5503a4790dbdSAndre Guedes BT_DBG("%s starting background scanning", hdev->name); 5504a4790dbdSAndre Guedes } 5505a4790dbdSAndre Guedes 5506a4790dbdSAndre Guedes err = hci_req_run(&req, update_background_scan_complete); 5507a4790dbdSAndre Guedes if (err) 5508a4790dbdSAndre Guedes BT_ERR("Failed to run HCI request: err %d", err); 5509a4790dbdSAndre Guedes } 5510