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> 3247219839SMarcel Holtmann #include <asm/unaligned.h> 331da177e4SLinus Torvalds 341da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 351da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 361da177e4SLinus Torvalds 37b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work); 38c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work); 393eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work); 401da177e4SLinus Torvalds 411da177e4SLinus Torvalds /* HCI device list */ 421da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 431da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 441da177e4SLinus Torvalds 451da177e4SLinus Torvalds /* HCI callback list */ 461da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 471da177e4SLinus Torvalds DEFINE_RWLOCK(hci_cb_list_lock); 481da177e4SLinus Torvalds 493df92b31SSasha Levin /* HCI ID Numbering */ 503df92b31SSasha Levin static DEFINE_IDA(hci_index_ida); 513df92b31SSasha Levin 521da177e4SLinus Torvalds /* ---- HCI notifications ---- */ 531da177e4SLinus Torvalds 546516455dSMarcel Holtmann static void hci_notify(struct hci_dev *hdev, int event) 551da177e4SLinus Torvalds { 56040030efSMarcel Holtmann hci_sock_dev_event(hdev, event); 571da177e4SLinus Torvalds } 581da177e4SLinus Torvalds 59baf27f6eSMarcel Holtmann /* ---- HCI debugfs entries ---- */ 60baf27f6eSMarcel Holtmann 614b4148e9SMarcel Holtmann static ssize_t dut_mode_read(struct file *file, char __user *user_buf, 624b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 634b4148e9SMarcel Holtmann { 644b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 654b4148e9SMarcel Holtmann char buf[3]; 664b4148e9SMarcel Holtmann 674b4148e9SMarcel Holtmann buf[0] = test_bit(HCI_DUT_MODE, &hdev->dev_flags) ? 'Y': 'N'; 684b4148e9SMarcel Holtmann buf[1] = '\n'; 694b4148e9SMarcel Holtmann buf[2] = '\0'; 704b4148e9SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 714b4148e9SMarcel Holtmann } 724b4148e9SMarcel Holtmann 734b4148e9SMarcel Holtmann static ssize_t dut_mode_write(struct file *file, const char __user *user_buf, 744b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 754b4148e9SMarcel Holtmann { 764b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 774b4148e9SMarcel Holtmann struct sk_buff *skb; 784b4148e9SMarcel Holtmann char buf[32]; 794b4148e9SMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 804b4148e9SMarcel Holtmann bool enable; 814b4148e9SMarcel Holtmann int err; 824b4148e9SMarcel Holtmann 834b4148e9SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 844b4148e9SMarcel Holtmann return -ENETDOWN; 854b4148e9SMarcel Holtmann 864b4148e9SMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 874b4148e9SMarcel Holtmann return -EFAULT; 884b4148e9SMarcel Holtmann 894b4148e9SMarcel Holtmann buf[buf_size] = '\0'; 904b4148e9SMarcel Holtmann if (strtobool(buf, &enable)) 914b4148e9SMarcel Holtmann return -EINVAL; 924b4148e9SMarcel Holtmann 934b4148e9SMarcel Holtmann if (enable == test_bit(HCI_DUT_MODE, &hdev->dev_flags)) 944b4148e9SMarcel Holtmann return -EALREADY; 954b4148e9SMarcel Holtmann 964b4148e9SMarcel Holtmann hci_req_lock(hdev); 974b4148e9SMarcel Holtmann if (enable) 984b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_ENABLE_DUT_MODE, 0, NULL, 994b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 1004b4148e9SMarcel Holtmann else 1014b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, 1024b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 1034b4148e9SMarcel Holtmann hci_req_unlock(hdev); 1044b4148e9SMarcel Holtmann 1054b4148e9SMarcel Holtmann if (IS_ERR(skb)) 1064b4148e9SMarcel Holtmann return PTR_ERR(skb); 1074b4148e9SMarcel Holtmann 1084b4148e9SMarcel Holtmann err = -bt_to_errno(skb->data[0]); 1094b4148e9SMarcel Holtmann kfree_skb(skb); 1104b4148e9SMarcel Holtmann 1114b4148e9SMarcel Holtmann if (err < 0) 1124b4148e9SMarcel Holtmann return err; 1134b4148e9SMarcel Holtmann 1144b4148e9SMarcel Holtmann change_bit(HCI_DUT_MODE, &hdev->dev_flags); 1154b4148e9SMarcel Holtmann 1164b4148e9SMarcel Holtmann return count; 1174b4148e9SMarcel Holtmann } 1184b4148e9SMarcel Holtmann 1194b4148e9SMarcel Holtmann static const struct file_operations dut_mode_fops = { 1204b4148e9SMarcel Holtmann .open = simple_open, 1214b4148e9SMarcel Holtmann .read = dut_mode_read, 1224b4148e9SMarcel Holtmann .write = dut_mode_write, 1234b4148e9SMarcel Holtmann .llseek = default_llseek, 1244b4148e9SMarcel Holtmann }; 1254b4148e9SMarcel Holtmann 126dfb826a8SMarcel Holtmann static int features_show(struct seq_file *f, void *ptr) 127dfb826a8SMarcel Holtmann { 128dfb826a8SMarcel Holtmann struct hci_dev *hdev = f->private; 129dfb826a8SMarcel Holtmann u8 p; 130dfb826a8SMarcel Holtmann 131dfb826a8SMarcel Holtmann hci_dev_lock(hdev); 132dfb826a8SMarcel Holtmann for (p = 0; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 133cfbb2b5bSMarcel Holtmann seq_printf(f, "%2u: 0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x " 134dfb826a8SMarcel Holtmann "0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x\n", p, 135dfb826a8SMarcel Holtmann hdev->features[p][0], hdev->features[p][1], 136dfb826a8SMarcel Holtmann hdev->features[p][2], hdev->features[p][3], 137dfb826a8SMarcel Holtmann hdev->features[p][4], hdev->features[p][5], 138dfb826a8SMarcel Holtmann hdev->features[p][6], hdev->features[p][7]); 139dfb826a8SMarcel Holtmann } 140cfbb2b5bSMarcel Holtmann if (lmp_le_capable(hdev)) 141cfbb2b5bSMarcel Holtmann seq_printf(f, "LE: 0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x " 142cfbb2b5bSMarcel Holtmann "0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x\n", 143cfbb2b5bSMarcel Holtmann hdev->le_features[0], hdev->le_features[1], 144cfbb2b5bSMarcel Holtmann hdev->le_features[2], hdev->le_features[3], 145cfbb2b5bSMarcel Holtmann hdev->le_features[4], hdev->le_features[5], 146cfbb2b5bSMarcel Holtmann hdev->le_features[6], hdev->le_features[7]); 147dfb826a8SMarcel Holtmann hci_dev_unlock(hdev); 148dfb826a8SMarcel Holtmann 149dfb826a8SMarcel Holtmann return 0; 150dfb826a8SMarcel Holtmann } 151dfb826a8SMarcel Holtmann 152dfb826a8SMarcel Holtmann static int features_open(struct inode *inode, struct file *file) 153dfb826a8SMarcel Holtmann { 154dfb826a8SMarcel Holtmann return single_open(file, features_show, inode->i_private); 155dfb826a8SMarcel Holtmann } 156dfb826a8SMarcel Holtmann 157dfb826a8SMarcel Holtmann static const struct file_operations features_fops = { 158dfb826a8SMarcel Holtmann .open = features_open, 159dfb826a8SMarcel Holtmann .read = seq_read, 160dfb826a8SMarcel Holtmann .llseek = seq_lseek, 161dfb826a8SMarcel Holtmann .release = single_release, 162dfb826a8SMarcel Holtmann }; 163dfb826a8SMarcel Holtmann 16470afe0b8SMarcel Holtmann static int blacklist_show(struct seq_file *f, void *p) 16570afe0b8SMarcel Holtmann { 16670afe0b8SMarcel Holtmann struct hci_dev *hdev = f->private; 16770afe0b8SMarcel Holtmann struct bdaddr_list *b; 16870afe0b8SMarcel Holtmann 16970afe0b8SMarcel Holtmann hci_dev_lock(hdev); 17070afe0b8SMarcel Holtmann list_for_each_entry(b, &hdev->blacklist, list) 171b25f0785SMarcel Holtmann seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 17270afe0b8SMarcel Holtmann hci_dev_unlock(hdev); 17370afe0b8SMarcel Holtmann 17470afe0b8SMarcel Holtmann return 0; 17570afe0b8SMarcel Holtmann } 17670afe0b8SMarcel Holtmann 17770afe0b8SMarcel Holtmann static int blacklist_open(struct inode *inode, struct file *file) 17870afe0b8SMarcel Holtmann { 17970afe0b8SMarcel Holtmann return single_open(file, blacklist_show, inode->i_private); 18070afe0b8SMarcel Holtmann } 18170afe0b8SMarcel Holtmann 18270afe0b8SMarcel Holtmann static const struct file_operations blacklist_fops = { 18370afe0b8SMarcel Holtmann .open = blacklist_open, 18470afe0b8SMarcel Holtmann .read = seq_read, 18570afe0b8SMarcel Holtmann .llseek = seq_lseek, 18670afe0b8SMarcel Holtmann .release = single_release, 18770afe0b8SMarcel Holtmann }; 18870afe0b8SMarcel Holtmann 18947219839SMarcel Holtmann static int uuids_show(struct seq_file *f, void *p) 19047219839SMarcel Holtmann { 19147219839SMarcel Holtmann struct hci_dev *hdev = f->private; 19247219839SMarcel Holtmann struct bt_uuid *uuid; 19347219839SMarcel Holtmann 19447219839SMarcel Holtmann hci_dev_lock(hdev); 19547219839SMarcel Holtmann list_for_each_entry(uuid, &hdev->uuids, list) { 19647219839SMarcel Holtmann u32 data0, data5; 19747219839SMarcel Holtmann u16 data1, data2, data3, data4; 19847219839SMarcel Holtmann 19947219839SMarcel Holtmann data5 = get_unaligned_le32(uuid); 20047219839SMarcel Holtmann data4 = get_unaligned_le16(uuid + 4); 20147219839SMarcel Holtmann data3 = get_unaligned_le16(uuid + 6); 20247219839SMarcel Holtmann data2 = get_unaligned_le16(uuid + 8); 20347219839SMarcel Holtmann data1 = get_unaligned_le16(uuid + 10); 20447219839SMarcel Holtmann data0 = get_unaligned_le32(uuid + 12); 20547219839SMarcel Holtmann 20647219839SMarcel Holtmann seq_printf(f, "%.8x-%.4x-%.4x-%.4x-%.4x%.8x\n", 20747219839SMarcel Holtmann data0, data1, data2, data3, data4, data5); 20847219839SMarcel Holtmann } 20947219839SMarcel Holtmann hci_dev_unlock(hdev); 21047219839SMarcel Holtmann 21147219839SMarcel Holtmann return 0; 21247219839SMarcel Holtmann } 21347219839SMarcel Holtmann 21447219839SMarcel Holtmann static int uuids_open(struct inode *inode, struct file *file) 21547219839SMarcel Holtmann { 21647219839SMarcel Holtmann return single_open(file, uuids_show, inode->i_private); 21747219839SMarcel Holtmann } 21847219839SMarcel Holtmann 21947219839SMarcel Holtmann static const struct file_operations uuids_fops = { 22047219839SMarcel Holtmann .open = uuids_open, 22147219839SMarcel Holtmann .read = seq_read, 22247219839SMarcel Holtmann .llseek = seq_lseek, 22347219839SMarcel Holtmann .release = single_release, 22447219839SMarcel Holtmann }; 22547219839SMarcel Holtmann 226baf27f6eSMarcel Holtmann static int inquiry_cache_show(struct seq_file *f, void *p) 227baf27f6eSMarcel Holtmann { 228baf27f6eSMarcel Holtmann struct hci_dev *hdev = f->private; 229baf27f6eSMarcel Holtmann struct discovery_state *cache = &hdev->discovery; 230baf27f6eSMarcel Holtmann struct inquiry_entry *e; 231baf27f6eSMarcel Holtmann 232baf27f6eSMarcel Holtmann hci_dev_lock(hdev); 233baf27f6eSMarcel Holtmann 234baf27f6eSMarcel Holtmann list_for_each_entry(e, &cache->all, all) { 235baf27f6eSMarcel Holtmann struct inquiry_data *data = &e->data; 236baf27f6eSMarcel Holtmann seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n", 237baf27f6eSMarcel Holtmann &data->bdaddr, 238baf27f6eSMarcel Holtmann data->pscan_rep_mode, data->pscan_period_mode, 239baf27f6eSMarcel Holtmann data->pscan_mode, data->dev_class[2], 240baf27f6eSMarcel Holtmann data->dev_class[1], data->dev_class[0], 241baf27f6eSMarcel Holtmann __le16_to_cpu(data->clock_offset), 242baf27f6eSMarcel Holtmann data->rssi, data->ssp_mode, e->timestamp); 243baf27f6eSMarcel Holtmann } 244baf27f6eSMarcel Holtmann 245baf27f6eSMarcel Holtmann hci_dev_unlock(hdev); 246baf27f6eSMarcel Holtmann 247baf27f6eSMarcel Holtmann return 0; 248baf27f6eSMarcel Holtmann } 249baf27f6eSMarcel Holtmann 250baf27f6eSMarcel Holtmann static int inquiry_cache_open(struct inode *inode, struct file *file) 251baf27f6eSMarcel Holtmann { 252baf27f6eSMarcel Holtmann return single_open(file, inquiry_cache_show, inode->i_private); 253baf27f6eSMarcel Holtmann } 254baf27f6eSMarcel Holtmann 255baf27f6eSMarcel Holtmann static const struct file_operations inquiry_cache_fops = { 256baf27f6eSMarcel Holtmann .open = inquiry_cache_open, 257baf27f6eSMarcel Holtmann .read = seq_read, 258baf27f6eSMarcel Holtmann .llseek = seq_lseek, 259baf27f6eSMarcel Holtmann .release = single_release, 260baf27f6eSMarcel Holtmann }; 261baf27f6eSMarcel Holtmann 26202d08d15SMarcel Holtmann static int link_keys_show(struct seq_file *f, void *ptr) 26302d08d15SMarcel Holtmann { 26402d08d15SMarcel Holtmann struct hci_dev *hdev = f->private; 26502d08d15SMarcel Holtmann struct list_head *p, *n; 26602d08d15SMarcel Holtmann 26702d08d15SMarcel Holtmann hci_dev_lock(hdev); 26802d08d15SMarcel Holtmann list_for_each_safe(p, n, &hdev->link_keys) { 26902d08d15SMarcel Holtmann struct link_key *key = list_entry(p, struct link_key, list); 27002d08d15SMarcel Holtmann seq_printf(f, "%pMR %u %*phN %u\n", &key->bdaddr, key->type, 27102d08d15SMarcel Holtmann HCI_LINK_KEY_SIZE, key->val, key->pin_len); 27202d08d15SMarcel Holtmann } 27302d08d15SMarcel Holtmann hci_dev_unlock(hdev); 27402d08d15SMarcel Holtmann 27502d08d15SMarcel Holtmann return 0; 27602d08d15SMarcel Holtmann } 27702d08d15SMarcel Holtmann 27802d08d15SMarcel Holtmann static int link_keys_open(struct inode *inode, struct file *file) 27902d08d15SMarcel Holtmann { 28002d08d15SMarcel Holtmann return single_open(file, link_keys_show, inode->i_private); 28102d08d15SMarcel Holtmann } 28202d08d15SMarcel Holtmann 28302d08d15SMarcel Holtmann static const struct file_operations link_keys_fops = { 28402d08d15SMarcel Holtmann .open = link_keys_open, 28502d08d15SMarcel Holtmann .read = seq_read, 28602d08d15SMarcel Holtmann .llseek = seq_lseek, 28702d08d15SMarcel Holtmann .release = single_release, 28802d08d15SMarcel Holtmann }; 28902d08d15SMarcel Holtmann 29012c269d7SMarcel Holtmann static ssize_t use_debug_keys_read(struct file *file, char __user *user_buf, 29112c269d7SMarcel Holtmann size_t count, loff_t *ppos) 29212c269d7SMarcel Holtmann { 29312c269d7SMarcel Holtmann struct hci_dev *hdev = file->private_data; 29412c269d7SMarcel Holtmann char buf[3]; 29512c269d7SMarcel Holtmann 29612c269d7SMarcel Holtmann buf[0] = test_bit(HCI_DEBUG_KEYS, &hdev->dev_flags) ? 'Y': 'N'; 29712c269d7SMarcel Holtmann buf[1] = '\n'; 29812c269d7SMarcel Holtmann buf[2] = '\0'; 29912c269d7SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 30012c269d7SMarcel Holtmann } 30112c269d7SMarcel Holtmann 30212c269d7SMarcel Holtmann static const struct file_operations use_debug_keys_fops = { 30312c269d7SMarcel Holtmann .open = simple_open, 30412c269d7SMarcel Holtmann .read = use_debug_keys_read, 30512c269d7SMarcel Holtmann .llseek = default_llseek, 30612c269d7SMarcel Holtmann }; 30712c269d7SMarcel Holtmann 308babdbb3cSMarcel Holtmann static int dev_class_show(struct seq_file *f, void *ptr) 309babdbb3cSMarcel Holtmann { 310babdbb3cSMarcel Holtmann struct hci_dev *hdev = f->private; 311babdbb3cSMarcel Holtmann 312babdbb3cSMarcel Holtmann hci_dev_lock(hdev); 313babdbb3cSMarcel Holtmann seq_printf(f, "0x%.2x%.2x%.2x\n", hdev->dev_class[2], 314babdbb3cSMarcel Holtmann hdev->dev_class[1], hdev->dev_class[0]); 315babdbb3cSMarcel Holtmann hci_dev_unlock(hdev); 316babdbb3cSMarcel Holtmann 317babdbb3cSMarcel Holtmann return 0; 318babdbb3cSMarcel Holtmann } 319babdbb3cSMarcel Holtmann 320babdbb3cSMarcel Holtmann static int dev_class_open(struct inode *inode, struct file *file) 321babdbb3cSMarcel Holtmann { 322babdbb3cSMarcel Holtmann return single_open(file, dev_class_show, inode->i_private); 323babdbb3cSMarcel Holtmann } 324babdbb3cSMarcel Holtmann 325babdbb3cSMarcel Holtmann static const struct file_operations dev_class_fops = { 326babdbb3cSMarcel Holtmann .open = dev_class_open, 327babdbb3cSMarcel Holtmann .read = seq_read, 328babdbb3cSMarcel Holtmann .llseek = seq_lseek, 329babdbb3cSMarcel Holtmann .release = single_release, 330babdbb3cSMarcel Holtmann }; 331babdbb3cSMarcel Holtmann 332041000b9SMarcel Holtmann static int voice_setting_get(void *data, u64 *val) 333041000b9SMarcel Holtmann { 334041000b9SMarcel Holtmann struct hci_dev *hdev = data; 335041000b9SMarcel Holtmann 336041000b9SMarcel Holtmann hci_dev_lock(hdev); 337041000b9SMarcel Holtmann *val = hdev->voice_setting; 338041000b9SMarcel Holtmann hci_dev_unlock(hdev); 339041000b9SMarcel Holtmann 340041000b9SMarcel Holtmann return 0; 341041000b9SMarcel Holtmann } 342041000b9SMarcel Holtmann 343041000b9SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get, 344041000b9SMarcel Holtmann NULL, "0x%4.4llx\n"); 345041000b9SMarcel Holtmann 346ebd1e33bSMarcel Holtmann static int auto_accept_delay_set(void *data, u64 val) 347ebd1e33bSMarcel Holtmann { 348ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 349ebd1e33bSMarcel Holtmann 350ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 351ebd1e33bSMarcel Holtmann hdev->auto_accept_delay = val; 352ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 353ebd1e33bSMarcel Holtmann 354ebd1e33bSMarcel Holtmann return 0; 355ebd1e33bSMarcel Holtmann } 356ebd1e33bSMarcel Holtmann 357ebd1e33bSMarcel Holtmann static int auto_accept_delay_get(void *data, u64 *val) 358ebd1e33bSMarcel Holtmann { 359ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 360ebd1e33bSMarcel Holtmann 361ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 362ebd1e33bSMarcel Holtmann *val = hdev->auto_accept_delay; 363ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 364ebd1e33bSMarcel Holtmann 365ebd1e33bSMarcel Holtmann return 0; 366ebd1e33bSMarcel Holtmann } 367ebd1e33bSMarcel Holtmann 368ebd1e33bSMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get, 369ebd1e33bSMarcel Holtmann auto_accept_delay_set, "%llu\n"); 370ebd1e33bSMarcel Holtmann 37106f5b778SMarcel Holtmann static int ssp_debug_mode_set(void *data, u64 val) 37206f5b778SMarcel Holtmann { 37306f5b778SMarcel Holtmann struct hci_dev *hdev = data; 37406f5b778SMarcel Holtmann struct sk_buff *skb; 37506f5b778SMarcel Holtmann __u8 mode; 37606f5b778SMarcel Holtmann int err; 37706f5b778SMarcel Holtmann 37806f5b778SMarcel Holtmann if (val != 0 && val != 1) 37906f5b778SMarcel Holtmann return -EINVAL; 38006f5b778SMarcel Holtmann 38106f5b778SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 38206f5b778SMarcel Holtmann return -ENETDOWN; 38306f5b778SMarcel Holtmann 38406f5b778SMarcel Holtmann hci_req_lock(hdev); 38506f5b778SMarcel Holtmann mode = val; 38606f5b778SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_WRITE_SSP_DEBUG_MODE, sizeof(mode), 38706f5b778SMarcel Holtmann &mode, HCI_CMD_TIMEOUT); 38806f5b778SMarcel Holtmann hci_req_unlock(hdev); 38906f5b778SMarcel Holtmann 39006f5b778SMarcel Holtmann if (IS_ERR(skb)) 39106f5b778SMarcel Holtmann return PTR_ERR(skb); 39206f5b778SMarcel Holtmann 39306f5b778SMarcel Holtmann err = -bt_to_errno(skb->data[0]); 39406f5b778SMarcel Holtmann kfree_skb(skb); 39506f5b778SMarcel Holtmann 39606f5b778SMarcel Holtmann if (err < 0) 39706f5b778SMarcel Holtmann return err; 39806f5b778SMarcel Holtmann 39906f5b778SMarcel Holtmann hci_dev_lock(hdev); 40006f5b778SMarcel Holtmann hdev->ssp_debug_mode = val; 40106f5b778SMarcel Holtmann hci_dev_unlock(hdev); 40206f5b778SMarcel Holtmann 40306f5b778SMarcel Holtmann return 0; 40406f5b778SMarcel Holtmann } 40506f5b778SMarcel Holtmann 40606f5b778SMarcel Holtmann static int ssp_debug_mode_get(void *data, u64 *val) 40706f5b778SMarcel Holtmann { 40806f5b778SMarcel Holtmann struct hci_dev *hdev = data; 40906f5b778SMarcel Holtmann 41006f5b778SMarcel Holtmann hci_dev_lock(hdev); 41106f5b778SMarcel Holtmann *val = hdev->ssp_debug_mode; 41206f5b778SMarcel Holtmann hci_dev_unlock(hdev); 41306f5b778SMarcel Holtmann 41406f5b778SMarcel Holtmann return 0; 41506f5b778SMarcel Holtmann } 41606f5b778SMarcel Holtmann 41706f5b778SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(ssp_debug_mode_fops, ssp_debug_mode_get, 41806f5b778SMarcel Holtmann ssp_debug_mode_set, "%llu\n"); 41906f5b778SMarcel Holtmann 4202bfa3531SMarcel Holtmann static int idle_timeout_set(void *data, u64 val) 4212bfa3531SMarcel Holtmann { 4222bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4232bfa3531SMarcel Holtmann 4242bfa3531SMarcel Holtmann if (val != 0 && (val < 500 || val > 3600000)) 4252bfa3531SMarcel Holtmann return -EINVAL; 4262bfa3531SMarcel Holtmann 4272bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4282bfa3531SMarcel Holtmann hdev->idle_timeout= val; 4292bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4302bfa3531SMarcel Holtmann 4312bfa3531SMarcel Holtmann return 0; 4322bfa3531SMarcel Holtmann } 4332bfa3531SMarcel Holtmann 4342bfa3531SMarcel Holtmann static int idle_timeout_get(void *data, u64 *val) 4352bfa3531SMarcel Holtmann { 4362bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4372bfa3531SMarcel Holtmann 4382bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4392bfa3531SMarcel Holtmann *val = hdev->idle_timeout; 4402bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4412bfa3531SMarcel Holtmann 4422bfa3531SMarcel Holtmann return 0; 4432bfa3531SMarcel Holtmann } 4442bfa3531SMarcel Holtmann 4452bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get, 4462bfa3531SMarcel Holtmann idle_timeout_set, "%llu\n"); 4472bfa3531SMarcel Holtmann 4482bfa3531SMarcel Holtmann static int sniff_min_interval_set(void *data, u64 val) 4492bfa3531SMarcel Holtmann { 4502bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4512bfa3531SMarcel Holtmann 4522bfa3531SMarcel Holtmann if (val == 0 || val % 2 || val > hdev->sniff_max_interval) 4532bfa3531SMarcel Holtmann return -EINVAL; 4542bfa3531SMarcel Holtmann 4552bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4562bfa3531SMarcel Holtmann hdev->sniff_min_interval= val; 4572bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4582bfa3531SMarcel Holtmann 4592bfa3531SMarcel Holtmann return 0; 4602bfa3531SMarcel Holtmann } 4612bfa3531SMarcel Holtmann 4622bfa3531SMarcel Holtmann static int sniff_min_interval_get(void *data, u64 *val) 4632bfa3531SMarcel Holtmann { 4642bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4652bfa3531SMarcel Holtmann 4662bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4672bfa3531SMarcel Holtmann *val = hdev->sniff_min_interval; 4682bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4692bfa3531SMarcel Holtmann 4702bfa3531SMarcel Holtmann return 0; 4712bfa3531SMarcel Holtmann } 4722bfa3531SMarcel Holtmann 4732bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get, 4742bfa3531SMarcel Holtmann sniff_min_interval_set, "%llu\n"); 4752bfa3531SMarcel Holtmann 4762bfa3531SMarcel Holtmann static int sniff_max_interval_set(void *data, u64 val) 4772bfa3531SMarcel Holtmann { 4782bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4792bfa3531SMarcel Holtmann 4802bfa3531SMarcel Holtmann if (val == 0 || val % 2 || val < hdev->sniff_min_interval) 4812bfa3531SMarcel Holtmann return -EINVAL; 4822bfa3531SMarcel Holtmann 4832bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4842bfa3531SMarcel Holtmann hdev->sniff_max_interval= val; 4852bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4862bfa3531SMarcel Holtmann 4872bfa3531SMarcel Holtmann return 0; 4882bfa3531SMarcel Holtmann } 4892bfa3531SMarcel Holtmann 4902bfa3531SMarcel Holtmann static int sniff_max_interval_get(void *data, u64 *val) 4912bfa3531SMarcel Holtmann { 4922bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 4932bfa3531SMarcel Holtmann 4942bfa3531SMarcel Holtmann hci_dev_lock(hdev); 4952bfa3531SMarcel Holtmann *val = hdev->sniff_max_interval; 4962bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 4972bfa3531SMarcel Holtmann 4982bfa3531SMarcel Holtmann return 0; 4992bfa3531SMarcel Holtmann } 5002bfa3531SMarcel Holtmann 5012bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get, 5022bfa3531SMarcel Holtmann sniff_max_interval_set, "%llu\n"); 5032bfa3531SMarcel Holtmann 504e7b8fc92SMarcel Holtmann static int static_address_show(struct seq_file *f, void *p) 505e7b8fc92SMarcel Holtmann { 506e7b8fc92SMarcel Holtmann struct hci_dev *hdev = f->private; 507e7b8fc92SMarcel Holtmann 508e7b8fc92SMarcel Holtmann hci_dev_lock(hdev); 509e7b8fc92SMarcel Holtmann seq_printf(f, "%pMR\n", &hdev->static_addr); 510e7b8fc92SMarcel Holtmann hci_dev_unlock(hdev); 511e7b8fc92SMarcel Holtmann 512e7b8fc92SMarcel Holtmann return 0; 513e7b8fc92SMarcel Holtmann } 514e7b8fc92SMarcel Holtmann 515e7b8fc92SMarcel Holtmann static int static_address_open(struct inode *inode, struct file *file) 516e7b8fc92SMarcel Holtmann { 517e7b8fc92SMarcel Holtmann return single_open(file, static_address_show, inode->i_private); 518e7b8fc92SMarcel Holtmann } 519e7b8fc92SMarcel Holtmann 520e7b8fc92SMarcel Holtmann static const struct file_operations static_address_fops = { 521e7b8fc92SMarcel Holtmann .open = static_address_open, 522e7b8fc92SMarcel Holtmann .read = seq_read, 523e7b8fc92SMarcel Holtmann .llseek = seq_lseek, 524e7b8fc92SMarcel Holtmann .release = single_release, 525e7b8fc92SMarcel Holtmann }; 526e7b8fc92SMarcel Holtmann 52792202185SMarcel Holtmann static int own_address_type_set(void *data, u64 val) 52892202185SMarcel Holtmann { 52992202185SMarcel Holtmann struct hci_dev *hdev = data; 53092202185SMarcel Holtmann 53192202185SMarcel Holtmann if (val != 0 && val != 1) 53292202185SMarcel Holtmann return -EINVAL; 53392202185SMarcel Holtmann 53492202185SMarcel Holtmann hci_dev_lock(hdev); 53592202185SMarcel Holtmann hdev->own_addr_type = val; 53692202185SMarcel Holtmann hci_dev_unlock(hdev); 53792202185SMarcel Holtmann 53892202185SMarcel Holtmann return 0; 53992202185SMarcel Holtmann } 54092202185SMarcel Holtmann 54192202185SMarcel Holtmann static int own_address_type_get(void *data, u64 *val) 54292202185SMarcel Holtmann { 54392202185SMarcel Holtmann struct hci_dev *hdev = data; 54492202185SMarcel Holtmann 54592202185SMarcel Holtmann hci_dev_lock(hdev); 54692202185SMarcel Holtmann *val = hdev->own_addr_type; 54792202185SMarcel Holtmann hci_dev_unlock(hdev); 54892202185SMarcel Holtmann 54992202185SMarcel Holtmann return 0; 55092202185SMarcel Holtmann } 55192202185SMarcel Holtmann 55292202185SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(own_address_type_fops, own_address_type_get, 55392202185SMarcel Holtmann own_address_type_set, "%llu\n"); 55492202185SMarcel Holtmann 5558f8625cdSMarcel Holtmann static int long_term_keys_show(struct seq_file *f, void *ptr) 5568f8625cdSMarcel Holtmann { 5578f8625cdSMarcel Holtmann struct hci_dev *hdev = f->private; 5588f8625cdSMarcel Holtmann struct list_head *p, *n; 5598f8625cdSMarcel Holtmann 5608f8625cdSMarcel Holtmann hci_dev_lock(hdev); 5618f8625cdSMarcel Holtmann list_for_each_safe(p, n, &hdev->link_keys) { 5628f8625cdSMarcel Holtmann struct smp_ltk *ltk = list_entry(p, struct smp_ltk, list); 5638f8625cdSMarcel Holtmann seq_printf(f, "%pMR (type %u) %u %u %u %.4x %*phN %*phN\\n", 5648f8625cdSMarcel Holtmann <k->bdaddr, ltk->bdaddr_type, ltk->authenticated, 5658f8625cdSMarcel Holtmann ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv), 5668f8625cdSMarcel Holtmann 8, ltk->rand, 16, ltk->val); 5678f8625cdSMarcel Holtmann } 5688f8625cdSMarcel Holtmann hci_dev_unlock(hdev); 5698f8625cdSMarcel Holtmann 5708f8625cdSMarcel Holtmann return 0; 5718f8625cdSMarcel Holtmann } 5728f8625cdSMarcel Holtmann 5738f8625cdSMarcel Holtmann static int long_term_keys_open(struct inode *inode, struct file *file) 5748f8625cdSMarcel Holtmann { 5758f8625cdSMarcel Holtmann return single_open(file, long_term_keys_show, inode->i_private); 5768f8625cdSMarcel Holtmann } 5778f8625cdSMarcel Holtmann 5788f8625cdSMarcel Holtmann static const struct file_operations long_term_keys_fops = { 5798f8625cdSMarcel Holtmann .open = long_term_keys_open, 5808f8625cdSMarcel Holtmann .read = seq_read, 5818f8625cdSMarcel Holtmann .llseek = seq_lseek, 5828f8625cdSMarcel Holtmann .release = single_release, 5838f8625cdSMarcel Holtmann }; 5848f8625cdSMarcel Holtmann 5854e70c7e7SMarcel Holtmann static int conn_min_interval_set(void *data, u64 val) 5864e70c7e7SMarcel Holtmann { 5874e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 5884e70c7e7SMarcel Holtmann 5894e70c7e7SMarcel Holtmann if (val < 0x0006 || val > 0x0c80 || val > hdev->le_conn_max_interval) 5904e70c7e7SMarcel Holtmann return -EINVAL; 5914e70c7e7SMarcel Holtmann 5924e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 5934e70c7e7SMarcel Holtmann hdev->le_conn_min_interval= val; 5944e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 5954e70c7e7SMarcel Holtmann 5964e70c7e7SMarcel Holtmann return 0; 5974e70c7e7SMarcel Holtmann } 5984e70c7e7SMarcel Holtmann 5994e70c7e7SMarcel Holtmann static int conn_min_interval_get(void *data, u64 *val) 6004e70c7e7SMarcel Holtmann { 6014e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 6024e70c7e7SMarcel Holtmann 6034e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 6044e70c7e7SMarcel Holtmann *val = hdev->le_conn_min_interval; 6054e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 6064e70c7e7SMarcel Holtmann 6074e70c7e7SMarcel Holtmann return 0; 6084e70c7e7SMarcel Holtmann } 6094e70c7e7SMarcel Holtmann 6104e70c7e7SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(conn_min_interval_fops, conn_min_interval_get, 6114e70c7e7SMarcel Holtmann conn_min_interval_set, "%llu\n"); 6124e70c7e7SMarcel Holtmann 6134e70c7e7SMarcel Holtmann static int conn_max_interval_set(void *data, u64 val) 6144e70c7e7SMarcel Holtmann { 6154e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 6164e70c7e7SMarcel Holtmann 6174e70c7e7SMarcel Holtmann if (val < 0x0006 || val > 0x0c80 || val < hdev->le_conn_min_interval) 6184e70c7e7SMarcel Holtmann return -EINVAL; 6194e70c7e7SMarcel Holtmann 6204e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 6214e70c7e7SMarcel Holtmann hdev->le_conn_max_interval= val; 6224e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 6234e70c7e7SMarcel Holtmann 6244e70c7e7SMarcel Holtmann return 0; 6254e70c7e7SMarcel Holtmann } 6264e70c7e7SMarcel Holtmann 6274e70c7e7SMarcel Holtmann static int conn_max_interval_get(void *data, u64 *val) 6284e70c7e7SMarcel Holtmann { 6294e70c7e7SMarcel Holtmann struct hci_dev *hdev = data; 6304e70c7e7SMarcel Holtmann 6314e70c7e7SMarcel Holtmann hci_dev_lock(hdev); 6324e70c7e7SMarcel Holtmann *val = hdev->le_conn_max_interval; 6334e70c7e7SMarcel Holtmann hci_dev_unlock(hdev); 6344e70c7e7SMarcel Holtmann 6354e70c7e7SMarcel Holtmann return 0; 6364e70c7e7SMarcel Holtmann } 6374e70c7e7SMarcel Holtmann 6384e70c7e7SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(conn_max_interval_fops, conn_max_interval_get, 6394e70c7e7SMarcel Holtmann conn_max_interval_set, "%llu\n"); 6404e70c7e7SMarcel Holtmann 6411da177e4SLinus Torvalds /* ---- HCI requests ---- */ 6421da177e4SLinus Torvalds 64342c6b129SJohan Hedberg static void hci_req_sync_complete(struct hci_dev *hdev, u8 result) 6441da177e4SLinus Torvalds { 64542c6b129SJohan Hedberg BT_DBG("%s result 0x%2.2x", hdev->name, result); 64675fb0e32SJohan Hedberg 6471da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 6481da177e4SLinus Torvalds hdev->req_result = result; 6491da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 6501da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 6511da177e4SLinus Torvalds } 6521da177e4SLinus Torvalds } 6531da177e4SLinus Torvalds 6541da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 6551da177e4SLinus Torvalds { 6561da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 6571da177e4SLinus Torvalds 6581da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 6591da177e4SLinus Torvalds hdev->req_result = err; 6601da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 6611da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 6621da177e4SLinus Torvalds } 6631da177e4SLinus Torvalds } 6641da177e4SLinus Torvalds 66577a63e0aSFengguang Wu static struct sk_buff *hci_get_cmd_complete(struct hci_dev *hdev, u16 opcode, 66677a63e0aSFengguang Wu u8 event) 66775e84b7cSJohan Hedberg { 66875e84b7cSJohan Hedberg struct hci_ev_cmd_complete *ev; 66975e84b7cSJohan Hedberg struct hci_event_hdr *hdr; 67075e84b7cSJohan Hedberg struct sk_buff *skb; 67175e84b7cSJohan Hedberg 67275e84b7cSJohan Hedberg hci_dev_lock(hdev); 67375e84b7cSJohan Hedberg 67475e84b7cSJohan Hedberg skb = hdev->recv_evt; 67575e84b7cSJohan Hedberg hdev->recv_evt = NULL; 67675e84b7cSJohan Hedberg 67775e84b7cSJohan Hedberg hci_dev_unlock(hdev); 67875e84b7cSJohan Hedberg 67975e84b7cSJohan Hedberg if (!skb) 68075e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 68175e84b7cSJohan Hedberg 68275e84b7cSJohan Hedberg if (skb->len < sizeof(*hdr)) { 68375e84b7cSJohan Hedberg BT_ERR("Too short HCI event"); 68475e84b7cSJohan Hedberg goto failed; 68575e84b7cSJohan Hedberg } 68675e84b7cSJohan Hedberg 68775e84b7cSJohan Hedberg hdr = (void *) skb->data; 68875e84b7cSJohan Hedberg skb_pull(skb, HCI_EVENT_HDR_SIZE); 68975e84b7cSJohan Hedberg 6907b1abbbeSJohan Hedberg if (event) { 6917b1abbbeSJohan Hedberg if (hdr->evt != event) 6927b1abbbeSJohan Hedberg goto failed; 6937b1abbbeSJohan Hedberg return skb; 6947b1abbbeSJohan Hedberg } 6957b1abbbeSJohan Hedberg 69675e84b7cSJohan Hedberg if (hdr->evt != HCI_EV_CMD_COMPLETE) { 69775e84b7cSJohan Hedberg BT_DBG("Last event is not cmd complete (0x%2.2x)", hdr->evt); 69875e84b7cSJohan Hedberg goto failed; 69975e84b7cSJohan Hedberg } 70075e84b7cSJohan Hedberg 70175e84b7cSJohan Hedberg if (skb->len < sizeof(*ev)) { 70275e84b7cSJohan Hedberg BT_ERR("Too short cmd_complete event"); 70375e84b7cSJohan Hedberg goto failed; 70475e84b7cSJohan Hedberg } 70575e84b7cSJohan Hedberg 70675e84b7cSJohan Hedberg ev = (void *) skb->data; 70775e84b7cSJohan Hedberg skb_pull(skb, sizeof(*ev)); 70875e84b7cSJohan Hedberg 70975e84b7cSJohan Hedberg if (opcode == __le16_to_cpu(ev->opcode)) 71075e84b7cSJohan Hedberg return skb; 71175e84b7cSJohan Hedberg 71275e84b7cSJohan Hedberg BT_DBG("opcode doesn't match (0x%2.2x != 0x%2.2x)", opcode, 71375e84b7cSJohan Hedberg __le16_to_cpu(ev->opcode)); 71475e84b7cSJohan Hedberg 71575e84b7cSJohan Hedberg failed: 71675e84b7cSJohan Hedberg kfree_skb(skb); 71775e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 71875e84b7cSJohan Hedberg } 71975e84b7cSJohan Hedberg 7207b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, 72107dc93ddSJohan Hedberg const void *param, u8 event, u32 timeout) 72275e84b7cSJohan Hedberg { 72375e84b7cSJohan Hedberg DECLARE_WAITQUEUE(wait, current); 72475e84b7cSJohan Hedberg struct hci_request req; 72575e84b7cSJohan Hedberg int err = 0; 72675e84b7cSJohan Hedberg 72775e84b7cSJohan Hedberg BT_DBG("%s", hdev->name); 72875e84b7cSJohan Hedberg 72975e84b7cSJohan Hedberg hci_req_init(&req, hdev); 73075e84b7cSJohan Hedberg 7317b1abbbeSJohan Hedberg hci_req_add_ev(&req, opcode, plen, param, event); 73275e84b7cSJohan Hedberg 73375e84b7cSJohan Hedberg hdev->req_status = HCI_REQ_PEND; 73475e84b7cSJohan Hedberg 73575e84b7cSJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 73675e84b7cSJohan Hedberg if (err < 0) 73775e84b7cSJohan Hedberg return ERR_PTR(err); 73875e84b7cSJohan Hedberg 73975e84b7cSJohan Hedberg add_wait_queue(&hdev->req_wait_q, &wait); 74075e84b7cSJohan Hedberg set_current_state(TASK_INTERRUPTIBLE); 74175e84b7cSJohan Hedberg 74275e84b7cSJohan Hedberg schedule_timeout(timeout); 74375e84b7cSJohan Hedberg 74475e84b7cSJohan Hedberg remove_wait_queue(&hdev->req_wait_q, &wait); 74575e84b7cSJohan Hedberg 74675e84b7cSJohan Hedberg if (signal_pending(current)) 74775e84b7cSJohan Hedberg return ERR_PTR(-EINTR); 74875e84b7cSJohan Hedberg 74975e84b7cSJohan Hedberg switch (hdev->req_status) { 75075e84b7cSJohan Hedberg case HCI_REQ_DONE: 75175e84b7cSJohan Hedberg err = -bt_to_errno(hdev->req_result); 75275e84b7cSJohan Hedberg break; 75375e84b7cSJohan Hedberg 75475e84b7cSJohan Hedberg case HCI_REQ_CANCELED: 75575e84b7cSJohan Hedberg err = -hdev->req_result; 75675e84b7cSJohan Hedberg break; 75775e84b7cSJohan Hedberg 75875e84b7cSJohan Hedberg default: 75975e84b7cSJohan Hedberg err = -ETIMEDOUT; 76075e84b7cSJohan Hedberg break; 76175e84b7cSJohan Hedberg } 76275e84b7cSJohan Hedberg 76375e84b7cSJohan Hedberg hdev->req_status = hdev->req_result = 0; 76475e84b7cSJohan Hedberg 76575e84b7cSJohan Hedberg BT_DBG("%s end: err %d", hdev->name, err); 76675e84b7cSJohan Hedberg 76775e84b7cSJohan Hedberg if (err < 0) 76875e84b7cSJohan Hedberg return ERR_PTR(err); 76975e84b7cSJohan Hedberg 7707b1abbbeSJohan Hedberg return hci_get_cmd_complete(hdev, opcode, event); 7717b1abbbeSJohan Hedberg } 7727b1abbbeSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync_ev); 7737b1abbbeSJohan Hedberg 7747b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 77507dc93ddSJohan Hedberg const void *param, u32 timeout) 7767b1abbbeSJohan Hedberg { 7777b1abbbeSJohan Hedberg return __hci_cmd_sync_ev(hdev, opcode, plen, param, 0, timeout); 77875e84b7cSJohan Hedberg } 77975e84b7cSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync); 78075e84b7cSJohan Hedberg 7811da177e4SLinus Torvalds /* Execute request and wait for completion. */ 78201178cd4SJohan Hedberg static int __hci_req_sync(struct hci_dev *hdev, 78342c6b129SJohan Hedberg void (*func)(struct hci_request *req, 78442c6b129SJohan Hedberg unsigned long opt), 7851da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 7861da177e4SLinus Torvalds { 78742c6b129SJohan Hedberg struct hci_request req; 7881da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 7891da177e4SLinus Torvalds int err = 0; 7901da177e4SLinus Torvalds 7911da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 7921da177e4SLinus Torvalds 79342c6b129SJohan Hedberg hci_req_init(&req, hdev); 79442c6b129SJohan Hedberg 7951da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 7961da177e4SLinus Torvalds 79742c6b129SJohan Hedberg func(&req, opt); 79853cce22dSJohan Hedberg 79942c6b129SJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 80042c6b129SJohan Hedberg if (err < 0) { 80153cce22dSJohan Hedberg hdev->req_status = 0; 802920c8300SAndre Guedes 803920c8300SAndre Guedes /* ENODATA means the HCI request command queue is empty. 804920c8300SAndre Guedes * This can happen when a request with conditionals doesn't 805920c8300SAndre Guedes * trigger any commands to be sent. This is normal behavior 806920c8300SAndre Guedes * and should not trigger an error return. 80742c6b129SJohan Hedberg */ 808920c8300SAndre Guedes if (err == -ENODATA) 80942c6b129SJohan Hedberg return 0; 810920c8300SAndre Guedes 811920c8300SAndre Guedes return err; 81253cce22dSJohan Hedberg } 81353cce22dSJohan Hedberg 814bc4445c7SAndre Guedes add_wait_queue(&hdev->req_wait_q, &wait); 815bc4445c7SAndre Guedes set_current_state(TASK_INTERRUPTIBLE); 816bc4445c7SAndre Guedes 8171da177e4SLinus Torvalds schedule_timeout(timeout); 8181da177e4SLinus Torvalds 8191da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 8201da177e4SLinus Torvalds 8211da177e4SLinus Torvalds if (signal_pending(current)) 8221da177e4SLinus Torvalds return -EINTR; 8231da177e4SLinus Torvalds 8241da177e4SLinus Torvalds switch (hdev->req_status) { 8251da177e4SLinus Torvalds case HCI_REQ_DONE: 826e175072fSJoe Perches err = -bt_to_errno(hdev->req_result); 8271da177e4SLinus Torvalds break; 8281da177e4SLinus Torvalds 8291da177e4SLinus Torvalds case HCI_REQ_CANCELED: 8301da177e4SLinus Torvalds err = -hdev->req_result; 8311da177e4SLinus Torvalds break; 8321da177e4SLinus Torvalds 8331da177e4SLinus Torvalds default: 8341da177e4SLinus Torvalds err = -ETIMEDOUT; 8351da177e4SLinus Torvalds break; 8363ff50b79SStephen Hemminger } 8371da177e4SLinus Torvalds 838a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 8391da177e4SLinus Torvalds 8401da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 8411da177e4SLinus Torvalds 8421da177e4SLinus Torvalds return err; 8431da177e4SLinus Torvalds } 8441da177e4SLinus Torvalds 84501178cd4SJohan Hedberg static int hci_req_sync(struct hci_dev *hdev, 84642c6b129SJohan Hedberg void (*req)(struct hci_request *req, 84742c6b129SJohan Hedberg unsigned long opt), 8481da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 8491da177e4SLinus Torvalds { 8501da177e4SLinus Torvalds int ret; 8511da177e4SLinus Torvalds 8527c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 8537c6a329eSMarcel Holtmann return -ENETDOWN; 8547c6a329eSMarcel Holtmann 8551da177e4SLinus Torvalds /* Serialize all requests */ 8561da177e4SLinus Torvalds hci_req_lock(hdev); 85701178cd4SJohan Hedberg ret = __hci_req_sync(hdev, req, opt, timeout); 8581da177e4SLinus Torvalds hci_req_unlock(hdev); 8591da177e4SLinus Torvalds 8601da177e4SLinus Torvalds return ret; 8611da177e4SLinus Torvalds } 8621da177e4SLinus Torvalds 86342c6b129SJohan Hedberg static void hci_reset_req(struct hci_request *req, unsigned long opt) 8641da177e4SLinus Torvalds { 86542c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 8661da177e4SLinus Torvalds 8671da177e4SLinus Torvalds /* Reset device */ 86842c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 86942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 8701da177e4SLinus Torvalds } 8711da177e4SLinus Torvalds 87242c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 8731da177e4SLinus Torvalds { 87442c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 8752455a3eaSAndrei Emeltchenko 8761da177e4SLinus Torvalds /* Read Local Supported Features */ 87742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 8781da177e4SLinus Torvalds 8791143e5a6SMarcel Holtmann /* Read Local Version */ 88042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 8812177bab5SJohan Hedberg 8822177bab5SJohan Hedberg /* Read BD Address */ 88342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 8841da177e4SLinus Torvalds } 8851da177e4SLinus Torvalds 88642c6b129SJohan Hedberg static void amp_init(struct hci_request *req) 887e61ef499SAndrei Emeltchenko { 88842c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 8892455a3eaSAndrei Emeltchenko 890e61ef499SAndrei Emeltchenko /* Read Local Version */ 89142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 8926bcbc489SAndrei Emeltchenko 893f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 894f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 895f6996cfeSMarcel Holtmann 896f6996cfeSMarcel Holtmann /* Read Local Supported Features */ 897f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 898f6996cfeSMarcel Holtmann 8996bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 90042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 901e71dfabaSAndrei Emeltchenko 902e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 90342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 9047528ca1cSMarcel Holtmann 905f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 906f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 907f38ba941SMarcel Holtmann 9087528ca1cSMarcel Holtmann /* Read Location Data */ 9097528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 910e61ef499SAndrei Emeltchenko } 911e61ef499SAndrei Emeltchenko 91242c6b129SJohan Hedberg static void hci_init1_req(struct hci_request *req, unsigned long opt) 913e61ef499SAndrei Emeltchenko { 91442c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 915e61ef499SAndrei Emeltchenko 916e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 917e61ef499SAndrei Emeltchenko 91811778716SAndrei Emeltchenko /* Reset */ 91911778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 92042c6b129SJohan Hedberg hci_reset_req(req, 0); 92111778716SAndrei Emeltchenko 922e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 923e61ef499SAndrei Emeltchenko case HCI_BREDR: 92442c6b129SJohan Hedberg bredr_init(req); 925e61ef499SAndrei Emeltchenko break; 926e61ef499SAndrei Emeltchenko 927e61ef499SAndrei Emeltchenko case HCI_AMP: 92842c6b129SJohan Hedberg amp_init(req); 929e61ef499SAndrei Emeltchenko break; 930e61ef499SAndrei Emeltchenko 931e61ef499SAndrei Emeltchenko default: 932e61ef499SAndrei Emeltchenko BT_ERR("Unknown device type %d", hdev->dev_type); 933e61ef499SAndrei Emeltchenko break; 934e61ef499SAndrei Emeltchenko } 935e61ef499SAndrei Emeltchenko } 936e61ef499SAndrei Emeltchenko 93742c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 9382177bab5SJohan Hedberg { 9394ca048e3SMarcel Holtmann struct hci_dev *hdev = req->hdev; 9404ca048e3SMarcel Holtmann 9412177bab5SJohan Hedberg __le16 param; 9422177bab5SJohan Hedberg __u8 flt_type; 9432177bab5SJohan Hedberg 9442177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 94542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 9462177bab5SJohan Hedberg 9472177bab5SJohan Hedberg /* Read Class of Device */ 94842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 9492177bab5SJohan Hedberg 9502177bab5SJohan Hedberg /* Read Local Name */ 95142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 9522177bab5SJohan Hedberg 9532177bab5SJohan Hedberg /* Read Voice Setting */ 95442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 9552177bab5SJohan Hedberg 956b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 957b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 958b4cb9fb2SMarcel Holtmann 9594b836f39SMarcel Holtmann /* Read Current IAC LAP */ 9604b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 9614b836f39SMarcel Holtmann 9622177bab5SJohan Hedberg /* Clear Event Filters */ 9632177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 96442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 9652177bab5SJohan Hedberg 9662177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 9672177bab5SJohan Hedberg param = __constant_cpu_to_le16(0x7d00); 96842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 9692177bab5SJohan Hedberg 9704ca048e3SMarcel Holtmann /* AVM Berlin (31), aka "BlueFRITZ!", reports version 1.2, 9714ca048e3SMarcel Holtmann * but it does not support page scan related HCI commands. 9724ca048e3SMarcel Holtmann */ 9734ca048e3SMarcel Holtmann if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) { 974f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 975f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 976f332ec66SJohan Hedberg } 9772177bab5SJohan Hedberg } 9782177bab5SJohan Hedberg 97942c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 9802177bab5SJohan Hedberg { 981c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 982c73eee91SJohan Hedberg 9832177bab5SJohan Hedberg /* Read LE Buffer Size */ 98442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 9852177bab5SJohan Hedberg 9862177bab5SJohan Hedberg /* Read LE Local Supported Features */ 98742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 9882177bab5SJohan Hedberg 9892177bab5SJohan Hedberg /* Read LE Advertising Channel TX Power */ 99042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 9912177bab5SJohan Hedberg 9922177bab5SJohan Hedberg /* Read LE White List Size */ 99342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 0, NULL); 9942177bab5SJohan Hedberg 9952177bab5SJohan Hedberg /* Read LE Supported States */ 99642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 997c73eee91SJohan Hedberg 998c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 999c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1000c73eee91SJohan Hedberg set_bit(HCI_LE_ENABLED, &hdev->dev_flags); 10012177bab5SJohan Hedberg } 10022177bab5SJohan Hedberg 10032177bab5SJohan Hedberg static u8 hci_get_inquiry_mode(struct hci_dev *hdev) 10042177bab5SJohan Hedberg { 10052177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 10062177bab5SJohan Hedberg return 0x02; 10072177bab5SJohan Hedberg 10082177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 10092177bab5SJohan Hedberg return 0x01; 10102177bab5SJohan Hedberg 10112177bab5SJohan Hedberg if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 && 10122177bab5SJohan Hedberg hdev->lmp_subver == 0x0757) 10132177bab5SJohan Hedberg return 0x01; 10142177bab5SJohan Hedberg 10152177bab5SJohan Hedberg if (hdev->manufacturer == 15) { 10162177bab5SJohan Hedberg if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963) 10172177bab5SJohan Hedberg return 0x01; 10182177bab5SJohan Hedberg if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963) 10192177bab5SJohan Hedberg return 0x01; 10202177bab5SJohan Hedberg if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965) 10212177bab5SJohan Hedberg return 0x01; 10222177bab5SJohan Hedberg } 10232177bab5SJohan Hedberg 10242177bab5SJohan Hedberg if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 && 10252177bab5SJohan Hedberg hdev->lmp_subver == 0x1805) 10262177bab5SJohan Hedberg return 0x01; 10272177bab5SJohan Hedberg 10282177bab5SJohan Hedberg return 0x00; 10292177bab5SJohan Hedberg } 10302177bab5SJohan Hedberg 103142c6b129SJohan Hedberg static void hci_setup_inquiry_mode(struct hci_request *req) 10322177bab5SJohan Hedberg { 10332177bab5SJohan Hedberg u8 mode; 10342177bab5SJohan Hedberg 103542c6b129SJohan Hedberg mode = hci_get_inquiry_mode(req->hdev); 10362177bab5SJohan Hedberg 103742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 10382177bab5SJohan Hedberg } 10392177bab5SJohan Hedberg 104042c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 10412177bab5SJohan Hedberg { 104242c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 104342c6b129SJohan Hedberg 10442177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 10452177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 10462177bab5SJohan Hedberg * command otherwise. 10472177bab5SJohan Hedberg */ 10482177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 10492177bab5SJohan Hedberg 10502177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 10512177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 10522177bab5SJohan Hedberg */ 10532177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 10542177bab5SJohan Hedberg return; 10552177bab5SJohan Hedberg 10562177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 10572177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 10582177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 10592177bab5SJohan Hedberg events[4] |= 0x04; /* Read Remote Extended Features Complete */ 10602177bab5SJohan Hedberg events[5] |= 0x08; /* Synchronous Connection Complete */ 10612177bab5SJohan Hedberg events[5] |= 0x10; /* Synchronous Connection Changed */ 1062c7882cbdSMarcel Holtmann } else { 1063c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 1064c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 1065c7882cbdSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 1066c7882cbdSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 1067c7882cbdSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information Complete */ 1068c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 1069c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 1070c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 1071c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 1072c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 1073c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 10742177bab5SJohan Hedberg } 10752177bab5SJohan Hedberg 10762177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 10772177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 10782177bab5SJohan Hedberg 10792177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 10802177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 10812177bab5SJohan Hedberg 10822177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 10832177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 10842177bab5SJohan Hedberg 10852177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 10862177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 10872177bab5SJohan Hedberg 10882177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 10892177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 10902177bab5SJohan Hedberg 10912177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 10922177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 10932177bab5SJohan Hedberg 10942177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 10952177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 10962177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 10972177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 10982177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 10992177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 11002177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 11012177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 11022177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 11032177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 11042177bab5SJohan Hedberg * Features Notification 11052177bab5SJohan Hedberg */ 11062177bab5SJohan Hedberg } 11072177bab5SJohan Hedberg 11082177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 11092177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 11102177bab5SJohan Hedberg 111142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 11122177bab5SJohan Hedberg 11132177bab5SJohan Hedberg if (lmp_le_capable(hdev)) { 11142177bab5SJohan Hedberg memset(events, 0, sizeof(events)); 11152177bab5SJohan Hedberg events[0] = 0x1f; 111642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, 11172177bab5SJohan Hedberg sizeof(events), events); 11182177bab5SJohan Hedberg } 11192177bab5SJohan Hedberg } 11202177bab5SJohan Hedberg 112142c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 11222177bab5SJohan Hedberg { 112342c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 112442c6b129SJohan Hedberg 11252177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 112642c6b129SJohan Hedberg bredr_setup(req); 112756f87901SJohan Hedberg else 112856f87901SJohan Hedberg clear_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 11292177bab5SJohan Hedberg 11302177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 113142c6b129SJohan Hedberg le_setup(req); 11322177bab5SJohan Hedberg 113342c6b129SJohan Hedberg hci_setup_event_mask(req); 11342177bab5SJohan Hedberg 11353f8e2d75SJohan Hedberg /* AVM Berlin (31), aka "BlueFRITZ!", doesn't support the read 11363f8e2d75SJohan Hedberg * local supported commands HCI command. 11373f8e2d75SJohan Hedberg */ 11383f8e2d75SJohan Hedberg if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) 113942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 11402177bab5SJohan Hedberg 11412177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 114257af75a8SMarcel Holtmann /* When SSP is available, then the host features page 114357af75a8SMarcel Holtmann * should also be available as well. However some 114457af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 114557af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 114657af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 114757af75a8SMarcel Holtmann */ 114857af75a8SMarcel Holtmann hdev->max_page = 0x01; 114957af75a8SMarcel Holtmann 11502177bab5SJohan Hedberg if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) { 11512177bab5SJohan Hedberg u8 mode = 0x01; 115242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 11532177bab5SJohan Hedberg sizeof(mode), &mode); 11542177bab5SJohan Hedberg } else { 11552177bab5SJohan Hedberg struct hci_cp_write_eir cp; 11562177bab5SJohan Hedberg 11572177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 11582177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 11592177bab5SJohan Hedberg 116042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 11612177bab5SJohan Hedberg } 11622177bab5SJohan Hedberg } 11632177bab5SJohan Hedberg 11642177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 116542c6b129SJohan Hedberg hci_setup_inquiry_mode(req); 11662177bab5SJohan Hedberg 11672177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 116842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 11692177bab5SJohan Hedberg 11702177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 11712177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 11722177bab5SJohan Hedberg 11732177bab5SJohan Hedberg cp.page = 0x01; 117442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 117542c6b129SJohan Hedberg sizeof(cp), &cp); 11762177bab5SJohan Hedberg } 11772177bab5SJohan Hedberg 11782177bab5SJohan Hedberg if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) { 11792177bab5SJohan Hedberg u8 enable = 1; 118042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 11812177bab5SJohan Hedberg &enable); 11822177bab5SJohan Hedberg } 11832177bab5SJohan Hedberg } 11842177bab5SJohan Hedberg 118542c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 11862177bab5SJohan Hedberg { 118742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 11882177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 11892177bab5SJohan Hedberg u16 link_policy = 0; 11902177bab5SJohan Hedberg 11912177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 11922177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 11932177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 11942177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 11952177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 11962177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 11972177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 11982177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 11992177bab5SJohan Hedberg 12002177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 120142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 12022177bab5SJohan Hedberg } 12032177bab5SJohan Hedberg 120442c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 12052177bab5SJohan Hedberg { 120642c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 12072177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 12082177bab5SJohan Hedberg 1209c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 1210c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1211c73eee91SJohan Hedberg return; 1212c73eee91SJohan Hedberg 12132177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 12142177bab5SJohan Hedberg 12152177bab5SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) { 12162177bab5SJohan Hedberg cp.le = 0x01; 12172177bab5SJohan Hedberg cp.simul = lmp_le_br_capable(hdev); 12182177bab5SJohan Hedberg } 12192177bab5SJohan Hedberg 12202177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 122142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 12222177bab5SJohan Hedberg &cp); 12232177bab5SJohan Hedberg } 12242177bab5SJohan Hedberg 1225d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 1226d62e6d67SJohan Hedberg { 1227d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 1228d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 1229d62e6d67SJohan Hedberg 1230d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 1231d62e6d67SJohan Hedberg * enable all necessary events for it. 1232d62e6d67SJohan Hedberg */ 1233d62e6d67SJohan Hedberg if (hdev->features[2][0] & 0x01) { 1234d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 1235d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 1236d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 1237d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 1238d62e6d67SJohan Hedberg } 1239d62e6d67SJohan Hedberg 1240d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 1241d62e6d67SJohan Hedberg * enable all necessary events for it. 1242d62e6d67SJohan Hedberg */ 1243d62e6d67SJohan Hedberg if (hdev->features[2][0] & 0x02) { 1244d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 1245d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 1246d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 1247d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 1248d62e6d67SJohan Hedberg } 1249d62e6d67SJohan Hedberg 1250d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 1251d62e6d67SJohan Hedberg } 1252d62e6d67SJohan Hedberg 125342c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 12542177bab5SJohan Hedberg { 125542c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 1256d2c5d77fSJohan Hedberg u8 p; 125742c6b129SJohan Hedberg 1258b8f4e068SGustavo Padovan /* Some Broadcom based Bluetooth controllers do not support the 1259b8f4e068SGustavo Padovan * Delete Stored Link Key command. They are clearly indicating its 1260b8f4e068SGustavo Padovan * absence in the bit mask of supported commands. 1261b8f4e068SGustavo Padovan * 1262b8f4e068SGustavo Padovan * Check the supported commands and only if the the command is marked 1263b8f4e068SGustavo Padovan * as supported send it. If not supported assume that the controller 1264b8f4e068SGustavo Padovan * does not have actual support for stored link keys which makes this 1265b8f4e068SGustavo Padovan * command redundant anyway. 1266b8f4e068SGustavo Padovan */ 126759f45d57SJohan Hedberg if (hdev->commands[6] & 0x80) { 126859f45d57SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 126959f45d57SJohan Hedberg 127059f45d57SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 127159f45d57SJohan Hedberg cp.delete_all = 0x01; 127259f45d57SJohan Hedberg hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 127359f45d57SJohan Hedberg sizeof(cp), &cp); 127459f45d57SJohan Hedberg } 127559f45d57SJohan Hedberg 12762177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 127742c6b129SJohan Hedberg hci_setup_link_policy(req); 12782177bab5SJohan Hedberg 127979830f66SMarcel Holtmann if (lmp_le_capable(hdev)) { 128079830f66SMarcel Holtmann /* If the controller has a public BD_ADDR, then by 128179830f66SMarcel Holtmann * default use that one. If this is a LE only 128279830f66SMarcel Holtmann * controller without one, default to the random 128379830f66SMarcel Holtmann * address. 128479830f66SMarcel Holtmann */ 128579830f66SMarcel Holtmann if (bacmp(&hdev->bdaddr, BDADDR_ANY)) 128679830f66SMarcel Holtmann hdev->own_addr_type = ADDR_LE_DEV_PUBLIC; 128779830f66SMarcel Holtmann else 128879830f66SMarcel Holtmann hdev->own_addr_type = ADDR_LE_DEV_RANDOM; 128979830f66SMarcel Holtmann 129042c6b129SJohan Hedberg hci_set_le_support(req); 129179830f66SMarcel Holtmann } 1292d2c5d77fSJohan Hedberg 1293d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 1294d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 1295d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 1296d2c5d77fSJohan Hedberg 1297d2c5d77fSJohan Hedberg cp.page = p; 1298d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 1299d2c5d77fSJohan Hedberg sizeof(cp), &cp); 1300d2c5d77fSJohan Hedberg } 13012177bab5SJohan Hedberg } 13022177bab5SJohan Hedberg 13035d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 13045d4e7e8dSJohan Hedberg { 13055d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 13065d4e7e8dSJohan Hedberg 1307d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 1308d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 1309d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 1310d62e6d67SJohan Hedberg 13115d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 13125d4e7e8dSJohan Hedberg if (hdev->features[2][0] & 0x04) 13135d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 13145d4e7e8dSJohan Hedberg } 13155d4e7e8dSJohan Hedberg 13162177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 13172177bab5SJohan Hedberg { 13182177bab5SJohan Hedberg int err; 13192177bab5SJohan Hedberg 13202177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 13212177bab5SJohan Hedberg if (err < 0) 13222177bab5SJohan Hedberg return err; 13232177bab5SJohan Hedberg 13244b4148e9SMarcel Holtmann /* The Device Under Test (DUT) mode is special and available for 13254b4148e9SMarcel Holtmann * all controller types. So just create it early on. 13264b4148e9SMarcel Holtmann */ 13274b4148e9SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 13284b4148e9SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 13294b4148e9SMarcel Holtmann &dut_mode_fops); 13304b4148e9SMarcel Holtmann } 13314b4148e9SMarcel Holtmann 13322177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 13332177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 13342177bab5SJohan Hedberg * first stage init. 13352177bab5SJohan Hedberg */ 13362177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 13372177bab5SJohan Hedberg return 0; 13382177bab5SJohan Hedberg 13392177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 13402177bab5SJohan Hedberg if (err < 0) 13412177bab5SJohan Hedberg return err; 13422177bab5SJohan Hedberg 13435d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 13445d4e7e8dSJohan Hedberg if (err < 0) 13455d4e7e8dSJohan Hedberg return err; 13465d4e7e8dSJohan Hedberg 1347baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 1348baf27f6eSMarcel Holtmann if (err < 0) 1349baf27f6eSMarcel Holtmann return err; 1350baf27f6eSMarcel Holtmann 1351baf27f6eSMarcel Holtmann /* Only create debugfs entries during the initial setup 1352baf27f6eSMarcel Holtmann * phase and not every time the controller gets powered on. 1353baf27f6eSMarcel Holtmann */ 1354baf27f6eSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 1355baf27f6eSMarcel Holtmann return 0; 1356baf27f6eSMarcel Holtmann 1357dfb826a8SMarcel Holtmann debugfs_create_file("features", 0444, hdev->debugfs, hdev, 1358dfb826a8SMarcel Holtmann &features_fops); 1359ceeb3bc0SMarcel Holtmann debugfs_create_u16("manufacturer", 0444, hdev->debugfs, 1360ceeb3bc0SMarcel Holtmann &hdev->manufacturer); 1361ceeb3bc0SMarcel Holtmann debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver); 1362ceeb3bc0SMarcel Holtmann debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev); 136370afe0b8SMarcel Holtmann debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev, 136470afe0b8SMarcel Holtmann &blacklist_fops); 136547219839SMarcel Holtmann debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 136647219839SMarcel Holtmann 1367baf27f6eSMarcel Holtmann if (lmp_bredr_capable(hdev)) { 1368baf27f6eSMarcel Holtmann debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, 1369baf27f6eSMarcel Holtmann hdev, &inquiry_cache_fops); 137002d08d15SMarcel Holtmann debugfs_create_file("link_keys", 0400, hdev->debugfs, 137102d08d15SMarcel Holtmann hdev, &link_keys_fops); 137212c269d7SMarcel Holtmann debugfs_create_file("use_debug_keys", 0444, hdev->debugfs, 137312c269d7SMarcel Holtmann hdev, &use_debug_keys_fops); 1374babdbb3cSMarcel Holtmann debugfs_create_file("dev_class", 0444, hdev->debugfs, 1375babdbb3cSMarcel Holtmann hdev, &dev_class_fops); 1376041000b9SMarcel Holtmann debugfs_create_file("voice_setting", 0444, hdev->debugfs, 1377041000b9SMarcel Holtmann hdev, &voice_setting_fops); 1378baf27f6eSMarcel Holtmann } 1379baf27f6eSMarcel Holtmann 138006f5b778SMarcel Holtmann if (lmp_ssp_capable(hdev)) { 1381ebd1e33bSMarcel Holtmann debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 1382ebd1e33bSMarcel Holtmann hdev, &auto_accept_delay_fops); 138306f5b778SMarcel Holtmann debugfs_create_file("ssp_debug_mode", 0644, hdev->debugfs, 138406f5b778SMarcel Holtmann hdev, &ssp_debug_mode_fops); 138506f5b778SMarcel Holtmann } 1386ebd1e33bSMarcel Holtmann 13872bfa3531SMarcel Holtmann if (lmp_sniff_capable(hdev)) { 13882bfa3531SMarcel Holtmann debugfs_create_file("idle_timeout", 0644, hdev->debugfs, 13892bfa3531SMarcel Holtmann hdev, &idle_timeout_fops); 13902bfa3531SMarcel Holtmann debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs, 13912bfa3531SMarcel Holtmann hdev, &sniff_min_interval_fops); 13922bfa3531SMarcel Holtmann debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs, 13932bfa3531SMarcel Holtmann hdev, &sniff_max_interval_fops); 13942bfa3531SMarcel Holtmann } 13952bfa3531SMarcel Holtmann 1396d0f729b8SMarcel Holtmann if (lmp_le_capable(hdev)) { 1397d0f729b8SMarcel Holtmann debugfs_create_u8("white_list_size", 0444, hdev->debugfs, 1398d0f729b8SMarcel Holtmann &hdev->le_white_list_size); 1399e7b8fc92SMarcel Holtmann debugfs_create_file("static_address", 0444, hdev->debugfs, 1400e7b8fc92SMarcel Holtmann hdev, &static_address_fops); 140192202185SMarcel Holtmann debugfs_create_file("own_address_type", 0644, hdev->debugfs, 140292202185SMarcel Holtmann hdev, &own_address_type_fops); 14038f8625cdSMarcel Holtmann debugfs_create_file("long_term_keys", 0400, hdev->debugfs, 14048f8625cdSMarcel Holtmann hdev, &long_term_keys_fops); 14054e70c7e7SMarcel Holtmann debugfs_create_file("conn_min_interval", 0644, hdev->debugfs, 14064e70c7e7SMarcel Holtmann hdev, &conn_min_interval_fops); 14074e70c7e7SMarcel Holtmann debugfs_create_file("conn_max_interval", 0644, hdev->debugfs, 14084e70c7e7SMarcel Holtmann hdev, &conn_max_interval_fops); 1409d0f729b8SMarcel Holtmann } 1410e7b8fc92SMarcel Holtmann 1411baf27f6eSMarcel Holtmann return 0; 14122177bab5SJohan Hedberg } 14132177bab5SJohan Hedberg 141442c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 14151da177e4SLinus Torvalds { 14161da177e4SLinus Torvalds __u8 scan = opt; 14171da177e4SLinus Torvalds 141842c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 14191da177e4SLinus Torvalds 14201da177e4SLinus Torvalds /* Inquiry and Page scans */ 142142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 14221da177e4SLinus Torvalds } 14231da177e4SLinus Torvalds 142442c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 14251da177e4SLinus Torvalds { 14261da177e4SLinus Torvalds __u8 auth = opt; 14271da177e4SLinus Torvalds 142842c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 14291da177e4SLinus Torvalds 14301da177e4SLinus Torvalds /* Authentication */ 143142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 14321da177e4SLinus Torvalds } 14331da177e4SLinus Torvalds 143442c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 14351da177e4SLinus Torvalds { 14361da177e4SLinus Torvalds __u8 encrypt = opt; 14371da177e4SLinus Torvalds 143842c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 14391da177e4SLinus Torvalds 1440e4e8e37cSMarcel Holtmann /* Encryption */ 144142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 14421da177e4SLinus Torvalds } 14431da177e4SLinus Torvalds 144442c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1445e4e8e37cSMarcel Holtmann { 1446e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1447e4e8e37cSMarcel Holtmann 144842c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1449e4e8e37cSMarcel Holtmann 1450e4e8e37cSMarcel Holtmann /* Default link policy */ 145142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1452e4e8e37cSMarcel Holtmann } 1453e4e8e37cSMarcel Holtmann 14541da177e4SLinus Torvalds /* Get HCI device by index. 14551da177e4SLinus Torvalds * Device is held on return. */ 14561da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 14571da177e4SLinus Torvalds { 14588035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 14591da177e4SLinus Torvalds 14601da177e4SLinus Torvalds BT_DBG("%d", index); 14611da177e4SLinus Torvalds 14621da177e4SLinus Torvalds if (index < 0) 14631da177e4SLinus Torvalds return NULL; 14641da177e4SLinus Torvalds 14651da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 14668035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 14671da177e4SLinus Torvalds if (d->id == index) { 14681da177e4SLinus Torvalds hdev = hci_dev_hold(d); 14691da177e4SLinus Torvalds break; 14701da177e4SLinus Torvalds } 14711da177e4SLinus Torvalds } 14721da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 14731da177e4SLinus Torvalds return hdev; 14741da177e4SLinus Torvalds } 14751da177e4SLinus Torvalds 14761da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1477ff9ef578SJohan Hedberg 147830dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 147930dc78e1SJohan Hedberg { 148030dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 148130dc78e1SJohan Hedberg 14826fbe195dSAndre Guedes switch (discov->state) { 1483343f935bSAndre Guedes case DISCOVERY_FINDING: 14846fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 148530dc78e1SJohan Hedberg return true; 148630dc78e1SJohan Hedberg 14876fbe195dSAndre Guedes default: 148830dc78e1SJohan Hedberg return false; 148930dc78e1SJohan Hedberg } 14906fbe195dSAndre Guedes } 149130dc78e1SJohan Hedberg 1492ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1493ff9ef578SJohan Hedberg { 1494ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1495ff9ef578SJohan Hedberg 1496ff9ef578SJohan Hedberg if (hdev->discovery.state == state) 1497ff9ef578SJohan Hedberg return; 1498ff9ef578SJohan Hedberg 1499ff9ef578SJohan Hedberg switch (state) { 1500ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 15017b99b659SAndre Guedes if (hdev->discovery.state != DISCOVERY_STARTING) 1502ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1503ff9ef578SJohan Hedberg break; 1504ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1505ff9ef578SJohan Hedberg break; 1506343f935bSAndre Guedes case DISCOVERY_FINDING: 1507ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1508ff9ef578SJohan Hedberg break; 150930dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 151030dc78e1SJohan Hedberg break; 1511ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1512ff9ef578SJohan Hedberg break; 1513ff9ef578SJohan Hedberg } 1514ff9ef578SJohan Hedberg 1515ff9ef578SJohan Hedberg hdev->discovery.state = state; 1516ff9ef578SJohan Hedberg } 1517ff9ef578SJohan Hedberg 15181f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 15191da177e4SLinus Torvalds { 152030883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1521b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 15221da177e4SLinus Torvalds 1523561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1524561aafbcSJohan Hedberg list_del(&p->all); 1525b57c1a56SJohan Hedberg kfree(p); 15261da177e4SLinus Torvalds } 1527561aafbcSJohan Hedberg 1528561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1529561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 15301da177e4SLinus Torvalds } 15311da177e4SLinus Torvalds 1532a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1533a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 15341da177e4SLinus Torvalds { 153530883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 15361da177e4SLinus Torvalds struct inquiry_entry *e; 15371da177e4SLinus Torvalds 15386ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 15391da177e4SLinus Torvalds 1540561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 15411da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 15421da177e4SLinus Torvalds return e; 15431da177e4SLinus Torvalds } 15441da177e4SLinus Torvalds 1545b57c1a56SJohan Hedberg return NULL; 1546b57c1a56SJohan Hedberg } 1547b57c1a56SJohan Hedberg 1548561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1549561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1550561aafbcSJohan Hedberg { 155130883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1552561aafbcSJohan Hedberg struct inquiry_entry *e; 1553561aafbcSJohan Hedberg 15546ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1555561aafbcSJohan Hedberg 1556561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1557561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1558561aafbcSJohan Hedberg return e; 1559561aafbcSJohan Hedberg } 1560561aafbcSJohan Hedberg 1561561aafbcSJohan Hedberg return NULL; 1562561aafbcSJohan Hedberg } 1563561aafbcSJohan Hedberg 156430dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 156530dc78e1SJohan Hedberg bdaddr_t *bdaddr, 156630dc78e1SJohan Hedberg int state) 156730dc78e1SJohan Hedberg { 156830dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 156930dc78e1SJohan Hedberg struct inquiry_entry *e; 157030dc78e1SJohan Hedberg 15716ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 157230dc78e1SJohan Hedberg 157330dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 157430dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 157530dc78e1SJohan Hedberg return e; 157630dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 157730dc78e1SJohan Hedberg return e; 157830dc78e1SJohan Hedberg } 157930dc78e1SJohan Hedberg 158030dc78e1SJohan Hedberg return NULL; 158130dc78e1SJohan Hedberg } 158230dc78e1SJohan Hedberg 1583a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1584a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1585a3d4e20aSJohan Hedberg { 1586a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1587a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1588a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1589a3d4e20aSJohan Hedberg 1590a3d4e20aSJohan Hedberg list_del(&ie->list); 1591a3d4e20aSJohan Hedberg 1592a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1593a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1594a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1595a3d4e20aSJohan Hedberg break; 1596a3d4e20aSJohan Hedberg pos = &p->list; 1597a3d4e20aSJohan Hedberg } 1598a3d4e20aSJohan Hedberg 1599a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1600a3d4e20aSJohan Hedberg } 1601a3d4e20aSJohan Hedberg 16023175405bSJohan Hedberg bool hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1603388fc8faSJohan Hedberg bool name_known, bool *ssp) 16041da177e4SLinus Torvalds { 160530883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 160670f23020SAndrei Emeltchenko struct inquiry_entry *ie; 16071da177e4SLinus Torvalds 16086ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 16091da177e4SLinus Torvalds 16102b2fec4dSSzymon Janc hci_remove_remote_oob_data(hdev, &data->bdaddr); 16112b2fec4dSSzymon Janc 1612388fc8faSJohan Hedberg if (ssp) 1613388fc8faSJohan Hedberg *ssp = data->ssp_mode; 1614388fc8faSJohan Hedberg 161570f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1616a3d4e20aSJohan Hedberg if (ie) { 1617388fc8faSJohan Hedberg if (ie->data.ssp_mode && ssp) 1618388fc8faSJohan Hedberg *ssp = true; 1619388fc8faSJohan Hedberg 1620a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1621a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1622a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1623a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1624a3d4e20aSJohan Hedberg } 1625a3d4e20aSJohan Hedberg 1626561aafbcSJohan Hedberg goto update; 1627a3d4e20aSJohan Hedberg } 1628561aafbcSJohan Hedberg 16291da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 163070f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 163170f23020SAndrei Emeltchenko if (!ie) 16323175405bSJohan Hedberg return false; 163370f23020SAndrei Emeltchenko 1634561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1635561aafbcSJohan Hedberg 1636561aafbcSJohan Hedberg if (name_known) { 1637561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1638561aafbcSJohan Hedberg } else { 1639561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1640561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1641561aafbcSJohan Hedberg } 1642561aafbcSJohan Hedberg 1643561aafbcSJohan Hedberg update: 1644561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1645561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1646561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1647561aafbcSJohan Hedberg list_del(&ie->list); 16481da177e4SLinus Torvalds } 16491da177e4SLinus Torvalds 165070f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 165170f23020SAndrei Emeltchenko ie->timestamp = jiffies; 16521da177e4SLinus Torvalds cache->timestamp = jiffies; 16533175405bSJohan Hedberg 16543175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 16553175405bSJohan Hedberg return false; 16563175405bSJohan Hedberg 16573175405bSJohan Hedberg return true; 16581da177e4SLinus Torvalds } 16591da177e4SLinus Torvalds 16601da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 16611da177e4SLinus Torvalds { 166230883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 16631da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 16641da177e4SLinus Torvalds struct inquiry_entry *e; 16651da177e4SLinus Torvalds int copied = 0; 16661da177e4SLinus Torvalds 1667561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 16681da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1669b57c1a56SJohan Hedberg 1670b57c1a56SJohan Hedberg if (copied >= num) 1671b57c1a56SJohan Hedberg break; 1672b57c1a56SJohan Hedberg 16731da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 16741da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 16751da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 16761da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 16771da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 16781da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1679b57c1a56SJohan Hedberg 16801da177e4SLinus Torvalds info++; 1681b57c1a56SJohan Hedberg copied++; 16821da177e4SLinus Torvalds } 16831da177e4SLinus Torvalds 16841da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 16851da177e4SLinus Torvalds return copied; 16861da177e4SLinus Torvalds } 16871da177e4SLinus Torvalds 168842c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 16891da177e4SLinus Torvalds { 16901da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 169142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 16921da177e4SLinus Torvalds struct hci_cp_inquiry cp; 16931da177e4SLinus Torvalds 16941da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 16951da177e4SLinus Torvalds 16961da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 16971da177e4SLinus Torvalds return; 16981da177e4SLinus Torvalds 16991da177e4SLinus Torvalds /* Start Inquiry */ 17001da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 17011da177e4SLinus Torvalds cp.length = ir->length; 17021da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 170342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 17041da177e4SLinus Torvalds } 17051da177e4SLinus Torvalds 17063e13fa1eSAndre Guedes static int wait_inquiry(void *word) 17073e13fa1eSAndre Guedes { 17083e13fa1eSAndre Guedes schedule(); 17093e13fa1eSAndre Guedes return signal_pending(current); 17103e13fa1eSAndre Guedes } 17113e13fa1eSAndre Guedes 17121da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 17131da177e4SLinus Torvalds { 17141da177e4SLinus Torvalds __u8 __user *ptr = arg; 17151da177e4SLinus Torvalds struct hci_inquiry_req ir; 17161da177e4SLinus Torvalds struct hci_dev *hdev; 17171da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 17181da177e4SLinus Torvalds long timeo; 17191da177e4SLinus Torvalds __u8 *buf; 17201da177e4SLinus Torvalds 17211da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 17221da177e4SLinus Torvalds return -EFAULT; 17231da177e4SLinus Torvalds 17245a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 17255a08ecceSAndrei Emeltchenko if (!hdev) 17261da177e4SLinus Torvalds return -ENODEV; 17271da177e4SLinus Torvalds 17280736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 17290736cfa8SMarcel Holtmann err = -EBUSY; 17300736cfa8SMarcel Holtmann goto done; 17310736cfa8SMarcel Holtmann } 17320736cfa8SMarcel Holtmann 17335b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 17345b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 17355b69bef5SMarcel Holtmann goto done; 17365b69bef5SMarcel Holtmann } 17375b69bef5SMarcel Holtmann 173856f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 173956f87901SJohan Hedberg err = -EOPNOTSUPP; 174056f87901SJohan Hedberg goto done; 174156f87901SJohan Hedberg } 174256f87901SJohan Hedberg 174309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17441da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1745a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 17461f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 17471da177e4SLinus Torvalds do_inquiry = 1; 17481da177e4SLinus Torvalds } 174909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17501da177e4SLinus Torvalds 175104837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 175270f23020SAndrei Emeltchenko 175370f23020SAndrei Emeltchenko if (do_inquiry) { 175401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 175501178cd4SJohan Hedberg timeo); 175670f23020SAndrei Emeltchenko if (err < 0) 17571da177e4SLinus Torvalds goto done; 17583e13fa1eSAndre Guedes 17593e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 17603e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 17613e13fa1eSAndre Guedes */ 17623e13fa1eSAndre Guedes if (wait_on_bit(&hdev->flags, HCI_INQUIRY, wait_inquiry, 17633e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 17643e13fa1eSAndre Guedes return -EINTR; 176570f23020SAndrei Emeltchenko } 17661da177e4SLinus Torvalds 17678fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 17688fc9ced3SGustavo Padovan * 255 entries 17698fc9ced3SGustavo Padovan */ 17701da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 17711da177e4SLinus Torvalds 17721da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 17731da177e4SLinus Torvalds * copy it to the user space. 17741da177e4SLinus Torvalds */ 177570f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 177670f23020SAndrei Emeltchenko if (!buf) { 17771da177e4SLinus Torvalds err = -ENOMEM; 17781da177e4SLinus Torvalds goto done; 17791da177e4SLinus Torvalds } 17801da177e4SLinus Torvalds 178109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17821da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 178309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17841da177e4SLinus Torvalds 17851da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 17861da177e4SLinus Torvalds 17871da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 17881da177e4SLinus Torvalds ptr += sizeof(ir); 17891da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 17901da177e4SLinus Torvalds ir.num_rsp)) 17911da177e4SLinus Torvalds err = -EFAULT; 17921da177e4SLinus Torvalds } else 17931da177e4SLinus Torvalds err = -EFAULT; 17941da177e4SLinus Torvalds 17951da177e4SLinus Torvalds kfree(buf); 17961da177e4SLinus Torvalds 17971da177e4SLinus Torvalds done: 17981da177e4SLinus Torvalds hci_dev_put(hdev); 17991da177e4SLinus Torvalds return err; 18001da177e4SLinus Torvalds } 18011da177e4SLinus Torvalds 1802cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 18031da177e4SLinus Torvalds { 18041da177e4SLinus Torvalds int ret = 0; 18051da177e4SLinus Torvalds 18061da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 18071da177e4SLinus Torvalds 18081da177e4SLinus Torvalds hci_req_lock(hdev); 18091da177e4SLinus Torvalds 181094324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 181194324962SJohan Hovold ret = -ENODEV; 181294324962SJohan Hovold goto done; 181394324962SJohan Hovold } 181494324962SJohan Hovold 1815a5c8f270SMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) { 1816a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1817a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1818bf543036SJohan Hedberg */ 1819a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 1820611b30f7SMarcel Holtmann ret = -ERFKILL; 1821611b30f7SMarcel Holtmann goto done; 1822611b30f7SMarcel Holtmann } 1823611b30f7SMarcel Holtmann 1824a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1825a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1826a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1827a5c8f270SMarcel Holtmann * or not. 1828a5c8f270SMarcel Holtmann * 1829a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1830a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1831a5c8f270SMarcel Holtmann */ 1832a5c8f270SMarcel Holtmann if (hdev->dev_type == HCI_BREDR && 1833a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1834a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1835a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1836a5c8f270SMarcel Holtmann goto done; 1837a5c8f270SMarcel Holtmann } 1838a5c8f270SMarcel Holtmann } 1839a5c8f270SMarcel Holtmann 18401da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 18411da177e4SLinus Torvalds ret = -EALREADY; 18421da177e4SLinus Torvalds goto done; 18431da177e4SLinus Torvalds } 18441da177e4SLinus Torvalds 18451da177e4SLinus Torvalds if (hdev->open(hdev)) { 18461da177e4SLinus Torvalds ret = -EIO; 18471da177e4SLinus Torvalds goto done; 18481da177e4SLinus Torvalds } 18491da177e4SLinus Torvalds 18501da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 18511da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1852f41c70c4SMarcel Holtmann 1853f41c70c4SMarcel Holtmann if (hdev->setup && test_bit(HCI_SETUP, &hdev->dev_flags)) 1854f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1855f41c70c4SMarcel Holtmann 1856f41c70c4SMarcel Holtmann if (!ret) { 1857f41c70c4SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 1858f41c70c4SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 1859f41c70c4SMarcel Holtmann 18600736cfa8SMarcel Holtmann if (!test_bit(HCI_RAW, &hdev->flags) && 18610736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 18622177bab5SJohan Hedberg ret = __hci_init(hdev); 18631da177e4SLinus Torvalds } 18641da177e4SLinus Torvalds 1865f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1866f41c70c4SMarcel Holtmann 18671da177e4SLinus Torvalds if (!ret) { 18681da177e4SLinus Torvalds hci_dev_hold(hdev); 18691da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 18701da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 1871bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 18720736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 18731514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 187409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1875744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 187609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 187756e5cb86SJohan Hedberg } 18781da177e4SLinus Torvalds } else { 18791da177e4SLinus Torvalds /* Init failed, cleanup */ 18803eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1881c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1882b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 18831da177e4SLinus Torvalds 18841da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 18851da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 18861da177e4SLinus Torvalds 18871da177e4SLinus Torvalds if (hdev->flush) 18881da177e4SLinus Torvalds hdev->flush(hdev); 18891da177e4SLinus Torvalds 18901da177e4SLinus Torvalds if (hdev->sent_cmd) { 18911da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 18921da177e4SLinus Torvalds hdev->sent_cmd = NULL; 18931da177e4SLinus Torvalds } 18941da177e4SLinus Torvalds 18951da177e4SLinus Torvalds hdev->close(hdev); 18961da177e4SLinus Torvalds hdev->flags = 0; 18971da177e4SLinus Torvalds } 18981da177e4SLinus Torvalds 18991da177e4SLinus Torvalds done: 19001da177e4SLinus Torvalds hci_req_unlock(hdev); 19011da177e4SLinus Torvalds return ret; 19021da177e4SLinus Torvalds } 19031da177e4SLinus Torvalds 1904cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1905cbed0ca1SJohan Hedberg 1906cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1907cbed0ca1SJohan Hedberg { 1908cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1909cbed0ca1SJohan Hedberg int err; 1910cbed0ca1SJohan Hedberg 1911cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1912cbed0ca1SJohan Hedberg if (!hdev) 1913cbed0ca1SJohan Hedberg return -ENODEV; 1914cbed0ca1SJohan Hedberg 1915e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1916e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1917e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1918e1d08f40SJohan Hedberg * completed. 1919e1d08f40SJohan Hedberg */ 1920e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 1921e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1922e1d08f40SJohan Hedberg 1923a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1924a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1925a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1926a5c8f270SMarcel Holtmann */ 1927e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1928e1d08f40SJohan Hedberg 1929cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1930cbed0ca1SJohan Hedberg 1931cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1932cbed0ca1SJohan Hedberg 1933cbed0ca1SJohan Hedberg return err; 1934cbed0ca1SJohan Hedberg } 1935cbed0ca1SJohan Hedberg 19361da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 19371da177e4SLinus Torvalds { 19381da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 19391da177e4SLinus Torvalds 194078c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 194178c04c0bSVinicius Costa Gomes 19421da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 19431da177e4SLinus Torvalds hci_req_lock(hdev); 19441da177e4SLinus Torvalds 19451da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 1946b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 19471da177e4SLinus Torvalds hci_req_unlock(hdev); 19481da177e4SLinus Torvalds return 0; 19491da177e4SLinus Torvalds } 19501da177e4SLinus Torvalds 19513eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 19523eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1953b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 19541da177e4SLinus Torvalds 195516ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 1956e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 195716ab91abSJohan Hedberg hdev->discov_timeout = 0; 19585e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 1959310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 196016ab91abSJohan Hedberg } 196116ab91abSJohan Hedberg 1962a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 19637d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 19647d78525dSJohan Hedberg 19657ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 19667ba8b4beSAndre Guedes 196709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 19681f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 19691da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 197009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 19711da177e4SLinus Torvalds 19721da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 19731da177e4SLinus Torvalds 19741da177e4SLinus Torvalds if (hdev->flush) 19751da177e4SLinus Torvalds hdev->flush(hdev); 19761da177e4SLinus Torvalds 19771da177e4SLinus Torvalds /* Reset device */ 19781da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 19791da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 19808af59467SJohan Hedberg if (!test_bit(HCI_RAW, &hdev->flags) && 19813a6afbd2SMarcel Holtmann !test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 1982a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 19831da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 198401178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 19851da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 19861da177e4SLinus Torvalds } 19871da177e4SLinus Torvalds 1988c347b765SGustavo F. Padovan /* flush cmd work */ 1989c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 19901da177e4SLinus Torvalds 19911da177e4SLinus Torvalds /* Drop queues */ 19921da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 19931da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 19941da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 19951da177e4SLinus Torvalds 19961da177e4SLinus Torvalds /* Drop last sent command */ 19971da177e4SLinus Torvalds if (hdev->sent_cmd) { 1998b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 19991da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 20001da177e4SLinus Torvalds hdev->sent_cmd = NULL; 20011da177e4SLinus Torvalds } 20021da177e4SLinus Torvalds 2003b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 2004b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 2005b6ddb638SJohan Hedberg 20061da177e4SLinus Torvalds /* After this point our queues are empty 20071da177e4SLinus Torvalds * and no tasks are scheduled. */ 20081da177e4SLinus Torvalds hdev->close(hdev); 20091da177e4SLinus Torvalds 201035b973c9SJohan Hedberg /* Clear flags */ 201135b973c9SJohan Hedberg hdev->flags = 0; 201235b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 201335b973c9SJohan Hedberg 201493c311a0SMarcel Holtmann if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 201593c311a0SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 201609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2017744cf19eSJohan Hedberg mgmt_powered(hdev, 0); 201809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 20198ee56540SMarcel Holtmann } 202093c311a0SMarcel Holtmann } 20215add6af8SJohan Hedberg 2022ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 2023536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 2024ced5c338SAndrei Emeltchenko 2025e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 202609b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 2027e59fda8dSJohan Hedberg 20281da177e4SLinus Torvalds hci_req_unlock(hdev); 20291da177e4SLinus Torvalds 20301da177e4SLinus Torvalds hci_dev_put(hdev); 20311da177e4SLinus Torvalds return 0; 20321da177e4SLinus Torvalds } 20331da177e4SLinus Torvalds 20341da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 20351da177e4SLinus Torvalds { 20361da177e4SLinus Torvalds struct hci_dev *hdev; 20371da177e4SLinus Torvalds int err; 20381da177e4SLinus Torvalds 203970f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 204070f23020SAndrei Emeltchenko if (!hdev) 20411da177e4SLinus Torvalds return -ENODEV; 20428ee56540SMarcel Holtmann 20430736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 20440736cfa8SMarcel Holtmann err = -EBUSY; 20450736cfa8SMarcel Holtmann goto done; 20460736cfa8SMarcel Holtmann } 20470736cfa8SMarcel Holtmann 20488ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 20498ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 20508ee56540SMarcel Holtmann 20511da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 20528ee56540SMarcel Holtmann 20530736cfa8SMarcel Holtmann done: 20541da177e4SLinus Torvalds hci_dev_put(hdev); 20551da177e4SLinus Torvalds return err; 20561da177e4SLinus Torvalds } 20571da177e4SLinus Torvalds 20581da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 20591da177e4SLinus Torvalds { 20601da177e4SLinus Torvalds struct hci_dev *hdev; 20611da177e4SLinus Torvalds int ret = 0; 20621da177e4SLinus Torvalds 206370f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 206470f23020SAndrei Emeltchenko if (!hdev) 20651da177e4SLinus Torvalds return -ENODEV; 20661da177e4SLinus Torvalds 20671da177e4SLinus Torvalds hci_req_lock(hdev); 20681da177e4SLinus Torvalds 2069808a049eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 2070808a049eSMarcel Holtmann ret = -ENETDOWN; 20711da177e4SLinus Torvalds goto done; 2072808a049eSMarcel Holtmann } 20731da177e4SLinus Torvalds 20740736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 20750736cfa8SMarcel Holtmann ret = -EBUSY; 20760736cfa8SMarcel Holtmann goto done; 20770736cfa8SMarcel Holtmann } 20780736cfa8SMarcel Holtmann 20791da177e4SLinus Torvalds /* Drop queues */ 20801da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 20811da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 20821da177e4SLinus Torvalds 208309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 20841f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 20851da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 208609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 20871da177e4SLinus Torvalds 20881da177e4SLinus Torvalds if (hdev->flush) 20891da177e4SLinus Torvalds hdev->flush(hdev); 20901da177e4SLinus Torvalds 20911da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 20926ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 20931da177e4SLinus Torvalds 20941da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 209501178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 20961da177e4SLinus Torvalds 20971da177e4SLinus Torvalds done: 20981da177e4SLinus Torvalds hci_req_unlock(hdev); 20991da177e4SLinus Torvalds hci_dev_put(hdev); 21001da177e4SLinus Torvalds return ret; 21011da177e4SLinus Torvalds } 21021da177e4SLinus Torvalds 21031da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 21041da177e4SLinus Torvalds { 21051da177e4SLinus Torvalds struct hci_dev *hdev; 21061da177e4SLinus Torvalds int ret = 0; 21071da177e4SLinus Torvalds 210870f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 210970f23020SAndrei Emeltchenko if (!hdev) 21101da177e4SLinus Torvalds return -ENODEV; 21111da177e4SLinus Torvalds 21120736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 21130736cfa8SMarcel Holtmann ret = -EBUSY; 21140736cfa8SMarcel Holtmann goto done; 21150736cfa8SMarcel Holtmann } 21160736cfa8SMarcel Holtmann 21171da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 21181da177e4SLinus Torvalds 21190736cfa8SMarcel Holtmann done: 21201da177e4SLinus Torvalds hci_dev_put(hdev); 21211da177e4SLinus Torvalds return ret; 21221da177e4SLinus Torvalds } 21231da177e4SLinus Torvalds 21241da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 21251da177e4SLinus Torvalds { 21261da177e4SLinus Torvalds struct hci_dev *hdev; 21271da177e4SLinus Torvalds struct hci_dev_req dr; 21281da177e4SLinus Torvalds int err = 0; 21291da177e4SLinus Torvalds 21301da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 21311da177e4SLinus Torvalds return -EFAULT; 21321da177e4SLinus Torvalds 213370f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 213470f23020SAndrei Emeltchenko if (!hdev) 21351da177e4SLinus Torvalds return -ENODEV; 21361da177e4SLinus Torvalds 21370736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 21380736cfa8SMarcel Holtmann err = -EBUSY; 21390736cfa8SMarcel Holtmann goto done; 21400736cfa8SMarcel Holtmann } 21410736cfa8SMarcel Holtmann 21425b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 21435b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 21445b69bef5SMarcel Holtmann goto done; 21455b69bef5SMarcel Holtmann } 21465b69bef5SMarcel Holtmann 214756f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 214856f87901SJohan Hedberg err = -EOPNOTSUPP; 214956f87901SJohan Hedberg goto done; 215056f87901SJohan Hedberg } 215156f87901SJohan Hedberg 21521da177e4SLinus Torvalds switch (cmd) { 21531da177e4SLinus Torvalds case HCISETAUTH: 215401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 21555f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 21561da177e4SLinus Torvalds break; 21571da177e4SLinus Torvalds 21581da177e4SLinus Torvalds case HCISETENCRYPT: 21591da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 21601da177e4SLinus Torvalds err = -EOPNOTSUPP; 21611da177e4SLinus Torvalds break; 21621da177e4SLinus Torvalds } 21631da177e4SLinus Torvalds 21641da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 21651da177e4SLinus Torvalds /* Auth must be enabled first */ 216601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 21675f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 21681da177e4SLinus Torvalds if (err) 21691da177e4SLinus Torvalds break; 21701da177e4SLinus Torvalds } 21711da177e4SLinus Torvalds 217201178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 21735f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 21741da177e4SLinus Torvalds break; 21751da177e4SLinus Torvalds 21761da177e4SLinus Torvalds case HCISETSCAN: 217701178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 21785f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 21791da177e4SLinus Torvalds break; 21801da177e4SLinus Torvalds 21811da177e4SLinus Torvalds case HCISETLINKPOL: 218201178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 21835f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 21841da177e4SLinus Torvalds break; 21851da177e4SLinus Torvalds 21861da177e4SLinus Torvalds case HCISETLINKMODE: 2187e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 2188e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 2189e4e8e37cSMarcel Holtmann break; 2190e4e8e37cSMarcel Holtmann 2191e4e8e37cSMarcel Holtmann case HCISETPTYPE: 2192e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 21931da177e4SLinus Torvalds break; 21941da177e4SLinus Torvalds 21951da177e4SLinus Torvalds case HCISETACLMTU: 21961da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 21971da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 21981da177e4SLinus Torvalds break; 21991da177e4SLinus Torvalds 22001da177e4SLinus Torvalds case HCISETSCOMTU: 22011da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 22021da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 22031da177e4SLinus Torvalds break; 22041da177e4SLinus Torvalds 22051da177e4SLinus Torvalds default: 22061da177e4SLinus Torvalds err = -EINVAL; 22071da177e4SLinus Torvalds break; 22081da177e4SLinus Torvalds } 2209e4e8e37cSMarcel Holtmann 22100736cfa8SMarcel Holtmann done: 22111da177e4SLinus Torvalds hci_dev_put(hdev); 22121da177e4SLinus Torvalds return err; 22131da177e4SLinus Torvalds } 22141da177e4SLinus Torvalds 22151da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 22161da177e4SLinus Torvalds { 22178035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 22181da177e4SLinus Torvalds struct hci_dev_list_req *dl; 22191da177e4SLinus Torvalds struct hci_dev_req *dr; 22201da177e4SLinus Torvalds int n = 0, size, err; 22211da177e4SLinus Torvalds __u16 dev_num; 22221da177e4SLinus Torvalds 22231da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 22241da177e4SLinus Torvalds return -EFAULT; 22251da177e4SLinus Torvalds 22261da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 22271da177e4SLinus Torvalds return -EINVAL; 22281da177e4SLinus Torvalds 22291da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 22301da177e4SLinus Torvalds 223170f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 223270f23020SAndrei Emeltchenko if (!dl) 22331da177e4SLinus Torvalds return -ENOMEM; 22341da177e4SLinus Torvalds 22351da177e4SLinus Torvalds dr = dl->dev_req; 22361da177e4SLinus Torvalds 2237f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 22388035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 2239a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 2240e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->power_off); 2241c542a06cSJohan Hedberg 2242a8b2d5c2SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 2243a8b2d5c2SJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->dev_flags); 2244c542a06cSJohan Hedberg 22451da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 22461da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 2247c542a06cSJohan Hedberg 22481da177e4SLinus Torvalds if (++n >= dev_num) 22491da177e4SLinus Torvalds break; 22501da177e4SLinus Torvalds } 2251f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 22521da177e4SLinus Torvalds 22531da177e4SLinus Torvalds dl->dev_num = n; 22541da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 22551da177e4SLinus Torvalds 22561da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 22571da177e4SLinus Torvalds kfree(dl); 22581da177e4SLinus Torvalds 22591da177e4SLinus Torvalds return err ? -EFAULT : 0; 22601da177e4SLinus Torvalds } 22611da177e4SLinus Torvalds 22621da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 22631da177e4SLinus Torvalds { 22641da177e4SLinus Torvalds struct hci_dev *hdev; 22651da177e4SLinus Torvalds struct hci_dev_info di; 22661da177e4SLinus Torvalds int err = 0; 22671da177e4SLinus Torvalds 22681da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 22691da177e4SLinus Torvalds return -EFAULT; 22701da177e4SLinus Torvalds 227170f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 227270f23020SAndrei Emeltchenko if (!hdev) 22731da177e4SLinus Torvalds return -ENODEV; 22741da177e4SLinus Torvalds 2275a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 22763243553fSJohan Hedberg cancel_delayed_work_sync(&hdev->power_off); 2277ab81cbf9SJohan Hedberg 2278a8b2d5c2SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 2279a8b2d5c2SJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->dev_flags); 2280c542a06cSJohan Hedberg 22811da177e4SLinus Torvalds strcpy(di.name, hdev->name); 22821da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 228360f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 22841da177e4SLinus Torvalds di.flags = hdev->flags; 22851da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2286572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 22871da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 22881da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 22891da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 22901da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2291572c7f84SJohan Hedberg } else { 2292572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2293572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2294572c7f84SJohan Hedberg di.sco_mtu = 0; 2295572c7f84SJohan Hedberg di.sco_pkts = 0; 2296572c7f84SJohan Hedberg } 22971da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 22981da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 22991da177e4SLinus Torvalds 23001da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 23011da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 23021da177e4SLinus Torvalds 23031da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 23041da177e4SLinus Torvalds err = -EFAULT; 23051da177e4SLinus Torvalds 23061da177e4SLinus Torvalds hci_dev_put(hdev); 23071da177e4SLinus Torvalds 23081da177e4SLinus Torvalds return err; 23091da177e4SLinus Torvalds } 23101da177e4SLinus Torvalds 23111da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 23121da177e4SLinus Torvalds 2313611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2314611b30f7SMarcel Holtmann { 2315611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2316611b30f7SMarcel Holtmann 2317611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2318611b30f7SMarcel Holtmann 23190736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 23200736cfa8SMarcel Holtmann return -EBUSY; 23210736cfa8SMarcel Holtmann 23225e130367SJohan Hedberg if (blocked) { 23235e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 2324bf543036SJohan Hedberg if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 2325611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 23265e130367SJohan Hedberg } else { 23275e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 23285e130367SJohan Hedberg } 2329611b30f7SMarcel Holtmann 2330611b30f7SMarcel Holtmann return 0; 2331611b30f7SMarcel Holtmann } 2332611b30f7SMarcel Holtmann 2333611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2334611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2335611b30f7SMarcel Holtmann }; 2336611b30f7SMarcel Holtmann 2337ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2338ab81cbf9SJohan Hedberg { 2339ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 234096570ffcSJohan Hedberg int err; 2341ab81cbf9SJohan Hedberg 2342ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2343ab81cbf9SJohan Hedberg 2344cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 234596570ffcSJohan Hedberg if (err < 0) { 234696570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 2347ab81cbf9SJohan Hedberg return; 234896570ffcSJohan Hedberg } 2349ab81cbf9SJohan Hedberg 2350a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2351a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2352a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2353a5c8f270SMarcel Holtmann */ 2354a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 2355a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 2356a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2357a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2358bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2359bf543036SJohan Hedberg hci_dev_do_close(hdev); 2360bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 236119202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 236219202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2363bf543036SJohan Hedberg } 2364ab81cbf9SJohan Hedberg 2365a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) 2366744cf19eSJohan Hedberg mgmt_index_added(hdev); 2367ab81cbf9SJohan Hedberg } 2368ab81cbf9SJohan Hedberg 2369ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2370ab81cbf9SJohan Hedberg { 23713243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 23723243553fSJohan Hedberg power_off.work); 2373ab81cbf9SJohan Hedberg 2374ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2375ab81cbf9SJohan Hedberg 23768ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2377ab81cbf9SJohan Hedberg } 2378ab81cbf9SJohan Hedberg 237916ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 238016ab91abSJohan Hedberg { 238116ab91abSJohan Hedberg struct hci_dev *hdev; 238216ab91abSJohan Hedberg 238316ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 238416ab91abSJohan Hedberg 238516ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 238616ab91abSJohan Hedberg 2387d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 238816ab91abSJohan Hedberg } 238916ab91abSJohan Hedberg 23902aeb9a1aSJohan Hedberg int hci_uuids_clear(struct hci_dev *hdev) 23912aeb9a1aSJohan Hedberg { 23924821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 23932aeb9a1aSJohan Hedberg 23944821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 23954821002cSJohan Hedberg list_del(&uuid->list); 23962aeb9a1aSJohan Hedberg kfree(uuid); 23972aeb9a1aSJohan Hedberg } 23982aeb9a1aSJohan Hedberg 23992aeb9a1aSJohan Hedberg return 0; 24002aeb9a1aSJohan Hedberg } 24012aeb9a1aSJohan Hedberg 240255ed8ca1SJohan Hedberg int hci_link_keys_clear(struct hci_dev *hdev) 240355ed8ca1SJohan Hedberg { 240455ed8ca1SJohan Hedberg struct list_head *p, *n; 240555ed8ca1SJohan Hedberg 240655ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 240755ed8ca1SJohan Hedberg struct link_key *key; 240855ed8ca1SJohan Hedberg 240955ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 241055ed8ca1SJohan Hedberg 241155ed8ca1SJohan Hedberg list_del(p); 241255ed8ca1SJohan Hedberg kfree(key); 241355ed8ca1SJohan Hedberg } 241455ed8ca1SJohan Hedberg 241555ed8ca1SJohan Hedberg return 0; 241655ed8ca1SJohan Hedberg } 241755ed8ca1SJohan Hedberg 2418b899efafSVinicius Costa Gomes int hci_smp_ltks_clear(struct hci_dev *hdev) 2419b899efafSVinicius Costa Gomes { 2420b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 2421b899efafSVinicius Costa Gomes 2422b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 2423b899efafSVinicius Costa Gomes list_del(&k->list); 2424b899efafSVinicius Costa Gomes kfree(k); 2425b899efafSVinicius Costa Gomes } 2426b899efafSVinicius Costa Gomes 2427b899efafSVinicius Costa Gomes return 0; 2428b899efafSVinicius Costa Gomes } 2429b899efafSVinicius Costa Gomes 243055ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 243155ed8ca1SJohan Hedberg { 243255ed8ca1SJohan Hedberg struct link_key *k; 243355ed8ca1SJohan Hedberg 24348035ded4SLuiz Augusto von Dentz list_for_each_entry(k, &hdev->link_keys, list) 243555ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 243655ed8ca1SJohan Hedberg return k; 243755ed8ca1SJohan Hedberg 243855ed8ca1SJohan Hedberg return NULL; 243955ed8ca1SJohan Hedberg } 244055ed8ca1SJohan Hedberg 2441745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2442d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2443d25e28abSJohan Hedberg { 2444d25e28abSJohan Hedberg /* Legacy key */ 2445d25e28abSJohan Hedberg if (key_type < 0x03) 2446745c0ce3SVishal Agarwal return true; 2447d25e28abSJohan Hedberg 2448d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2449d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2450745c0ce3SVishal Agarwal return false; 2451d25e28abSJohan Hedberg 2452d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2453d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2454745c0ce3SVishal Agarwal return false; 2455d25e28abSJohan Hedberg 2456d25e28abSJohan Hedberg /* Security mode 3 case */ 2457d25e28abSJohan Hedberg if (!conn) 2458745c0ce3SVishal Agarwal return true; 2459d25e28abSJohan Hedberg 2460d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2461d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2462745c0ce3SVishal Agarwal return true; 2463d25e28abSJohan Hedberg 2464d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2465d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2466745c0ce3SVishal Agarwal return true; 2467d25e28abSJohan Hedberg 2468d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2469d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2470745c0ce3SVishal Agarwal return true; 2471d25e28abSJohan Hedberg 2472d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2473d25e28abSJohan Hedberg * persistently */ 2474745c0ce3SVishal Agarwal return false; 2475d25e28abSJohan Hedberg } 2476d25e28abSJohan Hedberg 2477c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8]) 247875d262c2SVinicius Costa Gomes { 2479c9839a11SVinicius Costa Gomes struct smp_ltk *k; 248075d262c2SVinicius Costa Gomes 2481c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) { 2482c9839a11SVinicius Costa Gomes if (k->ediv != ediv || 2483c9839a11SVinicius Costa Gomes memcmp(rand, k->rand, sizeof(k->rand))) 248475d262c2SVinicius Costa Gomes continue; 248575d262c2SVinicius Costa Gomes 248675d262c2SVinicius Costa Gomes return k; 248775d262c2SVinicius Costa Gomes } 248875d262c2SVinicius Costa Gomes 248975d262c2SVinicius Costa Gomes return NULL; 249075d262c2SVinicius Costa Gomes } 249175d262c2SVinicius Costa Gomes 2492c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2493c9839a11SVinicius Costa Gomes u8 addr_type) 249475d262c2SVinicius Costa Gomes { 2495c9839a11SVinicius Costa Gomes struct smp_ltk *k; 249675d262c2SVinicius Costa Gomes 2497c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) 2498c9839a11SVinicius Costa Gomes if (addr_type == k->bdaddr_type && 2499c9839a11SVinicius Costa Gomes bacmp(bdaddr, &k->bdaddr) == 0) 250075d262c2SVinicius Costa Gomes return k; 250175d262c2SVinicius Costa Gomes 250275d262c2SVinicius Costa Gomes return NULL; 250375d262c2SVinicius Costa Gomes } 250475d262c2SVinicius Costa Gomes 2505d25e28abSJohan Hedberg int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key, 2506d25e28abSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len) 250755ed8ca1SJohan Hedberg { 250855ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2509745c0ce3SVishal Agarwal u8 old_key_type; 2510745c0ce3SVishal Agarwal bool persistent; 251155ed8ca1SJohan Hedberg 251255ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 251355ed8ca1SJohan Hedberg if (old_key) { 251455ed8ca1SJohan Hedberg old_key_type = old_key->type; 251555ed8ca1SJohan Hedberg key = old_key; 251655ed8ca1SJohan Hedberg } else { 251712adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 251855ed8ca1SJohan Hedberg key = kzalloc(sizeof(*key), GFP_ATOMIC); 251955ed8ca1SJohan Hedberg if (!key) 252055ed8ca1SJohan Hedberg return -ENOMEM; 252155ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 252255ed8ca1SJohan Hedberg } 252355ed8ca1SJohan Hedberg 25246ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 252555ed8ca1SJohan Hedberg 2526d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2527d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2528d25e28abSJohan Hedberg * previous key */ 2529d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2530a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2531d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2532655fe6ecSJohan Hedberg if (conn) 2533655fe6ecSJohan Hedberg conn->key_type = type; 2534655fe6ecSJohan Hedberg } 2535d25e28abSJohan Hedberg 253655ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 25379b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 253855ed8ca1SJohan Hedberg key->pin_len = pin_len; 253955ed8ca1SJohan Hedberg 2540b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 254155ed8ca1SJohan Hedberg key->type = old_key_type; 25424748fed2SJohan Hedberg else 25434748fed2SJohan Hedberg key->type = type; 25444748fed2SJohan Hedberg 25454df378a1SJohan Hedberg if (!new_key) 25464df378a1SJohan Hedberg return 0; 25474df378a1SJohan Hedberg 25484df378a1SJohan Hedberg persistent = hci_persistent_key(hdev, conn, type, old_key_type); 25494df378a1SJohan Hedberg 2550744cf19eSJohan Hedberg mgmt_new_link_key(hdev, key, persistent); 25514df378a1SJohan Hedberg 25526ec5bcadSVishal Agarwal if (conn) 25536ec5bcadSVishal Agarwal conn->flush_key = !persistent; 255455ed8ca1SJohan Hedberg 255555ed8ca1SJohan Hedberg return 0; 255655ed8ca1SJohan Hedberg } 255755ed8ca1SJohan Hedberg 2558c9839a11SVinicius Costa Gomes int hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type, u8 type, 25599a006657SAndrei Emeltchenko int new_key, u8 authenticated, u8 tk[16], u8 enc_size, __le16 256004124681SGustavo F. Padovan ediv, u8 rand[8]) 256175d262c2SVinicius Costa Gomes { 2562c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 256375d262c2SVinicius Costa Gomes 2564c9839a11SVinicius Costa Gomes if (!(type & HCI_SMP_STK) && !(type & HCI_SMP_LTK)) 2565c9839a11SVinicius Costa Gomes return 0; 256675d262c2SVinicius Costa Gomes 2567c9839a11SVinicius Costa Gomes old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type); 2568c9839a11SVinicius Costa Gomes if (old_key) 256975d262c2SVinicius Costa Gomes key = old_key; 2570c9839a11SVinicius Costa Gomes else { 2571c9839a11SVinicius Costa Gomes key = kzalloc(sizeof(*key), GFP_ATOMIC); 257275d262c2SVinicius Costa Gomes if (!key) 257375d262c2SVinicius Costa Gomes return -ENOMEM; 2574c9839a11SVinicius Costa Gomes list_add(&key->list, &hdev->long_term_keys); 257575d262c2SVinicius Costa Gomes } 257675d262c2SVinicius Costa Gomes 257775d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2578c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2579c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2580c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2581c9839a11SVinicius Costa Gomes key->ediv = ediv; 2582c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2583c9839a11SVinicius Costa Gomes key->type = type; 2584c9839a11SVinicius Costa Gomes memcpy(key->rand, rand, sizeof(key->rand)); 258575d262c2SVinicius Costa Gomes 2586c9839a11SVinicius Costa Gomes if (!new_key) 2587c9839a11SVinicius Costa Gomes return 0; 258875d262c2SVinicius Costa Gomes 2589261cc5aaSVinicius Costa Gomes if (type & HCI_SMP_LTK) 2590261cc5aaSVinicius Costa Gomes mgmt_new_ltk(hdev, key, 1); 2591261cc5aaSVinicius Costa Gomes 259275d262c2SVinicius Costa Gomes return 0; 259375d262c2SVinicius Costa Gomes } 259475d262c2SVinicius Costa Gomes 259555ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 259655ed8ca1SJohan Hedberg { 259755ed8ca1SJohan Hedberg struct link_key *key; 259855ed8ca1SJohan Hedberg 259955ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 260055ed8ca1SJohan Hedberg if (!key) 260155ed8ca1SJohan Hedberg return -ENOENT; 260255ed8ca1SJohan Hedberg 26036ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 260455ed8ca1SJohan Hedberg 260555ed8ca1SJohan Hedberg list_del(&key->list); 260655ed8ca1SJohan Hedberg kfree(key); 260755ed8ca1SJohan Hedberg 260855ed8ca1SJohan Hedberg return 0; 260955ed8ca1SJohan Hedberg } 261055ed8ca1SJohan Hedberg 2611b899efafSVinicius Costa Gomes int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr) 2612b899efafSVinicius Costa Gomes { 2613b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 2614b899efafSVinicius Costa Gomes 2615b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 2616b899efafSVinicius Costa Gomes if (bacmp(bdaddr, &k->bdaddr)) 2617b899efafSVinicius Costa Gomes continue; 2618b899efafSVinicius Costa Gomes 26196ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2620b899efafSVinicius Costa Gomes 2621b899efafSVinicius Costa Gomes list_del(&k->list); 2622b899efafSVinicius Costa Gomes kfree(k); 2623b899efafSVinicius Costa Gomes } 2624b899efafSVinicius Costa Gomes 2625b899efafSVinicius Costa Gomes return 0; 2626b899efafSVinicius Costa Gomes } 2627b899efafSVinicius Costa Gomes 26286bd32326SVille Tervo /* HCI command timer function */ 2629bda4f23aSAndrei Emeltchenko static void hci_cmd_timeout(unsigned long arg) 26306bd32326SVille Tervo { 26316bd32326SVille Tervo struct hci_dev *hdev = (void *) arg; 26326bd32326SVille Tervo 2633bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2634bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2635bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2636bda4f23aSAndrei Emeltchenko 2637bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 2638bda4f23aSAndrei Emeltchenko } else { 26396bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 2640bda4f23aSAndrei Emeltchenko } 2641bda4f23aSAndrei Emeltchenko 26426bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2643c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 26446bd32326SVille Tervo } 26456bd32326SVille Tervo 26462763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 26472763eda6SSzymon Janc bdaddr_t *bdaddr) 26482763eda6SSzymon Janc { 26492763eda6SSzymon Janc struct oob_data *data; 26502763eda6SSzymon Janc 26512763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 26522763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 26532763eda6SSzymon Janc return data; 26542763eda6SSzymon Janc 26552763eda6SSzymon Janc return NULL; 26562763eda6SSzymon Janc } 26572763eda6SSzymon Janc 26582763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 26592763eda6SSzymon Janc { 26602763eda6SSzymon Janc struct oob_data *data; 26612763eda6SSzymon Janc 26622763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 26632763eda6SSzymon Janc if (!data) 26642763eda6SSzymon Janc return -ENOENT; 26652763eda6SSzymon Janc 26666ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 26672763eda6SSzymon Janc 26682763eda6SSzymon Janc list_del(&data->list); 26692763eda6SSzymon Janc kfree(data); 26702763eda6SSzymon Janc 26712763eda6SSzymon Janc return 0; 26722763eda6SSzymon Janc } 26732763eda6SSzymon Janc 26742763eda6SSzymon Janc int hci_remote_oob_data_clear(struct hci_dev *hdev) 26752763eda6SSzymon Janc { 26762763eda6SSzymon Janc struct oob_data *data, *n; 26772763eda6SSzymon Janc 26782763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 26792763eda6SSzymon Janc list_del(&data->list); 26802763eda6SSzymon Janc kfree(data); 26812763eda6SSzymon Janc } 26822763eda6SSzymon Janc 26832763eda6SSzymon Janc return 0; 26842763eda6SSzymon Janc } 26852763eda6SSzymon Janc 26862763eda6SSzymon Janc int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash, 26872763eda6SSzymon Janc u8 *randomizer) 26882763eda6SSzymon Janc { 26892763eda6SSzymon Janc struct oob_data *data; 26902763eda6SSzymon Janc 26912763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 26922763eda6SSzymon Janc 26932763eda6SSzymon Janc if (!data) { 26942763eda6SSzymon Janc data = kmalloc(sizeof(*data), GFP_ATOMIC); 26952763eda6SSzymon Janc if (!data) 26962763eda6SSzymon Janc return -ENOMEM; 26972763eda6SSzymon Janc 26982763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 26992763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 27002763eda6SSzymon Janc } 27012763eda6SSzymon Janc 27022763eda6SSzymon Janc memcpy(data->hash, hash, sizeof(data->hash)); 27032763eda6SSzymon Janc memcpy(data->randomizer, randomizer, sizeof(data->randomizer)); 27042763eda6SSzymon Janc 27056ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 27062763eda6SSzymon Janc 27072763eda6SSzymon Janc return 0; 27082763eda6SSzymon Janc } 27092763eda6SSzymon Janc 2710b9ee0a78SMarcel Holtmann struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev, 2711b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2712b2a66aadSAntti Julku { 2713b2a66aadSAntti Julku struct bdaddr_list *b; 2714b2a66aadSAntti Julku 2715b9ee0a78SMarcel Holtmann list_for_each_entry(b, &hdev->blacklist, list) { 2716b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2717b2a66aadSAntti Julku return b; 2718b9ee0a78SMarcel Holtmann } 2719b2a66aadSAntti Julku 2720b2a66aadSAntti Julku return NULL; 2721b2a66aadSAntti Julku } 2722b2a66aadSAntti Julku 2723b2a66aadSAntti Julku int hci_blacklist_clear(struct hci_dev *hdev) 2724b2a66aadSAntti Julku { 2725b2a66aadSAntti Julku struct list_head *p, *n; 2726b2a66aadSAntti Julku 2727b2a66aadSAntti Julku list_for_each_safe(p, n, &hdev->blacklist) { 2728b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 2729b2a66aadSAntti Julku 2730b2a66aadSAntti Julku list_del(p); 2731b2a66aadSAntti Julku kfree(b); 2732b2a66aadSAntti Julku } 2733b2a66aadSAntti Julku 2734b2a66aadSAntti Julku return 0; 2735b2a66aadSAntti Julku } 2736b2a66aadSAntti Julku 273788c1fe4bSJohan Hedberg int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 2738b2a66aadSAntti Julku { 2739b2a66aadSAntti Julku struct bdaddr_list *entry; 2740b2a66aadSAntti Julku 2741b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2742b2a66aadSAntti Julku return -EBADF; 2743b2a66aadSAntti Julku 2744b9ee0a78SMarcel Holtmann if (hci_blacklist_lookup(hdev, bdaddr, type)) 27455e762444SAntti Julku return -EEXIST; 2746b2a66aadSAntti Julku 2747b2a66aadSAntti Julku entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL); 27485e762444SAntti Julku if (!entry) 27495e762444SAntti Julku return -ENOMEM; 2750b2a66aadSAntti Julku 2751b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2752b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2753b2a66aadSAntti Julku 2754b2a66aadSAntti Julku list_add(&entry->list, &hdev->blacklist); 2755b2a66aadSAntti Julku 275688c1fe4bSJohan Hedberg return mgmt_device_blocked(hdev, bdaddr, type); 2757b2a66aadSAntti Julku } 2758b2a66aadSAntti Julku 275988c1fe4bSJohan Hedberg int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 2760b2a66aadSAntti Julku { 2761b2a66aadSAntti Julku struct bdaddr_list *entry; 2762b2a66aadSAntti Julku 2763b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 27645e762444SAntti Julku return hci_blacklist_clear(hdev); 2765b2a66aadSAntti Julku 2766b9ee0a78SMarcel Holtmann entry = hci_blacklist_lookup(hdev, bdaddr, type); 27671ec918ceSSzymon Janc if (!entry) 27685e762444SAntti Julku return -ENOENT; 2769b2a66aadSAntti Julku 2770b2a66aadSAntti Julku list_del(&entry->list); 2771b2a66aadSAntti Julku kfree(entry); 2772b2a66aadSAntti Julku 277388c1fe4bSJohan Hedberg return mgmt_device_unblocked(hdev, bdaddr, type); 2774b2a66aadSAntti Julku } 2775b2a66aadSAntti Julku 27764c87eaabSAndre Guedes static void inquiry_complete(struct hci_dev *hdev, u8 status) 27777ba8b4beSAndre Guedes { 27784c87eaabSAndre Guedes if (status) { 27794c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 27807ba8b4beSAndre Guedes 27814c87eaabSAndre Guedes hci_dev_lock(hdev); 27824c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 27834c87eaabSAndre Guedes hci_dev_unlock(hdev); 27844c87eaabSAndre Guedes return; 27854c87eaabSAndre Guedes } 27867ba8b4beSAndre Guedes } 27877ba8b4beSAndre Guedes 27884c87eaabSAndre Guedes static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status) 27897ba8b4beSAndre Guedes { 27904c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 27914c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 27924c87eaabSAndre Guedes struct hci_request req; 27934c87eaabSAndre Guedes struct hci_cp_inquiry cp; 27947ba8b4beSAndre Guedes int err; 27957ba8b4beSAndre Guedes 27964c87eaabSAndre Guedes if (status) { 27974c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 27984c87eaabSAndre Guedes return; 27997ba8b4beSAndre Guedes } 28007ba8b4beSAndre Guedes 28014c87eaabSAndre Guedes switch (hdev->discovery.type) { 28024c87eaabSAndre Guedes case DISCOV_TYPE_LE: 28034c87eaabSAndre Guedes hci_dev_lock(hdev); 28044c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 28054c87eaabSAndre Guedes hci_dev_unlock(hdev); 28064c87eaabSAndre Guedes break; 28077dbfac1dSAndre Guedes 28084c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 28094c87eaabSAndre Guedes hci_req_init(&req, hdev); 28107dbfac1dSAndre Guedes 28117dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 28124c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 28134c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 28144c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 28154c87eaabSAndre Guedes 28164c87eaabSAndre Guedes hci_dev_lock(hdev); 28174c87eaabSAndre Guedes 28184c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 28194c87eaabSAndre Guedes 28204c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 28214c87eaabSAndre Guedes if (err) { 28224c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 28234c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 28247dbfac1dSAndre Guedes } 28257dbfac1dSAndre Guedes 28264c87eaabSAndre Guedes hci_dev_unlock(hdev); 28274c87eaabSAndre Guedes break; 28284c87eaabSAndre Guedes } 28297dbfac1dSAndre Guedes } 28307dbfac1dSAndre Guedes 28317ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 28327ba8b4beSAndre Guedes { 28337ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 28347ba8b4beSAndre Guedes le_scan_disable.work); 28357ba8b4beSAndre Guedes struct hci_cp_le_set_scan_enable cp; 28364c87eaabSAndre Guedes struct hci_request req; 28374c87eaabSAndre Guedes int err; 28387ba8b4beSAndre Guedes 28397ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 28407ba8b4beSAndre Guedes 28414c87eaabSAndre Guedes hci_req_init(&req, hdev); 28427ba8b4beSAndre Guedes 28437ba8b4beSAndre Guedes memset(&cp, 0, sizeof(cp)); 28444c87eaabSAndre Guedes cp.enable = LE_SCAN_DISABLE; 28454c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 28467ba8b4beSAndre Guedes 28474c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 28484c87eaabSAndre Guedes if (err) 28494c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 285028b75a89SAndre Guedes } 285128b75a89SAndre Guedes 28529be0dab7SDavid Herrmann /* Alloc HCI device */ 28539be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 28549be0dab7SDavid Herrmann { 28559be0dab7SDavid Herrmann struct hci_dev *hdev; 28569be0dab7SDavid Herrmann 28579be0dab7SDavid Herrmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 28589be0dab7SDavid Herrmann if (!hdev) 28599be0dab7SDavid Herrmann return NULL; 28609be0dab7SDavid Herrmann 2861b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 2862b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 2863b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 2864b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 2865b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 2866bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 2867bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 2868b1b813d4SDavid Herrmann 2869b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 2870b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 2871b1b813d4SDavid Herrmann 2872bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 2873bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 28744e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 28754e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 2876bef64738SMarcel Holtmann 2877b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 2878b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 2879b1b813d4SDavid Herrmann 2880b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 2881b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 2882b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 2883b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 2884b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 2885b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 28866b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 2887b1b813d4SDavid Herrmann 2888b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 2889b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 2890b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 2891b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 2892b1b813d4SDavid Herrmann 2893b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 2894b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 2895b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 2896b1b813d4SDavid Herrmann 2897b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 2898b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 2899b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 2900b1b813d4SDavid Herrmann 2901b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 2902b1b813d4SDavid Herrmann 2903bda4f23aSAndrei Emeltchenko setup_timer(&hdev->cmd_timer, hci_cmd_timeout, (unsigned long) hdev); 2904b1b813d4SDavid Herrmann 2905b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 2906b1b813d4SDavid Herrmann discovery_init(hdev); 29079be0dab7SDavid Herrmann 29089be0dab7SDavid Herrmann return hdev; 29099be0dab7SDavid Herrmann } 29109be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 29119be0dab7SDavid Herrmann 29129be0dab7SDavid Herrmann /* Free HCI device */ 29139be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 29149be0dab7SDavid Herrmann { 29159be0dab7SDavid Herrmann /* will free via device release */ 29169be0dab7SDavid Herrmann put_device(&hdev->dev); 29179be0dab7SDavid Herrmann } 29189be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 29199be0dab7SDavid Herrmann 29201da177e4SLinus Torvalds /* Register HCI device */ 29211da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 29221da177e4SLinus Torvalds { 2923b1b813d4SDavid Herrmann int id, error; 29241da177e4SLinus Torvalds 2925010666a1SDavid Herrmann if (!hdev->open || !hdev->close) 29261da177e4SLinus Torvalds return -EINVAL; 29271da177e4SLinus Torvalds 292808add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 292908add513SMat Martineau * so the index can be used as the AMP controller ID. 293008add513SMat Martineau */ 29313df92b31SSasha Levin switch (hdev->dev_type) { 29323df92b31SSasha Levin case HCI_BREDR: 29333df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 29341da177e4SLinus Torvalds break; 29353df92b31SSasha Levin case HCI_AMP: 29363df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 29373df92b31SSasha Levin break; 29383df92b31SSasha Levin default: 29393df92b31SSasha Levin return -EINVAL; 29401da177e4SLinus Torvalds } 29411da177e4SLinus Torvalds 29423df92b31SSasha Levin if (id < 0) 29433df92b31SSasha Levin return id; 29443df92b31SSasha Levin 29451da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 29461da177e4SLinus Torvalds hdev->id = id; 29472d8b3a11SAndrei Emeltchenko 29482d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 29492d8b3a11SAndrei Emeltchenko 2950d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 2951d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 295233ca954dSDavid Herrmann if (!hdev->workqueue) { 295333ca954dSDavid Herrmann error = -ENOMEM; 295433ca954dSDavid Herrmann goto err; 295533ca954dSDavid Herrmann } 2956f48fd9c8SMarcel Holtmann 2957d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 2958d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 29596ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 29606ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 29616ead1bbcSJohan Hedberg error = -ENOMEM; 29626ead1bbcSJohan Hedberg goto err; 29636ead1bbcSJohan Hedberg } 29646ead1bbcSJohan Hedberg 29650153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 29660153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 29670153e2ecSMarcel Holtmann 2968bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 2969bdc3e0f1SMarcel Holtmann 2970bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 297133ca954dSDavid Herrmann if (error < 0) 297233ca954dSDavid Herrmann goto err_wqueue; 29731da177e4SLinus Torvalds 2974611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 2975a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 2976a8c5fb1aSGustavo Padovan hdev); 2977611b30f7SMarcel Holtmann if (hdev->rfkill) { 2978611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 2979611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 2980611b30f7SMarcel Holtmann hdev->rfkill = NULL; 2981611b30f7SMarcel Holtmann } 2982611b30f7SMarcel Holtmann } 2983611b30f7SMarcel Holtmann 29845e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 29855e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 29865e130367SJohan Hedberg 2987a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 2988004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2989ce2be9acSAndrei Emeltchenko 299001cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 299156f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 299256f87901SJohan Hedberg * through reading supported features during init. 299356f87901SJohan Hedberg */ 299456f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 299556f87901SJohan Hedberg } 2996ce2be9acSAndrei Emeltchenko 2997fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 2998fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 2999fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3000fcee3377SGustavo Padovan 30011da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 3002dc946bd8SDavid Herrmann hci_dev_hold(hdev); 30031da177e4SLinus Torvalds 300419202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3005fbe96d6fSMarcel Holtmann 30061da177e4SLinus Torvalds return id; 3007f48fd9c8SMarcel Holtmann 300833ca954dSDavid Herrmann err_wqueue: 300933ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 30106ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 301133ca954dSDavid Herrmann err: 30123df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3013f48fd9c8SMarcel Holtmann 301433ca954dSDavid Herrmann return error; 30151da177e4SLinus Torvalds } 30161da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 30171da177e4SLinus Torvalds 30181da177e4SLinus Torvalds /* Unregister HCI device */ 301959735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 30201da177e4SLinus Torvalds { 30213df92b31SSasha Levin int i, id; 3022ef222013SMarcel Holtmann 3023c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 30241da177e4SLinus Torvalds 302594324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 302694324962SJohan Hovold 30273df92b31SSasha Levin id = hdev->id; 30283df92b31SSasha Levin 3029f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 30301da177e4SLinus Torvalds list_del(&hdev->list); 3031f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 30321da177e4SLinus Torvalds 30331da177e4SLinus Torvalds hci_dev_do_close(hdev); 30341da177e4SLinus Torvalds 3035cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 3036ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 3037ef222013SMarcel Holtmann 3038b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3039b9b5ef18SGustavo Padovan 3040ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3041a8b2d5c2SJohan Hedberg !test_bit(HCI_SETUP, &hdev->dev_flags)) { 304209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3043744cf19eSJohan Hedberg mgmt_index_removed(hdev); 304409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 304556e5cb86SJohan Hedberg } 3046ab81cbf9SJohan Hedberg 30472e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 30482e58ef3eSJohan Hedberg * pending list */ 30492e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 30502e58ef3eSJohan Hedberg 30511da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 30521da177e4SLinus Torvalds 3053611b30f7SMarcel Holtmann if (hdev->rfkill) { 3054611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3055611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3056611b30f7SMarcel Holtmann } 3057611b30f7SMarcel Holtmann 3058bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 3059147e2d59SDave Young 30600153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 30610153e2ecSMarcel Holtmann 3062f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 30636ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 3064f48fd9c8SMarcel Holtmann 306509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3066e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 30672aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 306855ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 3069b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 30702763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 307109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 3072e2e0cacbSJohan Hedberg 3073dc946bd8SDavid Herrmann hci_dev_put(hdev); 30743df92b31SSasha Levin 30753df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 30761da177e4SLinus Torvalds } 30771da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 30781da177e4SLinus Torvalds 30791da177e4SLinus Torvalds /* Suspend HCI device */ 30801da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 30811da177e4SLinus Torvalds { 30821da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 30831da177e4SLinus Torvalds return 0; 30841da177e4SLinus Torvalds } 30851da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 30861da177e4SLinus Torvalds 30871da177e4SLinus Torvalds /* Resume HCI device */ 30881da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 30891da177e4SLinus Torvalds { 30901da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 30911da177e4SLinus Torvalds return 0; 30921da177e4SLinus Torvalds } 30931da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 30941da177e4SLinus Torvalds 309576bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 3096e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 309776bca880SMarcel Holtmann { 309876bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 309976bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 310076bca880SMarcel Holtmann kfree_skb(skb); 310176bca880SMarcel Holtmann return -ENXIO; 310276bca880SMarcel Holtmann } 310376bca880SMarcel Holtmann 3104d82603c6SJorrit Schippers /* Incoming skb */ 310576bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 310676bca880SMarcel Holtmann 310776bca880SMarcel Holtmann /* Time stamp */ 310876bca880SMarcel Holtmann __net_timestamp(skb); 310976bca880SMarcel Holtmann 311076bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3111b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3112c78ae283SMarcel Holtmann 311376bca880SMarcel Holtmann return 0; 311476bca880SMarcel Holtmann } 311576bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 311676bca880SMarcel Holtmann 311733e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 31181e429f38SGustavo F. Padovan int count, __u8 index) 311933e882a5SSuraj Sumangala { 312033e882a5SSuraj Sumangala int len = 0; 312133e882a5SSuraj Sumangala int hlen = 0; 312233e882a5SSuraj Sumangala int remain = count; 312333e882a5SSuraj Sumangala struct sk_buff *skb; 312433e882a5SSuraj Sumangala struct bt_skb_cb *scb; 312533e882a5SSuraj Sumangala 312633e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 312733e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 312833e882a5SSuraj Sumangala return -EILSEQ; 312933e882a5SSuraj Sumangala 313033e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 313133e882a5SSuraj Sumangala 313233e882a5SSuraj Sumangala if (!skb) { 313333e882a5SSuraj Sumangala switch (type) { 313433e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 313533e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 313633e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 313733e882a5SSuraj Sumangala break; 313833e882a5SSuraj Sumangala case HCI_EVENT_PKT: 313933e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 314033e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 314133e882a5SSuraj Sumangala break; 314233e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 314333e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 314433e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 314533e882a5SSuraj Sumangala break; 314633e882a5SSuraj Sumangala } 314733e882a5SSuraj Sumangala 31481e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 314933e882a5SSuraj Sumangala if (!skb) 315033e882a5SSuraj Sumangala return -ENOMEM; 315133e882a5SSuraj Sumangala 315233e882a5SSuraj Sumangala scb = (void *) skb->cb; 315333e882a5SSuraj Sumangala scb->expect = hlen; 315433e882a5SSuraj Sumangala scb->pkt_type = type; 315533e882a5SSuraj Sumangala 315633e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 315733e882a5SSuraj Sumangala } 315833e882a5SSuraj Sumangala 315933e882a5SSuraj Sumangala while (count) { 316033e882a5SSuraj Sumangala scb = (void *) skb->cb; 316189bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 316233e882a5SSuraj Sumangala 316333e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 316433e882a5SSuraj Sumangala 316533e882a5SSuraj Sumangala count -= len; 316633e882a5SSuraj Sumangala data += len; 316733e882a5SSuraj Sumangala scb->expect -= len; 316833e882a5SSuraj Sumangala remain = count; 316933e882a5SSuraj Sumangala 317033e882a5SSuraj Sumangala switch (type) { 317133e882a5SSuraj Sumangala case HCI_EVENT_PKT: 317233e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 317333e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 317433e882a5SSuraj Sumangala scb->expect = h->plen; 317533e882a5SSuraj Sumangala 317633e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 317733e882a5SSuraj Sumangala kfree_skb(skb); 317833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 317933e882a5SSuraj Sumangala return -ENOMEM; 318033e882a5SSuraj Sumangala } 318133e882a5SSuraj Sumangala } 318233e882a5SSuraj Sumangala break; 318333e882a5SSuraj Sumangala 318433e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 318533e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 318633e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 318733e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 318833e882a5SSuraj Sumangala 318933e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 319033e882a5SSuraj Sumangala kfree_skb(skb); 319133e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 319233e882a5SSuraj Sumangala return -ENOMEM; 319333e882a5SSuraj Sumangala } 319433e882a5SSuraj Sumangala } 319533e882a5SSuraj Sumangala break; 319633e882a5SSuraj Sumangala 319733e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 319833e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 319933e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 320033e882a5SSuraj Sumangala scb->expect = h->dlen; 320133e882a5SSuraj Sumangala 320233e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 320333e882a5SSuraj Sumangala kfree_skb(skb); 320433e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 320533e882a5SSuraj Sumangala return -ENOMEM; 320633e882a5SSuraj Sumangala } 320733e882a5SSuraj Sumangala } 320833e882a5SSuraj Sumangala break; 320933e882a5SSuraj Sumangala } 321033e882a5SSuraj Sumangala 321133e882a5SSuraj Sumangala if (scb->expect == 0) { 321233e882a5SSuraj Sumangala /* Complete frame */ 321333e882a5SSuraj Sumangala 321433e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 3215e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 321633e882a5SSuraj Sumangala 321733e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 321833e882a5SSuraj Sumangala return remain; 321933e882a5SSuraj Sumangala } 322033e882a5SSuraj Sumangala } 322133e882a5SSuraj Sumangala 322233e882a5SSuraj Sumangala return remain; 322333e882a5SSuraj Sumangala } 322433e882a5SSuraj Sumangala 3225ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 3226ef222013SMarcel Holtmann { 3227f39a3c06SSuraj Sumangala int rem = 0; 3228f39a3c06SSuraj Sumangala 3229ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 3230ef222013SMarcel Holtmann return -EILSEQ; 3231ef222013SMarcel Holtmann 3232da5f6c37SGustavo F. Padovan while (count) { 32331e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, type - 1); 3234f39a3c06SSuraj Sumangala if (rem < 0) 3235f39a3c06SSuraj Sumangala return rem; 3236ef222013SMarcel Holtmann 3237f39a3c06SSuraj Sumangala data += (count - rem); 3238f39a3c06SSuraj Sumangala count = rem; 3239f81c6224SJoe Perches } 3240ef222013SMarcel Holtmann 3241f39a3c06SSuraj Sumangala return rem; 3242ef222013SMarcel Holtmann } 3243ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 3244ef222013SMarcel Holtmann 324599811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 324699811510SSuraj Sumangala 324799811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 324899811510SSuraj Sumangala { 324999811510SSuraj Sumangala int type; 325099811510SSuraj Sumangala int rem = 0; 325199811510SSuraj Sumangala 3252da5f6c37SGustavo F. Padovan while (count) { 325399811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 325499811510SSuraj Sumangala 325599811510SSuraj Sumangala if (!skb) { 325699811510SSuraj Sumangala struct { char type; } *pkt; 325799811510SSuraj Sumangala 325899811510SSuraj Sumangala /* Start of the frame */ 325999811510SSuraj Sumangala pkt = data; 326099811510SSuraj Sumangala type = pkt->type; 326199811510SSuraj Sumangala 326299811510SSuraj Sumangala data++; 326399811510SSuraj Sumangala count--; 326499811510SSuraj Sumangala } else 326599811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 326699811510SSuraj Sumangala 32671e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 32681e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 326999811510SSuraj Sumangala if (rem < 0) 327099811510SSuraj Sumangala return rem; 327199811510SSuraj Sumangala 327299811510SSuraj Sumangala data += (count - rem); 327399811510SSuraj Sumangala count = rem; 3274f81c6224SJoe Perches } 327599811510SSuraj Sumangala 327699811510SSuraj Sumangala return rem; 327799811510SSuraj Sumangala } 327899811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 327999811510SSuraj Sumangala 32801da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 32811da177e4SLinus Torvalds 32821da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 32831da177e4SLinus Torvalds { 32841da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 32851da177e4SLinus Torvalds 3286f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 32871da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 3288f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 32891da177e4SLinus Torvalds 32901da177e4SLinus Torvalds return 0; 32911da177e4SLinus Torvalds } 32921da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 32931da177e4SLinus Torvalds 32941da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 32951da177e4SLinus Torvalds { 32961da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 32971da177e4SLinus Torvalds 3298f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 32991da177e4SLinus Torvalds list_del(&cb->list); 3300f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 33011da177e4SLinus Torvalds 33021da177e4SLinus Torvalds return 0; 33031da177e4SLinus Torvalds } 33041da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 33051da177e4SLinus Torvalds 330651086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 33071da177e4SLinus Torvalds { 33080d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 33091da177e4SLinus Torvalds 33101da177e4SLinus Torvalds /* Time stamp */ 3311a61bbcf2SPatrick McHardy __net_timestamp(skb); 33121da177e4SLinus Torvalds 3313cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3314cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3315cd82e61cSMarcel Holtmann 3316cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3317cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3318470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 33191da177e4SLinus Torvalds } 33201da177e4SLinus Torvalds 33211da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 33221da177e4SLinus Torvalds skb_orphan(skb); 33231da177e4SLinus Torvalds 33247bd8f09fSMarcel Holtmann if (hdev->send(hdev, skb) < 0) 332551086991SMarcel Holtmann BT_ERR("%s sending frame failed", hdev->name); 33261da177e4SLinus Torvalds } 33271da177e4SLinus Torvalds 33283119ae95SJohan Hedberg void hci_req_init(struct hci_request *req, struct hci_dev *hdev) 33293119ae95SJohan Hedberg { 33303119ae95SJohan Hedberg skb_queue_head_init(&req->cmd_q); 33313119ae95SJohan Hedberg req->hdev = hdev; 33325d73e034SAndre Guedes req->err = 0; 33333119ae95SJohan Hedberg } 33343119ae95SJohan Hedberg 33353119ae95SJohan Hedberg int hci_req_run(struct hci_request *req, hci_req_complete_t complete) 33363119ae95SJohan Hedberg { 33373119ae95SJohan Hedberg struct hci_dev *hdev = req->hdev; 33383119ae95SJohan Hedberg struct sk_buff *skb; 33393119ae95SJohan Hedberg unsigned long flags; 33403119ae95SJohan Hedberg 33413119ae95SJohan Hedberg BT_DBG("length %u", skb_queue_len(&req->cmd_q)); 33423119ae95SJohan Hedberg 33435d73e034SAndre Guedes /* If an error occured during request building, remove all HCI 33445d73e034SAndre Guedes * commands queued on the HCI request queue. 33455d73e034SAndre Guedes */ 33465d73e034SAndre Guedes if (req->err) { 33475d73e034SAndre Guedes skb_queue_purge(&req->cmd_q); 33485d73e034SAndre Guedes return req->err; 33495d73e034SAndre Guedes } 33505d73e034SAndre Guedes 33513119ae95SJohan Hedberg /* Do not allow empty requests */ 33523119ae95SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 3353382b0c39SAndre Guedes return -ENODATA; 33543119ae95SJohan Hedberg 33553119ae95SJohan Hedberg skb = skb_peek_tail(&req->cmd_q); 33563119ae95SJohan Hedberg bt_cb(skb)->req.complete = complete; 33573119ae95SJohan Hedberg 33583119ae95SJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 33593119ae95SJohan Hedberg skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q); 33603119ae95SJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 33613119ae95SJohan Hedberg 33623119ae95SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 33633119ae95SJohan Hedberg 33643119ae95SJohan Hedberg return 0; 33653119ae95SJohan Hedberg } 33663119ae95SJohan Hedberg 33671ca3a9d0SJohan Hedberg static struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, 336807dc93ddSJohan Hedberg u32 plen, const void *param) 33691da177e4SLinus Torvalds { 33701da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 33711da177e4SLinus Torvalds struct hci_command_hdr *hdr; 33721da177e4SLinus Torvalds struct sk_buff *skb; 33731da177e4SLinus Torvalds 33741da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 33751ca3a9d0SJohan Hedberg if (!skb) 33761ca3a9d0SJohan Hedberg return NULL; 33771da177e4SLinus Torvalds 33781da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 3379a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 33801da177e4SLinus Torvalds hdr->plen = plen; 33811da177e4SLinus Torvalds 33821da177e4SLinus Torvalds if (plen) 33831da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 33841da177e4SLinus Torvalds 33851da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 33861da177e4SLinus Torvalds 33870d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 3388c78ae283SMarcel Holtmann 33891ca3a9d0SJohan Hedberg return skb; 33901ca3a9d0SJohan Hedberg } 33911ca3a9d0SJohan Hedberg 33921ca3a9d0SJohan Hedberg /* Send HCI command */ 339307dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 339407dc93ddSJohan Hedberg const void *param) 33951ca3a9d0SJohan Hedberg { 33961ca3a9d0SJohan Hedberg struct sk_buff *skb; 33971ca3a9d0SJohan Hedberg 33981ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 33991ca3a9d0SJohan Hedberg 34001ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 34011ca3a9d0SJohan Hedberg if (!skb) { 34021ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 34031ca3a9d0SJohan Hedberg return -ENOMEM; 34041ca3a9d0SJohan Hedberg } 34051ca3a9d0SJohan Hedberg 340611714b3dSJohan Hedberg /* Stand-alone HCI commands must be flaged as 340711714b3dSJohan Hedberg * single-command requests. 340811714b3dSJohan Hedberg */ 340911714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 341011714b3dSJohan Hedberg 34111da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3412c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 34131da177e4SLinus Torvalds 34141da177e4SLinus Torvalds return 0; 34151da177e4SLinus Torvalds } 34161da177e4SLinus Torvalds 341771c76a17SJohan Hedberg /* Queue a command to an asynchronous HCI request */ 341807dc93ddSJohan Hedberg void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen, 341907dc93ddSJohan Hedberg const void *param, u8 event) 342071c76a17SJohan Hedberg { 342171c76a17SJohan Hedberg struct hci_dev *hdev = req->hdev; 342271c76a17SJohan Hedberg struct sk_buff *skb; 342371c76a17SJohan Hedberg 342471c76a17SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 342571c76a17SJohan Hedberg 342634739c1eSAndre Guedes /* If an error occured during request building, there is no point in 342734739c1eSAndre Guedes * queueing the HCI command. We can simply return. 342834739c1eSAndre Guedes */ 342934739c1eSAndre Guedes if (req->err) 343034739c1eSAndre Guedes return; 343134739c1eSAndre Guedes 343271c76a17SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 343371c76a17SJohan Hedberg if (!skb) { 34345d73e034SAndre Guedes BT_ERR("%s no memory for command (opcode 0x%4.4x)", 34355d73e034SAndre Guedes hdev->name, opcode); 34365d73e034SAndre Guedes req->err = -ENOMEM; 3437e348fe6bSAndre Guedes return; 343871c76a17SJohan Hedberg } 343971c76a17SJohan Hedberg 344071c76a17SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 344171c76a17SJohan Hedberg bt_cb(skb)->req.start = true; 344271c76a17SJohan Hedberg 344302350a72SJohan Hedberg bt_cb(skb)->req.event = event; 344402350a72SJohan Hedberg 344571c76a17SJohan Hedberg skb_queue_tail(&req->cmd_q, skb); 344671c76a17SJohan Hedberg } 344771c76a17SJohan Hedberg 344807dc93ddSJohan Hedberg void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, 344907dc93ddSJohan Hedberg const void *param) 345002350a72SJohan Hedberg { 345102350a72SJohan Hedberg hci_req_add_ev(req, opcode, plen, param, 0); 345202350a72SJohan Hedberg } 345302350a72SJohan Hedberg 34541da177e4SLinus Torvalds /* Get data from the previously sent command */ 3455a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 34561da177e4SLinus Torvalds { 34571da177e4SLinus Torvalds struct hci_command_hdr *hdr; 34581da177e4SLinus Torvalds 34591da177e4SLinus Torvalds if (!hdev->sent_cmd) 34601da177e4SLinus Torvalds return NULL; 34611da177e4SLinus Torvalds 34621da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 34631da177e4SLinus Torvalds 3464a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 34651da177e4SLinus Torvalds return NULL; 34661da177e4SLinus Torvalds 3467f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 34681da177e4SLinus Torvalds 34691da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 34701da177e4SLinus Torvalds } 34711da177e4SLinus Torvalds 34721da177e4SLinus Torvalds /* Send ACL data */ 34731da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 34741da177e4SLinus Torvalds { 34751da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 34761da177e4SLinus Torvalds int len = skb->len; 34771da177e4SLinus Torvalds 3478badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3479badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 34809c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3481aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3482aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 34831da177e4SLinus Torvalds } 34841da177e4SLinus Torvalds 3485ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 348673d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 34871da177e4SLinus Torvalds { 3488ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 34891da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 34901da177e4SLinus Torvalds struct sk_buff *list; 34911da177e4SLinus Torvalds 3492087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3493087bfd99SGustavo Padovan skb->data_len = 0; 3494087bfd99SGustavo Padovan 3495087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3496204a6e54SAndrei Emeltchenko 3497204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3498204a6e54SAndrei Emeltchenko case HCI_BREDR: 3499087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3500204a6e54SAndrei Emeltchenko break; 3501204a6e54SAndrei Emeltchenko case HCI_AMP: 3502204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3503204a6e54SAndrei Emeltchenko break; 3504204a6e54SAndrei Emeltchenko default: 3505204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 3506204a6e54SAndrei Emeltchenko return; 3507204a6e54SAndrei Emeltchenko } 3508087bfd99SGustavo Padovan 350970f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 351070f23020SAndrei Emeltchenko if (!list) { 35111da177e4SLinus Torvalds /* Non fragmented */ 35121da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 35131da177e4SLinus Torvalds 351473d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 35151da177e4SLinus Torvalds } else { 35161da177e4SLinus Torvalds /* Fragmented */ 35171da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 35181da177e4SLinus Torvalds 35191da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 35201da177e4SLinus Torvalds 35211da177e4SLinus Torvalds /* Queue all fragments atomically */ 3522af3e6359SGustavo F. Padovan spin_lock(&queue->lock); 35231da177e4SLinus Torvalds 352473d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3525e702112fSAndrei Emeltchenko 3526e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3527e702112fSAndrei Emeltchenko flags |= ACL_CONT; 35281da177e4SLinus Torvalds do { 35291da177e4SLinus Torvalds skb = list; list = list->next; 35301da177e4SLinus Torvalds 35310d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3532e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 35331da177e4SLinus Torvalds 35341da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 35351da177e4SLinus Torvalds 353673d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 35371da177e4SLinus Torvalds } while (list); 35381da177e4SLinus Torvalds 3539af3e6359SGustavo F. Padovan spin_unlock(&queue->lock); 35401da177e4SLinus Torvalds } 354173d80debSLuiz Augusto von Dentz } 354273d80debSLuiz Augusto von Dentz 354373d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 354473d80debSLuiz Augusto von Dentz { 3545ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 354673d80debSLuiz Augusto von Dentz 3547f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 354873d80debSLuiz Augusto von Dentz 3549ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 35501da177e4SLinus Torvalds 35513eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 35521da177e4SLinus Torvalds } 35531da177e4SLinus Torvalds 35541da177e4SLinus Torvalds /* Send SCO data */ 35550d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 35561da177e4SLinus Torvalds { 35571da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 35581da177e4SLinus Torvalds struct hci_sco_hdr hdr; 35591da177e4SLinus Torvalds 35601da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 35611da177e4SLinus Torvalds 3562aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 35631da177e4SLinus Torvalds hdr.dlen = skb->len; 35641da177e4SLinus Torvalds 3565badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3566badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 35679c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 35681da177e4SLinus Torvalds 35690d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 3570c78ae283SMarcel Holtmann 35711da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 35723eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 35731da177e4SLinus Torvalds } 35741da177e4SLinus Torvalds 35751da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 35761da177e4SLinus Torvalds 35771da177e4SLinus Torvalds /* HCI Connection scheduler */ 35786039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3579a8c5fb1aSGustavo Padovan int *quote) 35801da177e4SLinus Torvalds { 35811da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 35828035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3583abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 35841da177e4SLinus Torvalds 35851da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 35861da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3587bf4c6325SGustavo F. Padovan 3588bf4c6325SGustavo F. Padovan rcu_read_lock(); 3589bf4c6325SGustavo F. Padovan 3590bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3591769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 35921da177e4SLinus Torvalds continue; 3593769be974SMarcel Holtmann 3594769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3595769be974SMarcel Holtmann continue; 3596769be974SMarcel Holtmann 35971da177e4SLinus Torvalds num++; 35981da177e4SLinus Torvalds 35991da177e4SLinus Torvalds if (c->sent < min) { 36001da177e4SLinus Torvalds min = c->sent; 36011da177e4SLinus Torvalds conn = c; 36021da177e4SLinus Torvalds } 360352087a79SLuiz Augusto von Dentz 360452087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 360552087a79SLuiz Augusto von Dentz break; 36061da177e4SLinus Torvalds } 36071da177e4SLinus Torvalds 3608bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3609bf4c6325SGustavo F. Padovan 36101da177e4SLinus Torvalds if (conn) { 36116ed58ec5SVille Tervo int cnt, q; 36126ed58ec5SVille Tervo 36136ed58ec5SVille Tervo switch (conn->type) { 36146ed58ec5SVille Tervo case ACL_LINK: 36156ed58ec5SVille Tervo cnt = hdev->acl_cnt; 36166ed58ec5SVille Tervo break; 36176ed58ec5SVille Tervo case SCO_LINK: 36186ed58ec5SVille Tervo case ESCO_LINK: 36196ed58ec5SVille Tervo cnt = hdev->sco_cnt; 36206ed58ec5SVille Tervo break; 36216ed58ec5SVille Tervo case LE_LINK: 36226ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 36236ed58ec5SVille Tervo break; 36246ed58ec5SVille Tervo default: 36256ed58ec5SVille Tervo cnt = 0; 36266ed58ec5SVille Tervo BT_ERR("Unknown link type"); 36276ed58ec5SVille Tervo } 36286ed58ec5SVille Tervo 36296ed58ec5SVille Tervo q = cnt / num; 36301da177e4SLinus Torvalds *quote = q ? q : 1; 36311da177e4SLinus Torvalds } else 36321da177e4SLinus Torvalds *quote = 0; 36331da177e4SLinus Torvalds 36341da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 36351da177e4SLinus Torvalds return conn; 36361da177e4SLinus Torvalds } 36371da177e4SLinus Torvalds 36386039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 36391da177e4SLinus Torvalds { 36401da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 36411da177e4SLinus Torvalds struct hci_conn *c; 36421da177e4SLinus Torvalds 3643bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 36441da177e4SLinus Torvalds 3645bf4c6325SGustavo F. Padovan rcu_read_lock(); 3646bf4c6325SGustavo F. Padovan 36471da177e4SLinus Torvalds /* Kill stalled connections */ 3648bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3649bae1f5d9SVille Tervo if (c->type == type && c->sent) { 36506ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 36516ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 3652bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 36531da177e4SLinus Torvalds } 36541da177e4SLinus Torvalds } 3655bf4c6325SGustavo F. Padovan 3656bf4c6325SGustavo F. Padovan rcu_read_unlock(); 36571da177e4SLinus Torvalds } 36581da177e4SLinus Torvalds 36596039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 366073d80debSLuiz Augusto von Dentz int *quote) 366173d80debSLuiz Augusto von Dentz { 366273d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 366373d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3664abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 366573d80debSLuiz Augusto von Dentz struct hci_conn *conn; 366673d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 366773d80debSLuiz Augusto von Dentz 366873d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 366973d80debSLuiz Augusto von Dentz 3670bf4c6325SGustavo F. Padovan rcu_read_lock(); 3671bf4c6325SGustavo F. Padovan 3672bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 367373d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 367473d80debSLuiz Augusto von Dentz 367573d80debSLuiz Augusto von Dentz if (conn->type != type) 367673d80debSLuiz Augusto von Dentz continue; 367773d80debSLuiz Augusto von Dentz 367873d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 367973d80debSLuiz Augusto von Dentz continue; 368073d80debSLuiz Augusto von Dentz 368173d80debSLuiz Augusto von Dentz conn_num++; 368273d80debSLuiz Augusto von Dentz 36838192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 368473d80debSLuiz Augusto von Dentz struct sk_buff *skb; 368573d80debSLuiz Augusto von Dentz 368673d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 368773d80debSLuiz Augusto von Dentz continue; 368873d80debSLuiz Augusto von Dentz 368973d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 369073d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 369173d80debSLuiz Augusto von Dentz continue; 369273d80debSLuiz Augusto von Dentz 369373d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 369473d80debSLuiz Augusto von Dentz num = 0; 369573d80debSLuiz Augusto von Dentz min = ~0; 369673d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 369773d80debSLuiz Augusto von Dentz } 369873d80debSLuiz Augusto von Dentz 369973d80debSLuiz Augusto von Dentz num++; 370073d80debSLuiz Augusto von Dentz 370173d80debSLuiz Augusto von Dentz if (conn->sent < min) { 370273d80debSLuiz Augusto von Dentz min = conn->sent; 370373d80debSLuiz Augusto von Dentz chan = tmp; 370473d80debSLuiz Augusto von Dentz } 370573d80debSLuiz Augusto von Dentz } 370673d80debSLuiz Augusto von Dentz 370773d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 370873d80debSLuiz Augusto von Dentz break; 370973d80debSLuiz Augusto von Dentz } 371073d80debSLuiz Augusto von Dentz 3711bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3712bf4c6325SGustavo F. Padovan 371373d80debSLuiz Augusto von Dentz if (!chan) 371473d80debSLuiz Augusto von Dentz return NULL; 371573d80debSLuiz Augusto von Dentz 371673d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 371773d80debSLuiz Augusto von Dentz case ACL_LINK: 371873d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 371973d80debSLuiz Augusto von Dentz break; 3720bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3721bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3722bd1eb66bSAndrei Emeltchenko break; 372373d80debSLuiz Augusto von Dentz case SCO_LINK: 372473d80debSLuiz Augusto von Dentz case ESCO_LINK: 372573d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 372673d80debSLuiz Augusto von Dentz break; 372773d80debSLuiz Augusto von Dentz case LE_LINK: 372873d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 372973d80debSLuiz Augusto von Dentz break; 373073d80debSLuiz Augusto von Dentz default: 373173d80debSLuiz Augusto von Dentz cnt = 0; 373273d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 373373d80debSLuiz Augusto von Dentz } 373473d80debSLuiz Augusto von Dentz 373573d80debSLuiz Augusto von Dentz q = cnt / num; 373673d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 373773d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 373873d80debSLuiz Augusto von Dentz return chan; 373973d80debSLuiz Augusto von Dentz } 374073d80debSLuiz Augusto von Dentz 374102b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 374202b20f0bSLuiz Augusto von Dentz { 374302b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 374402b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 374502b20f0bSLuiz Augusto von Dentz int num = 0; 374602b20f0bSLuiz Augusto von Dentz 374702b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 374802b20f0bSLuiz Augusto von Dentz 3749bf4c6325SGustavo F. Padovan rcu_read_lock(); 3750bf4c6325SGustavo F. Padovan 3751bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 375202b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 375302b20f0bSLuiz Augusto von Dentz 375402b20f0bSLuiz Augusto von Dentz if (conn->type != type) 375502b20f0bSLuiz Augusto von Dentz continue; 375602b20f0bSLuiz Augusto von Dentz 375702b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 375802b20f0bSLuiz Augusto von Dentz continue; 375902b20f0bSLuiz Augusto von Dentz 376002b20f0bSLuiz Augusto von Dentz num++; 376102b20f0bSLuiz Augusto von Dentz 37628192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 376302b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 376402b20f0bSLuiz Augusto von Dentz 376502b20f0bSLuiz Augusto von Dentz if (chan->sent) { 376602b20f0bSLuiz Augusto von Dentz chan->sent = 0; 376702b20f0bSLuiz Augusto von Dentz continue; 376802b20f0bSLuiz Augusto von Dentz } 376902b20f0bSLuiz Augusto von Dentz 377002b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 377102b20f0bSLuiz Augusto von Dentz continue; 377202b20f0bSLuiz Augusto von Dentz 377302b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 377402b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 377502b20f0bSLuiz Augusto von Dentz continue; 377602b20f0bSLuiz Augusto von Dentz 377702b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 377802b20f0bSLuiz Augusto von Dentz 377902b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 378002b20f0bSLuiz Augusto von Dentz skb->priority); 378102b20f0bSLuiz Augusto von Dentz } 378202b20f0bSLuiz Augusto von Dentz 378302b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 378402b20f0bSLuiz Augusto von Dentz break; 378502b20f0bSLuiz Augusto von Dentz } 3786bf4c6325SGustavo F. Padovan 3787bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3788bf4c6325SGustavo F. Padovan 378902b20f0bSLuiz Augusto von Dentz } 379002b20f0bSLuiz Augusto von Dentz 3791b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 3792b71d385aSAndrei Emeltchenko { 3793b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 3794b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 3795b71d385aSAndrei Emeltchenko } 3796b71d385aSAndrei Emeltchenko 37976039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 37981da177e4SLinus Torvalds { 37991da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 38001da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 38011da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 380263d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 38035f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 3804bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 38051da177e4SLinus Torvalds } 380663d2bc1bSAndrei Emeltchenko } 38071da177e4SLinus Torvalds 38086039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 380963d2bc1bSAndrei Emeltchenko { 381063d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 381163d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 381263d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 381363d2bc1bSAndrei Emeltchenko int quote; 381463d2bc1bSAndrei Emeltchenko 381563d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 381604837f64SMarcel Holtmann 381773d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 381873d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 3819ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3820ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 382173d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 382273d80debSLuiz Augusto von Dentz skb->len, skb->priority); 382373d80debSLuiz Augusto von Dentz 3824ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3825ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3826ec1cce24SLuiz Augusto von Dentz break; 3827ec1cce24SLuiz Augusto von Dentz 3828ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3829ec1cce24SLuiz Augusto von Dentz 383073d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 383173d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 383204837f64SMarcel Holtmann 383357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 38341da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 38351da177e4SLinus Torvalds 38361da177e4SLinus Torvalds hdev->acl_cnt--; 383773d80debSLuiz Augusto von Dentz chan->sent++; 383873d80debSLuiz Augusto von Dentz chan->conn->sent++; 38391da177e4SLinus Torvalds } 38401da177e4SLinus Torvalds } 384102b20f0bSLuiz Augusto von Dentz 384202b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 384302b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 38441da177e4SLinus Torvalds } 38451da177e4SLinus Torvalds 38466039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 3847b71d385aSAndrei Emeltchenko { 384863d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 3849b71d385aSAndrei Emeltchenko struct hci_chan *chan; 3850b71d385aSAndrei Emeltchenko struct sk_buff *skb; 3851b71d385aSAndrei Emeltchenko int quote; 3852bd1eb66bSAndrei Emeltchenko u8 type; 3853b71d385aSAndrei Emeltchenko 385463d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 3855b71d385aSAndrei Emeltchenko 3856bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3857bd1eb66bSAndrei Emeltchenko 3858bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 3859bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 3860bd1eb66bSAndrei Emeltchenko else 3861bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 3862bd1eb66bSAndrei Emeltchenko 3863b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 3864bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 3865b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 3866b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 3867b71d385aSAndrei Emeltchenko int blocks; 3868b71d385aSAndrei Emeltchenko 3869b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 3870b71d385aSAndrei Emeltchenko skb->len, skb->priority); 3871b71d385aSAndrei Emeltchenko 3872b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 3873b71d385aSAndrei Emeltchenko if (skb->priority < priority) 3874b71d385aSAndrei Emeltchenko break; 3875b71d385aSAndrei Emeltchenko 3876b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 3877b71d385aSAndrei Emeltchenko 3878b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 3879b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 3880b71d385aSAndrei Emeltchenko return; 3881b71d385aSAndrei Emeltchenko 3882b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 3883b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 3884b71d385aSAndrei Emeltchenko 388557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3886b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 3887b71d385aSAndrei Emeltchenko 3888b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 3889b71d385aSAndrei Emeltchenko quote -= blocks; 3890b71d385aSAndrei Emeltchenko 3891b71d385aSAndrei Emeltchenko chan->sent += blocks; 3892b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 3893b71d385aSAndrei Emeltchenko } 3894b71d385aSAndrei Emeltchenko } 3895b71d385aSAndrei Emeltchenko 3896b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 3897bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 3898b71d385aSAndrei Emeltchenko } 3899b71d385aSAndrei Emeltchenko 39006039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 3901b71d385aSAndrei Emeltchenko { 3902b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3903b71d385aSAndrei Emeltchenko 3904bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 3905bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 3906bd1eb66bSAndrei Emeltchenko return; 3907bd1eb66bSAndrei Emeltchenko 3908bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 3909bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 3910b71d385aSAndrei Emeltchenko return; 3911b71d385aSAndrei Emeltchenko 3912b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 3913b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 3914b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 3915b71d385aSAndrei Emeltchenko break; 3916b71d385aSAndrei Emeltchenko 3917b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 3918b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 3919b71d385aSAndrei Emeltchenko break; 3920b71d385aSAndrei Emeltchenko } 3921b71d385aSAndrei Emeltchenko } 3922b71d385aSAndrei Emeltchenko 39231da177e4SLinus Torvalds /* Schedule SCO */ 39246039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 39251da177e4SLinus Torvalds { 39261da177e4SLinus Torvalds struct hci_conn *conn; 39271da177e4SLinus Torvalds struct sk_buff *skb; 39281da177e4SLinus Torvalds int quote; 39291da177e4SLinus Torvalds 39301da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 39311da177e4SLinus Torvalds 393252087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 393352087a79SLuiz Augusto von Dentz return; 393452087a79SLuiz Augusto von Dentz 39351da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 39361da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 39371da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 393857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 39391da177e4SLinus Torvalds 39401da177e4SLinus Torvalds conn->sent++; 39411da177e4SLinus Torvalds if (conn->sent == ~0) 39421da177e4SLinus Torvalds conn->sent = 0; 39431da177e4SLinus Torvalds } 39441da177e4SLinus Torvalds } 39451da177e4SLinus Torvalds } 39461da177e4SLinus Torvalds 39476039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 3948b6a0dc82SMarcel Holtmann { 3949b6a0dc82SMarcel Holtmann struct hci_conn *conn; 3950b6a0dc82SMarcel Holtmann struct sk_buff *skb; 3951b6a0dc82SMarcel Holtmann int quote; 3952b6a0dc82SMarcel Holtmann 3953b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 3954b6a0dc82SMarcel Holtmann 395552087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 395652087a79SLuiz Augusto von Dentz return; 395752087a79SLuiz Augusto von Dentz 39588fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 39598fc9ced3SGustavo Padovan "e))) { 3960b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 3961b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 396257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3963b6a0dc82SMarcel Holtmann 3964b6a0dc82SMarcel Holtmann conn->sent++; 3965b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 3966b6a0dc82SMarcel Holtmann conn->sent = 0; 3967b6a0dc82SMarcel Holtmann } 3968b6a0dc82SMarcel Holtmann } 3969b6a0dc82SMarcel Holtmann } 3970b6a0dc82SMarcel Holtmann 39716039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 39726ed58ec5SVille Tervo { 397373d80debSLuiz Augusto von Dentz struct hci_chan *chan; 39746ed58ec5SVille Tervo struct sk_buff *skb; 397502b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 39766ed58ec5SVille Tervo 39776ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 39786ed58ec5SVille Tervo 397952087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 398052087a79SLuiz Augusto von Dentz return; 398152087a79SLuiz Augusto von Dentz 39826ed58ec5SVille Tervo if (!test_bit(HCI_RAW, &hdev->flags)) { 39836ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 39846ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 3985bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 39866ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 3987bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 39886ed58ec5SVille Tervo } 39896ed58ec5SVille Tervo 39906ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 399102b20f0bSLuiz Augusto von Dentz tmp = cnt; 399273d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 3993ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3994ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 399573d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 399673d80debSLuiz Augusto von Dentz skb->len, skb->priority); 39976ed58ec5SVille Tervo 3998ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3999ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4000ec1cce24SLuiz Augusto von Dentz break; 4001ec1cce24SLuiz Augusto von Dentz 4002ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4003ec1cce24SLuiz Augusto von Dentz 400457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40056ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 40066ed58ec5SVille Tervo 40076ed58ec5SVille Tervo cnt--; 400873d80debSLuiz Augusto von Dentz chan->sent++; 400973d80debSLuiz Augusto von Dentz chan->conn->sent++; 40106ed58ec5SVille Tervo } 40116ed58ec5SVille Tervo } 401273d80debSLuiz Augusto von Dentz 40136ed58ec5SVille Tervo if (hdev->le_pkts) 40146ed58ec5SVille Tervo hdev->le_cnt = cnt; 40156ed58ec5SVille Tervo else 40166ed58ec5SVille Tervo hdev->acl_cnt = cnt; 401702b20f0bSLuiz Augusto von Dentz 401802b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 401902b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 40206ed58ec5SVille Tervo } 40216ed58ec5SVille Tervo 40223eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 40231da177e4SLinus Torvalds { 40243eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 40251da177e4SLinus Torvalds struct sk_buff *skb; 40261da177e4SLinus Torvalds 40276ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 40286ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 40291da177e4SLinus Torvalds 403052de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 40311da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 40321da177e4SLinus Torvalds hci_sched_acl(hdev); 40331da177e4SLinus Torvalds hci_sched_sco(hdev); 4034b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 40356ed58ec5SVille Tervo hci_sched_le(hdev); 403652de599eSMarcel Holtmann } 40376ed58ec5SVille Tervo 40381da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 40391da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 404057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40411da177e4SLinus Torvalds } 40421da177e4SLinus Torvalds 404325985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 40441da177e4SLinus Torvalds 40451da177e4SLinus Torvalds /* ACL data packet */ 40466039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 40471da177e4SLinus Torvalds { 40481da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 40491da177e4SLinus Torvalds struct hci_conn *conn; 40501da177e4SLinus Torvalds __u16 handle, flags; 40511da177e4SLinus Torvalds 40521da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 40531da177e4SLinus Torvalds 40541da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 40551da177e4SLinus Torvalds flags = hci_flags(handle); 40561da177e4SLinus Torvalds handle = hci_handle(handle); 40571da177e4SLinus Torvalds 4058f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4059a8c5fb1aSGustavo Padovan handle, flags); 40601da177e4SLinus Torvalds 40611da177e4SLinus Torvalds hdev->stat.acl_rx++; 40621da177e4SLinus Torvalds 40631da177e4SLinus Torvalds hci_dev_lock(hdev); 40641da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 40651da177e4SLinus Torvalds hci_dev_unlock(hdev); 40661da177e4SLinus Torvalds 40671da177e4SLinus Torvalds if (conn) { 406865983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 406904837f64SMarcel Holtmann 40701da177e4SLinus Torvalds /* Send to upper protocol */ 4071686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 40721da177e4SLinus Torvalds return; 40731da177e4SLinus Torvalds } else { 40741da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 40751da177e4SLinus Torvalds hdev->name, handle); 40761da177e4SLinus Torvalds } 40771da177e4SLinus Torvalds 40781da177e4SLinus Torvalds kfree_skb(skb); 40791da177e4SLinus Torvalds } 40801da177e4SLinus Torvalds 40811da177e4SLinus Torvalds /* SCO data packet */ 40826039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 40831da177e4SLinus Torvalds { 40841da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 40851da177e4SLinus Torvalds struct hci_conn *conn; 40861da177e4SLinus Torvalds __u16 handle; 40871da177e4SLinus Torvalds 40881da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 40891da177e4SLinus Torvalds 40901da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 40911da177e4SLinus Torvalds 4092f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 40931da177e4SLinus Torvalds 40941da177e4SLinus Torvalds hdev->stat.sco_rx++; 40951da177e4SLinus Torvalds 40961da177e4SLinus Torvalds hci_dev_lock(hdev); 40971da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 40981da177e4SLinus Torvalds hci_dev_unlock(hdev); 40991da177e4SLinus Torvalds 41001da177e4SLinus Torvalds if (conn) { 41011da177e4SLinus Torvalds /* Send to upper protocol */ 4102686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 41031da177e4SLinus Torvalds return; 41041da177e4SLinus Torvalds } else { 41051da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 41061da177e4SLinus Torvalds hdev->name, handle); 41071da177e4SLinus Torvalds } 41081da177e4SLinus Torvalds 41091da177e4SLinus Torvalds kfree_skb(skb); 41101da177e4SLinus Torvalds } 41111da177e4SLinus Torvalds 41129238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 41139238f36aSJohan Hedberg { 41149238f36aSJohan Hedberg struct sk_buff *skb; 41159238f36aSJohan Hedberg 41169238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 41179238f36aSJohan Hedberg if (!skb) 41189238f36aSJohan Hedberg return true; 41199238f36aSJohan Hedberg 41209238f36aSJohan Hedberg return bt_cb(skb)->req.start; 41219238f36aSJohan Hedberg } 41229238f36aSJohan Hedberg 412342c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 412442c6b129SJohan Hedberg { 412542c6b129SJohan Hedberg struct hci_command_hdr *sent; 412642c6b129SJohan Hedberg struct sk_buff *skb; 412742c6b129SJohan Hedberg u16 opcode; 412842c6b129SJohan Hedberg 412942c6b129SJohan Hedberg if (!hdev->sent_cmd) 413042c6b129SJohan Hedberg return; 413142c6b129SJohan Hedberg 413242c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 413342c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 413442c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 413542c6b129SJohan Hedberg return; 413642c6b129SJohan Hedberg 413742c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 413842c6b129SJohan Hedberg if (!skb) 413942c6b129SJohan Hedberg return; 414042c6b129SJohan Hedberg 414142c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 414242c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 414342c6b129SJohan Hedberg } 414442c6b129SJohan Hedberg 41459238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 41469238f36aSJohan Hedberg { 41479238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 41489238f36aSJohan Hedberg struct sk_buff *skb; 41499238f36aSJohan Hedberg unsigned long flags; 41509238f36aSJohan Hedberg 41519238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 41529238f36aSJohan Hedberg 415342c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 415442c6b129SJohan Hedberg * sent we need to do special handling of it. 41559238f36aSJohan Hedberg */ 415642c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 415742c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 415842c6b129SJohan Hedberg * reset complete event during init and any pending 415942c6b129SJohan Hedberg * command will never be completed. In such a case we 416042c6b129SJohan Hedberg * need to resend whatever was the last sent 416142c6b129SJohan Hedberg * command. 416242c6b129SJohan Hedberg */ 416342c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 416442c6b129SJohan Hedberg hci_resend_last(hdev); 416542c6b129SJohan Hedberg 41669238f36aSJohan Hedberg return; 416742c6b129SJohan Hedberg } 41689238f36aSJohan Hedberg 41699238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 41709238f36aSJohan Hedberg * this request the request is not yet complete. 41719238f36aSJohan Hedberg */ 41729238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 41739238f36aSJohan Hedberg return; 41749238f36aSJohan Hedberg 41759238f36aSJohan Hedberg /* If this was the last command in a request the complete 41769238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 41779238f36aSJohan Hedberg * command queue (hdev->cmd_q). 41789238f36aSJohan Hedberg */ 41799238f36aSJohan Hedberg if (hdev->sent_cmd) { 41809238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 418153e21fbcSJohan Hedberg 418253e21fbcSJohan Hedberg if (req_complete) { 418353e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 418453e21fbcSJohan Hedberg * avoid calling the callback more than once if 418553e21fbcSJohan Hedberg * this function gets called again. 418653e21fbcSJohan Hedberg */ 418753e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 418853e21fbcSJohan Hedberg 41899238f36aSJohan Hedberg goto call_complete; 41909238f36aSJohan Hedberg } 419153e21fbcSJohan Hedberg } 41929238f36aSJohan Hedberg 41939238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 41949238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 41959238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 41969238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 41979238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 41989238f36aSJohan Hedberg break; 41999238f36aSJohan Hedberg } 42009238f36aSJohan Hedberg 42019238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 42029238f36aSJohan Hedberg kfree_skb(skb); 42039238f36aSJohan Hedberg } 42049238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 42059238f36aSJohan Hedberg 42069238f36aSJohan Hedberg call_complete: 42079238f36aSJohan Hedberg if (req_complete) 42089238f36aSJohan Hedberg req_complete(hdev, status); 42099238f36aSJohan Hedberg } 42109238f36aSJohan Hedberg 4211b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 42121da177e4SLinus Torvalds { 4213b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 42141da177e4SLinus Torvalds struct sk_buff *skb; 42151da177e4SLinus Torvalds 42161da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 42171da177e4SLinus Torvalds 42181da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4219cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4220cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4221cd82e61cSMarcel Holtmann 42221da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 42231da177e4SLinus Torvalds /* Send copy to the sockets */ 4224470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 42251da177e4SLinus Torvalds } 42261da177e4SLinus Torvalds 42270736cfa8SMarcel Holtmann if (test_bit(HCI_RAW, &hdev->flags) || 42280736cfa8SMarcel Holtmann test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 42291da177e4SLinus Torvalds kfree_skb(skb); 42301da177e4SLinus Torvalds continue; 42311da177e4SLinus Torvalds } 42321da177e4SLinus Torvalds 42331da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 42341da177e4SLinus Torvalds /* Don't process data packets in this states. */ 42350d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 42361da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 42371da177e4SLinus Torvalds case HCI_SCODATA_PKT: 42381da177e4SLinus Torvalds kfree_skb(skb); 42391da177e4SLinus Torvalds continue; 42403ff50b79SStephen Hemminger } 42411da177e4SLinus Torvalds } 42421da177e4SLinus Torvalds 42431da177e4SLinus Torvalds /* Process frame */ 42440d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 42451da177e4SLinus Torvalds case HCI_EVENT_PKT: 4246b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 42471da177e4SLinus Torvalds hci_event_packet(hdev, skb); 42481da177e4SLinus Torvalds break; 42491da177e4SLinus Torvalds 42501da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 42511da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 42521da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 42531da177e4SLinus Torvalds break; 42541da177e4SLinus Torvalds 42551da177e4SLinus Torvalds case HCI_SCODATA_PKT: 42561da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 42571da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 42581da177e4SLinus Torvalds break; 42591da177e4SLinus Torvalds 42601da177e4SLinus Torvalds default: 42611da177e4SLinus Torvalds kfree_skb(skb); 42621da177e4SLinus Torvalds break; 42631da177e4SLinus Torvalds } 42641da177e4SLinus Torvalds } 42651da177e4SLinus Torvalds } 42661da177e4SLinus Torvalds 4267c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 42681da177e4SLinus Torvalds { 4269c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 42701da177e4SLinus Torvalds struct sk_buff *skb; 42711da177e4SLinus Torvalds 42722104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 42732104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 42741da177e4SLinus Torvalds 42751da177e4SLinus Torvalds /* Send queued commands */ 42765a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 42775a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 42785a08ecceSAndrei Emeltchenko if (!skb) 42795a08ecceSAndrei Emeltchenko return; 42805a08ecceSAndrei Emeltchenko 42811da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 42821da177e4SLinus Torvalds 4283a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 428470f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 42851da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 428657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42877bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 42887bdb8a5cSSzymon Janc del_timer(&hdev->cmd_timer); 42897bdb8a5cSSzymon Janc else 42906bd32326SVille Tervo mod_timer(&hdev->cmd_timer, 42915f246e89SAndrei Emeltchenko jiffies + HCI_CMD_TIMEOUT); 42921da177e4SLinus Torvalds } else { 42931da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4294c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 42951da177e4SLinus Torvalds } 42961da177e4SLinus Torvalds } 42971da177e4SLinus Torvalds } 4298