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 61dfb826a8SMarcel Holtmann static int features_show(struct seq_file *f, void *ptr) 62dfb826a8SMarcel Holtmann { 63dfb826a8SMarcel Holtmann struct hci_dev *hdev = f->private; 64dfb826a8SMarcel Holtmann u8 p; 65dfb826a8SMarcel Holtmann 66dfb826a8SMarcel Holtmann hci_dev_lock(hdev); 67dfb826a8SMarcel Holtmann for (p = 0; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 68dfb826a8SMarcel Holtmann seq_printf(f, "Page %u: 0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x " 69dfb826a8SMarcel Holtmann "0x%2.2x 0x%2.2x 0x%2.2x 0x%2.2x\n", p, 70dfb826a8SMarcel Holtmann hdev->features[p][0], hdev->features[p][1], 71dfb826a8SMarcel Holtmann hdev->features[p][2], hdev->features[p][3], 72dfb826a8SMarcel Holtmann hdev->features[p][4], hdev->features[p][5], 73dfb826a8SMarcel Holtmann hdev->features[p][6], hdev->features[p][7]); 74dfb826a8SMarcel Holtmann } 75dfb826a8SMarcel Holtmann hci_dev_unlock(hdev); 76dfb826a8SMarcel Holtmann 77dfb826a8SMarcel Holtmann return 0; 78dfb826a8SMarcel Holtmann } 79dfb826a8SMarcel Holtmann 80dfb826a8SMarcel Holtmann static int features_open(struct inode *inode, struct file *file) 81dfb826a8SMarcel Holtmann { 82dfb826a8SMarcel Holtmann return single_open(file, features_show, inode->i_private); 83dfb826a8SMarcel Holtmann } 84dfb826a8SMarcel Holtmann 85dfb826a8SMarcel Holtmann static const struct file_operations features_fops = { 86dfb826a8SMarcel Holtmann .open = features_open, 87dfb826a8SMarcel Holtmann .read = seq_read, 88dfb826a8SMarcel Holtmann .llseek = seq_lseek, 89dfb826a8SMarcel Holtmann .release = single_release, 90dfb826a8SMarcel Holtmann }; 91dfb826a8SMarcel Holtmann 9270afe0b8SMarcel Holtmann static int blacklist_show(struct seq_file *f, void *p) 9370afe0b8SMarcel Holtmann { 9470afe0b8SMarcel Holtmann struct hci_dev *hdev = f->private; 9570afe0b8SMarcel Holtmann struct bdaddr_list *b; 9670afe0b8SMarcel Holtmann 9770afe0b8SMarcel Holtmann hci_dev_lock(hdev); 9870afe0b8SMarcel Holtmann list_for_each_entry(b, &hdev->blacklist, list) 99b25f0785SMarcel Holtmann seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 10070afe0b8SMarcel Holtmann hci_dev_unlock(hdev); 10170afe0b8SMarcel Holtmann 10270afe0b8SMarcel Holtmann return 0; 10370afe0b8SMarcel Holtmann } 10470afe0b8SMarcel Holtmann 10570afe0b8SMarcel Holtmann static int blacklist_open(struct inode *inode, struct file *file) 10670afe0b8SMarcel Holtmann { 10770afe0b8SMarcel Holtmann return single_open(file, blacklist_show, inode->i_private); 10870afe0b8SMarcel Holtmann } 10970afe0b8SMarcel Holtmann 11070afe0b8SMarcel Holtmann static const struct file_operations blacklist_fops = { 11170afe0b8SMarcel Holtmann .open = blacklist_open, 11270afe0b8SMarcel Holtmann .read = seq_read, 11370afe0b8SMarcel Holtmann .llseek = seq_lseek, 11470afe0b8SMarcel Holtmann .release = single_release, 11570afe0b8SMarcel Holtmann }; 11670afe0b8SMarcel Holtmann 11747219839SMarcel Holtmann static int uuids_show(struct seq_file *f, void *p) 11847219839SMarcel Holtmann { 11947219839SMarcel Holtmann struct hci_dev *hdev = f->private; 12047219839SMarcel Holtmann struct bt_uuid *uuid; 12147219839SMarcel Holtmann 12247219839SMarcel Holtmann hci_dev_lock(hdev); 12347219839SMarcel Holtmann list_for_each_entry(uuid, &hdev->uuids, list) { 12447219839SMarcel Holtmann u32 data0, data5; 12547219839SMarcel Holtmann u16 data1, data2, data3, data4; 12647219839SMarcel Holtmann 12747219839SMarcel Holtmann data5 = get_unaligned_le32(uuid); 12847219839SMarcel Holtmann data4 = get_unaligned_le16(uuid + 4); 12947219839SMarcel Holtmann data3 = get_unaligned_le16(uuid + 6); 13047219839SMarcel Holtmann data2 = get_unaligned_le16(uuid + 8); 13147219839SMarcel Holtmann data1 = get_unaligned_le16(uuid + 10); 13247219839SMarcel Holtmann data0 = get_unaligned_le32(uuid + 12); 13347219839SMarcel Holtmann 13447219839SMarcel Holtmann seq_printf(f, "%.8x-%.4x-%.4x-%.4x-%.4x%.8x\n", 13547219839SMarcel Holtmann data0, data1, data2, data3, data4, data5); 13647219839SMarcel Holtmann } 13747219839SMarcel Holtmann hci_dev_unlock(hdev); 13847219839SMarcel Holtmann 13947219839SMarcel Holtmann return 0; 14047219839SMarcel Holtmann } 14147219839SMarcel Holtmann 14247219839SMarcel Holtmann static int uuids_open(struct inode *inode, struct file *file) 14347219839SMarcel Holtmann { 14447219839SMarcel Holtmann return single_open(file, uuids_show, inode->i_private); 14547219839SMarcel Holtmann } 14647219839SMarcel Holtmann 14747219839SMarcel Holtmann static const struct file_operations uuids_fops = { 14847219839SMarcel Holtmann .open = uuids_open, 14947219839SMarcel Holtmann .read = seq_read, 15047219839SMarcel Holtmann .llseek = seq_lseek, 15147219839SMarcel Holtmann .release = single_release, 15247219839SMarcel Holtmann }; 15347219839SMarcel Holtmann 154baf27f6eSMarcel Holtmann static int inquiry_cache_show(struct seq_file *f, void *p) 155baf27f6eSMarcel Holtmann { 156baf27f6eSMarcel Holtmann struct hci_dev *hdev = f->private; 157baf27f6eSMarcel Holtmann struct discovery_state *cache = &hdev->discovery; 158baf27f6eSMarcel Holtmann struct inquiry_entry *e; 159baf27f6eSMarcel Holtmann 160baf27f6eSMarcel Holtmann hci_dev_lock(hdev); 161baf27f6eSMarcel Holtmann 162baf27f6eSMarcel Holtmann list_for_each_entry(e, &cache->all, all) { 163baf27f6eSMarcel Holtmann struct inquiry_data *data = &e->data; 164baf27f6eSMarcel Holtmann seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n", 165baf27f6eSMarcel Holtmann &data->bdaddr, 166baf27f6eSMarcel Holtmann data->pscan_rep_mode, data->pscan_period_mode, 167baf27f6eSMarcel Holtmann data->pscan_mode, data->dev_class[2], 168baf27f6eSMarcel Holtmann data->dev_class[1], data->dev_class[0], 169baf27f6eSMarcel Holtmann __le16_to_cpu(data->clock_offset), 170baf27f6eSMarcel Holtmann data->rssi, data->ssp_mode, e->timestamp); 171baf27f6eSMarcel Holtmann } 172baf27f6eSMarcel Holtmann 173baf27f6eSMarcel Holtmann hci_dev_unlock(hdev); 174baf27f6eSMarcel Holtmann 175baf27f6eSMarcel Holtmann return 0; 176baf27f6eSMarcel Holtmann } 177baf27f6eSMarcel Holtmann 178baf27f6eSMarcel Holtmann static int inquiry_cache_open(struct inode *inode, struct file *file) 179baf27f6eSMarcel Holtmann { 180baf27f6eSMarcel Holtmann return single_open(file, inquiry_cache_show, inode->i_private); 181baf27f6eSMarcel Holtmann } 182baf27f6eSMarcel Holtmann 183baf27f6eSMarcel Holtmann static const struct file_operations inquiry_cache_fops = { 184baf27f6eSMarcel Holtmann .open = inquiry_cache_open, 185baf27f6eSMarcel Holtmann .read = seq_read, 186baf27f6eSMarcel Holtmann .llseek = seq_lseek, 187baf27f6eSMarcel Holtmann .release = single_release, 188baf27f6eSMarcel Holtmann }; 189baf27f6eSMarcel Holtmann 19002d08d15SMarcel Holtmann static int link_keys_show(struct seq_file *f, void *ptr) 19102d08d15SMarcel Holtmann { 19202d08d15SMarcel Holtmann struct hci_dev *hdev = f->private; 19302d08d15SMarcel Holtmann struct list_head *p, *n; 19402d08d15SMarcel Holtmann 19502d08d15SMarcel Holtmann hci_dev_lock(hdev); 19602d08d15SMarcel Holtmann list_for_each_safe(p, n, &hdev->link_keys) { 19702d08d15SMarcel Holtmann struct link_key *key = list_entry(p, struct link_key, list); 19802d08d15SMarcel Holtmann seq_printf(f, "%pMR %u %*phN %u\n", &key->bdaddr, key->type, 19902d08d15SMarcel Holtmann HCI_LINK_KEY_SIZE, key->val, key->pin_len); 20002d08d15SMarcel Holtmann } 20102d08d15SMarcel Holtmann hci_dev_unlock(hdev); 20202d08d15SMarcel Holtmann 20302d08d15SMarcel Holtmann return 0; 20402d08d15SMarcel Holtmann } 20502d08d15SMarcel Holtmann 20602d08d15SMarcel Holtmann static int link_keys_open(struct inode *inode, struct file *file) 20702d08d15SMarcel Holtmann { 20802d08d15SMarcel Holtmann return single_open(file, link_keys_show, inode->i_private); 20902d08d15SMarcel Holtmann } 21002d08d15SMarcel Holtmann 21102d08d15SMarcel Holtmann static const struct file_operations link_keys_fops = { 21202d08d15SMarcel Holtmann .open = link_keys_open, 21302d08d15SMarcel Holtmann .read = seq_read, 21402d08d15SMarcel Holtmann .llseek = seq_lseek, 21502d08d15SMarcel Holtmann .release = single_release, 21602d08d15SMarcel Holtmann }; 21702d08d15SMarcel Holtmann 21812c269d7SMarcel Holtmann static ssize_t use_debug_keys_read(struct file *file, char __user *user_buf, 21912c269d7SMarcel Holtmann size_t count, loff_t *ppos) 22012c269d7SMarcel Holtmann { 22112c269d7SMarcel Holtmann struct hci_dev *hdev = file->private_data; 22212c269d7SMarcel Holtmann char buf[3]; 22312c269d7SMarcel Holtmann 22412c269d7SMarcel Holtmann buf[0] = test_bit(HCI_DEBUG_KEYS, &hdev->dev_flags) ? 'Y': 'N'; 22512c269d7SMarcel Holtmann buf[1] = '\n'; 22612c269d7SMarcel Holtmann buf[2] = '\0'; 22712c269d7SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 22812c269d7SMarcel Holtmann } 22912c269d7SMarcel Holtmann 23012c269d7SMarcel Holtmann static const struct file_operations use_debug_keys_fops = { 23112c269d7SMarcel Holtmann .open = simple_open, 23212c269d7SMarcel Holtmann .read = use_debug_keys_read, 23312c269d7SMarcel Holtmann .llseek = default_llseek, 23412c269d7SMarcel Holtmann }; 23512c269d7SMarcel Holtmann 236babdbb3cSMarcel Holtmann static int dev_class_show(struct seq_file *f, void *ptr) 237babdbb3cSMarcel Holtmann { 238babdbb3cSMarcel Holtmann struct hci_dev *hdev = f->private; 239babdbb3cSMarcel Holtmann 240babdbb3cSMarcel Holtmann hci_dev_lock(hdev); 241babdbb3cSMarcel Holtmann seq_printf(f, "0x%.2x%.2x%.2x\n", hdev->dev_class[2], 242babdbb3cSMarcel Holtmann hdev->dev_class[1], hdev->dev_class[0]); 243babdbb3cSMarcel Holtmann hci_dev_unlock(hdev); 244babdbb3cSMarcel Holtmann 245babdbb3cSMarcel Holtmann return 0; 246babdbb3cSMarcel Holtmann } 247babdbb3cSMarcel Holtmann 248babdbb3cSMarcel Holtmann static int dev_class_open(struct inode *inode, struct file *file) 249babdbb3cSMarcel Holtmann { 250babdbb3cSMarcel Holtmann return single_open(file, dev_class_show, inode->i_private); 251babdbb3cSMarcel Holtmann } 252babdbb3cSMarcel Holtmann 253babdbb3cSMarcel Holtmann static const struct file_operations dev_class_fops = { 254babdbb3cSMarcel Holtmann .open = dev_class_open, 255babdbb3cSMarcel Holtmann .read = seq_read, 256babdbb3cSMarcel Holtmann .llseek = seq_lseek, 257babdbb3cSMarcel Holtmann .release = single_release, 258babdbb3cSMarcel Holtmann }; 259babdbb3cSMarcel Holtmann 260041000b9SMarcel Holtmann static int voice_setting_get(void *data, u64 *val) 261041000b9SMarcel Holtmann { 262041000b9SMarcel Holtmann struct hci_dev *hdev = data; 263041000b9SMarcel Holtmann 264041000b9SMarcel Holtmann hci_dev_lock(hdev); 265041000b9SMarcel Holtmann *val = hdev->voice_setting; 266041000b9SMarcel Holtmann hci_dev_unlock(hdev); 267041000b9SMarcel Holtmann 268041000b9SMarcel Holtmann return 0; 269041000b9SMarcel Holtmann } 270041000b9SMarcel Holtmann 271041000b9SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get, 272041000b9SMarcel Holtmann NULL, "0x%4.4llx\n"); 273041000b9SMarcel Holtmann 274ebd1e33bSMarcel Holtmann static int auto_accept_delay_set(void *data, u64 val) 275ebd1e33bSMarcel Holtmann { 276ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 277ebd1e33bSMarcel Holtmann 278ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 279ebd1e33bSMarcel Holtmann hdev->auto_accept_delay = val; 280ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 281ebd1e33bSMarcel Holtmann 282ebd1e33bSMarcel Holtmann return 0; 283ebd1e33bSMarcel Holtmann } 284ebd1e33bSMarcel Holtmann 285ebd1e33bSMarcel Holtmann static int auto_accept_delay_get(void *data, u64 *val) 286ebd1e33bSMarcel Holtmann { 287ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 288ebd1e33bSMarcel Holtmann 289ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 290ebd1e33bSMarcel Holtmann *val = hdev->auto_accept_delay; 291ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 292ebd1e33bSMarcel Holtmann 293ebd1e33bSMarcel Holtmann return 0; 294ebd1e33bSMarcel Holtmann } 295ebd1e33bSMarcel Holtmann 296ebd1e33bSMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get, 297ebd1e33bSMarcel Holtmann auto_accept_delay_set, "%llu\n"); 298ebd1e33bSMarcel Holtmann 2992bfa3531SMarcel Holtmann static int idle_timeout_set(void *data, u64 val) 3002bfa3531SMarcel Holtmann { 3012bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 3022bfa3531SMarcel Holtmann 3032bfa3531SMarcel Holtmann if (val != 0 && (val < 500 || val > 3600000)) 3042bfa3531SMarcel Holtmann return -EINVAL; 3052bfa3531SMarcel Holtmann 3062bfa3531SMarcel Holtmann hci_dev_lock(hdev); 3072bfa3531SMarcel Holtmann hdev->idle_timeout= val; 3082bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 3092bfa3531SMarcel Holtmann 3102bfa3531SMarcel Holtmann return 0; 3112bfa3531SMarcel Holtmann } 3122bfa3531SMarcel Holtmann 3132bfa3531SMarcel Holtmann static int idle_timeout_get(void *data, u64 *val) 3142bfa3531SMarcel Holtmann { 3152bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 3162bfa3531SMarcel Holtmann 3172bfa3531SMarcel Holtmann hci_dev_lock(hdev); 3182bfa3531SMarcel Holtmann *val = hdev->idle_timeout; 3192bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 3202bfa3531SMarcel Holtmann 3212bfa3531SMarcel Holtmann return 0; 3222bfa3531SMarcel Holtmann } 3232bfa3531SMarcel Holtmann 3242bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get, 3252bfa3531SMarcel Holtmann idle_timeout_set, "%llu\n"); 3262bfa3531SMarcel Holtmann 3272bfa3531SMarcel Holtmann static int sniff_min_interval_set(void *data, u64 val) 3282bfa3531SMarcel Holtmann { 3292bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 3302bfa3531SMarcel Holtmann 3312bfa3531SMarcel Holtmann if (val == 0 || val % 2 || val > hdev->sniff_max_interval) 3322bfa3531SMarcel Holtmann return -EINVAL; 3332bfa3531SMarcel Holtmann 3342bfa3531SMarcel Holtmann hci_dev_lock(hdev); 3352bfa3531SMarcel Holtmann hdev->sniff_min_interval= val; 3362bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 3372bfa3531SMarcel Holtmann 3382bfa3531SMarcel Holtmann return 0; 3392bfa3531SMarcel Holtmann } 3402bfa3531SMarcel Holtmann 3412bfa3531SMarcel Holtmann static int sniff_min_interval_get(void *data, u64 *val) 3422bfa3531SMarcel Holtmann { 3432bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 3442bfa3531SMarcel Holtmann 3452bfa3531SMarcel Holtmann hci_dev_lock(hdev); 3462bfa3531SMarcel Holtmann *val = hdev->sniff_min_interval; 3472bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 3482bfa3531SMarcel Holtmann 3492bfa3531SMarcel Holtmann return 0; 3502bfa3531SMarcel Holtmann } 3512bfa3531SMarcel Holtmann 3522bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get, 3532bfa3531SMarcel Holtmann sniff_min_interval_set, "%llu\n"); 3542bfa3531SMarcel Holtmann 3552bfa3531SMarcel Holtmann static int sniff_max_interval_set(void *data, u64 val) 3562bfa3531SMarcel Holtmann { 3572bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 3582bfa3531SMarcel Holtmann 3592bfa3531SMarcel Holtmann if (val == 0 || val % 2 || val < hdev->sniff_min_interval) 3602bfa3531SMarcel Holtmann return -EINVAL; 3612bfa3531SMarcel Holtmann 3622bfa3531SMarcel Holtmann hci_dev_lock(hdev); 3632bfa3531SMarcel Holtmann hdev->sniff_max_interval= val; 3642bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 3652bfa3531SMarcel Holtmann 3662bfa3531SMarcel Holtmann return 0; 3672bfa3531SMarcel Holtmann } 3682bfa3531SMarcel Holtmann 3692bfa3531SMarcel Holtmann static int sniff_max_interval_get(void *data, u64 *val) 3702bfa3531SMarcel Holtmann { 3712bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 3722bfa3531SMarcel Holtmann 3732bfa3531SMarcel Holtmann hci_dev_lock(hdev); 3742bfa3531SMarcel Holtmann *val = hdev->sniff_max_interval; 3752bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 3762bfa3531SMarcel Holtmann 3772bfa3531SMarcel Holtmann return 0; 3782bfa3531SMarcel Holtmann } 3792bfa3531SMarcel Holtmann 3802bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get, 3812bfa3531SMarcel Holtmann sniff_max_interval_set, "%llu\n"); 3822bfa3531SMarcel Holtmann 383e7b8fc92SMarcel Holtmann static int static_address_show(struct seq_file *f, void *p) 384e7b8fc92SMarcel Holtmann { 385e7b8fc92SMarcel Holtmann struct hci_dev *hdev = f->private; 386e7b8fc92SMarcel Holtmann 387e7b8fc92SMarcel Holtmann hci_dev_lock(hdev); 388e7b8fc92SMarcel Holtmann seq_printf(f, "%pMR\n", &hdev->static_addr); 389e7b8fc92SMarcel Holtmann hci_dev_unlock(hdev); 390e7b8fc92SMarcel Holtmann 391e7b8fc92SMarcel Holtmann return 0; 392e7b8fc92SMarcel Holtmann } 393e7b8fc92SMarcel Holtmann 394e7b8fc92SMarcel Holtmann static int static_address_open(struct inode *inode, struct file *file) 395e7b8fc92SMarcel Holtmann { 396e7b8fc92SMarcel Holtmann return single_open(file, static_address_show, inode->i_private); 397e7b8fc92SMarcel Holtmann } 398e7b8fc92SMarcel Holtmann 399e7b8fc92SMarcel Holtmann static const struct file_operations static_address_fops = { 400e7b8fc92SMarcel Holtmann .open = static_address_open, 401e7b8fc92SMarcel Holtmann .read = seq_read, 402e7b8fc92SMarcel Holtmann .llseek = seq_lseek, 403e7b8fc92SMarcel Holtmann .release = single_release, 404e7b8fc92SMarcel Holtmann }; 405e7b8fc92SMarcel Holtmann 40692202185SMarcel Holtmann static int own_address_type_set(void *data, u64 val) 40792202185SMarcel Holtmann { 40892202185SMarcel Holtmann struct hci_dev *hdev = data; 40992202185SMarcel Holtmann 41092202185SMarcel Holtmann if (val != 0 && val != 1) 41192202185SMarcel Holtmann return -EINVAL; 41292202185SMarcel Holtmann 41392202185SMarcel Holtmann hci_dev_lock(hdev); 41492202185SMarcel Holtmann hdev->own_addr_type = val; 41592202185SMarcel Holtmann hci_dev_unlock(hdev); 41692202185SMarcel Holtmann 41792202185SMarcel Holtmann return 0; 41892202185SMarcel Holtmann } 41992202185SMarcel Holtmann 42092202185SMarcel Holtmann static int own_address_type_get(void *data, u64 *val) 42192202185SMarcel Holtmann { 42292202185SMarcel Holtmann struct hci_dev *hdev = data; 42392202185SMarcel Holtmann 42492202185SMarcel Holtmann hci_dev_lock(hdev); 42592202185SMarcel Holtmann *val = hdev->own_addr_type; 42692202185SMarcel Holtmann hci_dev_unlock(hdev); 42792202185SMarcel Holtmann 42892202185SMarcel Holtmann return 0; 42992202185SMarcel Holtmann } 43092202185SMarcel Holtmann 43192202185SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(own_address_type_fops, own_address_type_get, 43292202185SMarcel Holtmann own_address_type_set, "%llu\n"); 43392202185SMarcel Holtmann 4348f8625cdSMarcel Holtmann static int long_term_keys_show(struct seq_file *f, void *ptr) 4358f8625cdSMarcel Holtmann { 4368f8625cdSMarcel Holtmann struct hci_dev *hdev = f->private; 4378f8625cdSMarcel Holtmann struct list_head *p, *n; 4388f8625cdSMarcel Holtmann 4398f8625cdSMarcel Holtmann hci_dev_lock(hdev); 4408f8625cdSMarcel Holtmann list_for_each_safe(p, n, &hdev->link_keys) { 4418f8625cdSMarcel Holtmann struct smp_ltk *ltk = list_entry(p, struct smp_ltk, list); 4428f8625cdSMarcel Holtmann seq_printf(f, "%pMR (type %u) %u %u %u %.4x %*phN %*phN\\n", 4438f8625cdSMarcel Holtmann <k->bdaddr, ltk->bdaddr_type, ltk->authenticated, 4448f8625cdSMarcel Holtmann ltk->type, ltk->enc_size, __le16_to_cpu(ltk->ediv), 4458f8625cdSMarcel Holtmann 8, ltk->rand, 16, ltk->val); 4468f8625cdSMarcel Holtmann } 4478f8625cdSMarcel Holtmann hci_dev_unlock(hdev); 4488f8625cdSMarcel Holtmann 4498f8625cdSMarcel Holtmann return 0; 4508f8625cdSMarcel Holtmann } 4518f8625cdSMarcel Holtmann 4528f8625cdSMarcel Holtmann static int long_term_keys_open(struct inode *inode, struct file *file) 4538f8625cdSMarcel Holtmann { 4548f8625cdSMarcel Holtmann return single_open(file, long_term_keys_show, inode->i_private); 4558f8625cdSMarcel Holtmann } 4568f8625cdSMarcel Holtmann 4578f8625cdSMarcel Holtmann static const struct file_operations long_term_keys_fops = { 4588f8625cdSMarcel Holtmann .open = long_term_keys_open, 4598f8625cdSMarcel Holtmann .read = seq_read, 4608f8625cdSMarcel Holtmann .llseek = seq_lseek, 4618f8625cdSMarcel Holtmann .release = single_release, 4628f8625cdSMarcel Holtmann }; 4638f8625cdSMarcel Holtmann 4641da177e4SLinus Torvalds /* ---- HCI requests ---- */ 4651da177e4SLinus Torvalds 46642c6b129SJohan Hedberg static void hci_req_sync_complete(struct hci_dev *hdev, u8 result) 4671da177e4SLinus Torvalds { 46842c6b129SJohan Hedberg BT_DBG("%s result 0x%2.2x", hdev->name, result); 46975fb0e32SJohan Hedberg 4701da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 4711da177e4SLinus Torvalds hdev->req_result = result; 4721da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 4731da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 4741da177e4SLinus Torvalds } 4751da177e4SLinus Torvalds } 4761da177e4SLinus Torvalds 4771da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 4781da177e4SLinus Torvalds { 4791da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 4801da177e4SLinus Torvalds 4811da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 4821da177e4SLinus Torvalds hdev->req_result = err; 4831da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 4841da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 4851da177e4SLinus Torvalds } 4861da177e4SLinus Torvalds } 4871da177e4SLinus Torvalds 48877a63e0aSFengguang Wu static struct sk_buff *hci_get_cmd_complete(struct hci_dev *hdev, u16 opcode, 48977a63e0aSFengguang Wu u8 event) 49075e84b7cSJohan Hedberg { 49175e84b7cSJohan Hedberg struct hci_ev_cmd_complete *ev; 49275e84b7cSJohan Hedberg struct hci_event_hdr *hdr; 49375e84b7cSJohan Hedberg struct sk_buff *skb; 49475e84b7cSJohan Hedberg 49575e84b7cSJohan Hedberg hci_dev_lock(hdev); 49675e84b7cSJohan Hedberg 49775e84b7cSJohan Hedberg skb = hdev->recv_evt; 49875e84b7cSJohan Hedberg hdev->recv_evt = NULL; 49975e84b7cSJohan Hedberg 50075e84b7cSJohan Hedberg hci_dev_unlock(hdev); 50175e84b7cSJohan Hedberg 50275e84b7cSJohan Hedberg if (!skb) 50375e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 50475e84b7cSJohan Hedberg 50575e84b7cSJohan Hedberg if (skb->len < sizeof(*hdr)) { 50675e84b7cSJohan Hedberg BT_ERR("Too short HCI event"); 50775e84b7cSJohan Hedberg goto failed; 50875e84b7cSJohan Hedberg } 50975e84b7cSJohan Hedberg 51075e84b7cSJohan Hedberg hdr = (void *) skb->data; 51175e84b7cSJohan Hedberg skb_pull(skb, HCI_EVENT_HDR_SIZE); 51275e84b7cSJohan Hedberg 5137b1abbbeSJohan Hedberg if (event) { 5147b1abbbeSJohan Hedberg if (hdr->evt != event) 5157b1abbbeSJohan Hedberg goto failed; 5167b1abbbeSJohan Hedberg return skb; 5177b1abbbeSJohan Hedberg } 5187b1abbbeSJohan Hedberg 51975e84b7cSJohan Hedberg if (hdr->evt != HCI_EV_CMD_COMPLETE) { 52075e84b7cSJohan Hedberg BT_DBG("Last event is not cmd complete (0x%2.2x)", hdr->evt); 52175e84b7cSJohan Hedberg goto failed; 52275e84b7cSJohan Hedberg } 52375e84b7cSJohan Hedberg 52475e84b7cSJohan Hedberg if (skb->len < sizeof(*ev)) { 52575e84b7cSJohan Hedberg BT_ERR("Too short cmd_complete event"); 52675e84b7cSJohan Hedberg goto failed; 52775e84b7cSJohan Hedberg } 52875e84b7cSJohan Hedberg 52975e84b7cSJohan Hedberg ev = (void *) skb->data; 53075e84b7cSJohan Hedberg skb_pull(skb, sizeof(*ev)); 53175e84b7cSJohan Hedberg 53275e84b7cSJohan Hedberg if (opcode == __le16_to_cpu(ev->opcode)) 53375e84b7cSJohan Hedberg return skb; 53475e84b7cSJohan Hedberg 53575e84b7cSJohan Hedberg BT_DBG("opcode doesn't match (0x%2.2x != 0x%2.2x)", opcode, 53675e84b7cSJohan Hedberg __le16_to_cpu(ev->opcode)); 53775e84b7cSJohan Hedberg 53875e84b7cSJohan Hedberg failed: 53975e84b7cSJohan Hedberg kfree_skb(skb); 54075e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 54175e84b7cSJohan Hedberg } 54275e84b7cSJohan Hedberg 5437b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, 54407dc93ddSJohan Hedberg const void *param, u8 event, u32 timeout) 54575e84b7cSJohan Hedberg { 54675e84b7cSJohan Hedberg DECLARE_WAITQUEUE(wait, current); 54775e84b7cSJohan Hedberg struct hci_request req; 54875e84b7cSJohan Hedberg int err = 0; 54975e84b7cSJohan Hedberg 55075e84b7cSJohan Hedberg BT_DBG("%s", hdev->name); 55175e84b7cSJohan Hedberg 55275e84b7cSJohan Hedberg hci_req_init(&req, hdev); 55375e84b7cSJohan Hedberg 5547b1abbbeSJohan Hedberg hci_req_add_ev(&req, opcode, plen, param, event); 55575e84b7cSJohan Hedberg 55675e84b7cSJohan Hedberg hdev->req_status = HCI_REQ_PEND; 55775e84b7cSJohan Hedberg 55875e84b7cSJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 55975e84b7cSJohan Hedberg if (err < 0) 56075e84b7cSJohan Hedberg return ERR_PTR(err); 56175e84b7cSJohan Hedberg 56275e84b7cSJohan Hedberg add_wait_queue(&hdev->req_wait_q, &wait); 56375e84b7cSJohan Hedberg set_current_state(TASK_INTERRUPTIBLE); 56475e84b7cSJohan Hedberg 56575e84b7cSJohan Hedberg schedule_timeout(timeout); 56675e84b7cSJohan Hedberg 56775e84b7cSJohan Hedberg remove_wait_queue(&hdev->req_wait_q, &wait); 56875e84b7cSJohan Hedberg 56975e84b7cSJohan Hedberg if (signal_pending(current)) 57075e84b7cSJohan Hedberg return ERR_PTR(-EINTR); 57175e84b7cSJohan Hedberg 57275e84b7cSJohan Hedberg switch (hdev->req_status) { 57375e84b7cSJohan Hedberg case HCI_REQ_DONE: 57475e84b7cSJohan Hedberg err = -bt_to_errno(hdev->req_result); 57575e84b7cSJohan Hedberg break; 57675e84b7cSJohan Hedberg 57775e84b7cSJohan Hedberg case HCI_REQ_CANCELED: 57875e84b7cSJohan Hedberg err = -hdev->req_result; 57975e84b7cSJohan Hedberg break; 58075e84b7cSJohan Hedberg 58175e84b7cSJohan Hedberg default: 58275e84b7cSJohan Hedberg err = -ETIMEDOUT; 58375e84b7cSJohan Hedberg break; 58475e84b7cSJohan Hedberg } 58575e84b7cSJohan Hedberg 58675e84b7cSJohan Hedberg hdev->req_status = hdev->req_result = 0; 58775e84b7cSJohan Hedberg 58875e84b7cSJohan Hedberg BT_DBG("%s end: err %d", hdev->name, err); 58975e84b7cSJohan Hedberg 59075e84b7cSJohan Hedberg if (err < 0) 59175e84b7cSJohan Hedberg return ERR_PTR(err); 59275e84b7cSJohan Hedberg 5937b1abbbeSJohan Hedberg return hci_get_cmd_complete(hdev, opcode, event); 5947b1abbbeSJohan Hedberg } 5957b1abbbeSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync_ev); 5967b1abbbeSJohan Hedberg 5977b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 59807dc93ddSJohan Hedberg const void *param, u32 timeout) 5997b1abbbeSJohan Hedberg { 6007b1abbbeSJohan Hedberg return __hci_cmd_sync_ev(hdev, opcode, plen, param, 0, timeout); 60175e84b7cSJohan Hedberg } 60275e84b7cSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync); 60375e84b7cSJohan Hedberg 6041da177e4SLinus Torvalds /* Execute request and wait for completion. */ 60501178cd4SJohan Hedberg static int __hci_req_sync(struct hci_dev *hdev, 60642c6b129SJohan Hedberg void (*func)(struct hci_request *req, 60742c6b129SJohan Hedberg unsigned long opt), 6081da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 6091da177e4SLinus Torvalds { 61042c6b129SJohan Hedberg struct hci_request req; 6111da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 6121da177e4SLinus Torvalds int err = 0; 6131da177e4SLinus Torvalds 6141da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 6151da177e4SLinus Torvalds 61642c6b129SJohan Hedberg hci_req_init(&req, hdev); 61742c6b129SJohan Hedberg 6181da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 6191da177e4SLinus Torvalds 62042c6b129SJohan Hedberg func(&req, opt); 62153cce22dSJohan Hedberg 62242c6b129SJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 62342c6b129SJohan Hedberg if (err < 0) { 62453cce22dSJohan Hedberg hdev->req_status = 0; 625920c8300SAndre Guedes 626920c8300SAndre Guedes /* ENODATA means the HCI request command queue is empty. 627920c8300SAndre Guedes * This can happen when a request with conditionals doesn't 628920c8300SAndre Guedes * trigger any commands to be sent. This is normal behavior 629920c8300SAndre Guedes * and should not trigger an error return. 63042c6b129SJohan Hedberg */ 631920c8300SAndre Guedes if (err == -ENODATA) 63242c6b129SJohan Hedberg return 0; 633920c8300SAndre Guedes 634920c8300SAndre Guedes return err; 63553cce22dSJohan Hedberg } 63653cce22dSJohan Hedberg 637bc4445c7SAndre Guedes add_wait_queue(&hdev->req_wait_q, &wait); 638bc4445c7SAndre Guedes set_current_state(TASK_INTERRUPTIBLE); 639bc4445c7SAndre Guedes 6401da177e4SLinus Torvalds schedule_timeout(timeout); 6411da177e4SLinus Torvalds 6421da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 6431da177e4SLinus Torvalds 6441da177e4SLinus Torvalds if (signal_pending(current)) 6451da177e4SLinus Torvalds return -EINTR; 6461da177e4SLinus Torvalds 6471da177e4SLinus Torvalds switch (hdev->req_status) { 6481da177e4SLinus Torvalds case HCI_REQ_DONE: 649e175072fSJoe Perches err = -bt_to_errno(hdev->req_result); 6501da177e4SLinus Torvalds break; 6511da177e4SLinus Torvalds 6521da177e4SLinus Torvalds case HCI_REQ_CANCELED: 6531da177e4SLinus Torvalds err = -hdev->req_result; 6541da177e4SLinus Torvalds break; 6551da177e4SLinus Torvalds 6561da177e4SLinus Torvalds default: 6571da177e4SLinus Torvalds err = -ETIMEDOUT; 6581da177e4SLinus Torvalds break; 6593ff50b79SStephen Hemminger } 6601da177e4SLinus Torvalds 661a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 6621da177e4SLinus Torvalds 6631da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 6641da177e4SLinus Torvalds 6651da177e4SLinus Torvalds return err; 6661da177e4SLinus Torvalds } 6671da177e4SLinus Torvalds 66801178cd4SJohan Hedberg static int hci_req_sync(struct hci_dev *hdev, 66942c6b129SJohan Hedberg void (*req)(struct hci_request *req, 67042c6b129SJohan Hedberg unsigned long opt), 6711da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 6721da177e4SLinus Torvalds { 6731da177e4SLinus Torvalds int ret; 6741da177e4SLinus Torvalds 6757c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 6767c6a329eSMarcel Holtmann return -ENETDOWN; 6777c6a329eSMarcel Holtmann 6781da177e4SLinus Torvalds /* Serialize all requests */ 6791da177e4SLinus Torvalds hci_req_lock(hdev); 68001178cd4SJohan Hedberg ret = __hci_req_sync(hdev, req, opt, timeout); 6811da177e4SLinus Torvalds hci_req_unlock(hdev); 6821da177e4SLinus Torvalds 6831da177e4SLinus Torvalds return ret; 6841da177e4SLinus Torvalds } 6851da177e4SLinus Torvalds 68642c6b129SJohan Hedberg static void hci_reset_req(struct hci_request *req, unsigned long opt) 6871da177e4SLinus Torvalds { 68842c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 6891da177e4SLinus Torvalds 6901da177e4SLinus Torvalds /* Reset device */ 69142c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 69242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 6931da177e4SLinus Torvalds } 6941da177e4SLinus Torvalds 69542c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 6961da177e4SLinus Torvalds { 69742c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 6982455a3eaSAndrei Emeltchenko 6991da177e4SLinus Torvalds /* Read Local Supported Features */ 70042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 7011da177e4SLinus Torvalds 7021143e5a6SMarcel Holtmann /* Read Local Version */ 70342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 7042177bab5SJohan Hedberg 7052177bab5SJohan Hedberg /* Read BD Address */ 70642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 7071da177e4SLinus Torvalds } 7081da177e4SLinus Torvalds 70942c6b129SJohan Hedberg static void amp_init(struct hci_request *req) 710e61ef499SAndrei Emeltchenko { 71142c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 7122455a3eaSAndrei Emeltchenko 713e61ef499SAndrei Emeltchenko /* Read Local Version */ 71442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 7156bcbc489SAndrei Emeltchenko 716f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 717f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 718f6996cfeSMarcel Holtmann 719f6996cfeSMarcel Holtmann /* Read Local Supported Features */ 720f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 721f6996cfeSMarcel Holtmann 7226bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 72342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 724e71dfabaSAndrei Emeltchenko 725e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 72642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 7277528ca1cSMarcel Holtmann 728f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 729f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 730f38ba941SMarcel Holtmann 7317528ca1cSMarcel Holtmann /* Read Location Data */ 7327528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 733e61ef499SAndrei Emeltchenko } 734e61ef499SAndrei Emeltchenko 73542c6b129SJohan Hedberg static void hci_init1_req(struct hci_request *req, unsigned long opt) 736e61ef499SAndrei Emeltchenko { 73742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 738e61ef499SAndrei Emeltchenko 739e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 740e61ef499SAndrei Emeltchenko 74111778716SAndrei Emeltchenko /* Reset */ 74211778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 74342c6b129SJohan Hedberg hci_reset_req(req, 0); 74411778716SAndrei Emeltchenko 745e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 746e61ef499SAndrei Emeltchenko case HCI_BREDR: 74742c6b129SJohan Hedberg bredr_init(req); 748e61ef499SAndrei Emeltchenko break; 749e61ef499SAndrei Emeltchenko 750e61ef499SAndrei Emeltchenko case HCI_AMP: 75142c6b129SJohan Hedberg amp_init(req); 752e61ef499SAndrei Emeltchenko break; 753e61ef499SAndrei Emeltchenko 754e61ef499SAndrei Emeltchenko default: 755e61ef499SAndrei Emeltchenko BT_ERR("Unknown device type %d", hdev->dev_type); 756e61ef499SAndrei Emeltchenko break; 757e61ef499SAndrei Emeltchenko } 758e61ef499SAndrei Emeltchenko } 759e61ef499SAndrei Emeltchenko 76042c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 7612177bab5SJohan Hedberg { 7624ca048e3SMarcel Holtmann struct hci_dev *hdev = req->hdev; 7634ca048e3SMarcel Holtmann 7642177bab5SJohan Hedberg __le16 param; 7652177bab5SJohan Hedberg __u8 flt_type; 7662177bab5SJohan Hedberg 7672177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 76842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 7692177bab5SJohan Hedberg 7702177bab5SJohan Hedberg /* Read Class of Device */ 77142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 7722177bab5SJohan Hedberg 7732177bab5SJohan Hedberg /* Read Local Name */ 77442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 7752177bab5SJohan Hedberg 7762177bab5SJohan Hedberg /* Read Voice Setting */ 77742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 7782177bab5SJohan Hedberg 779b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 780b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 781b4cb9fb2SMarcel Holtmann 7824b836f39SMarcel Holtmann /* Read Current IAC LAP */ 7834b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 7844b836f39SMarcel Holtmann 7852177bab5SJohan Hedberg /* Clear Event Filters */ 7862177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 78742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 7882177bab5SJohan Hedberg 7892177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 7902177bab5SJohan Hedberg param = __constant_cpu_to_le16(0x7d00); 79142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 7922177bab5SJohan Hedberg 7934ca048e3SMarcel Holtmann /* AVM Berlin (31), aka "BlueFRITZ!", reports version 1.2, 7944ca048e3SMarcel Holtmann * but it does not support page scan related HCI commands. 7954ca048e3SMarcel Holtmann */ 7964ca048e3SMarcel Holtmann if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) { 797f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 798f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 799f332ec66SJohan Hedberg } 8002177bab5SJohan Hedberg } 8012177bab5SJohan Hedberg 80242c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 8032177bab5SJohan Hedberg { 804c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 805c73eee91SJohan Hedberg 8062177bab5SJohan Hedberg /* Read LE Buffer Size */ 80742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 8082177bab5SJohan Hedberg 8092177bab5SJohan Hedberg /* Read LE Local Supported Features */ 81042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 8112177bab5SJohan Hedberg 8122177bab5SJohan Hedberg /* Read LE Advertising Channel TX Power */ 81342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 8142177bab5SJohan Hedberg 8152177bab5SJohan Hedberg /* Read LE White List Size */ 81642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 0, NULL); 8172177bab5SJohan Hedberg 8182177bab5SJohan Hedberg /* Read LE Supported States */ 81942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 820c73eee91SJohan Hedberg 821c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 822c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 823c73eee91SJohan Hedberg set_bit(HCI_LE_ENABLED, &hdev->dev_flags); 8242177bab5SJohan Hedberg } 8252177bab5SJohan Hedberg 8262177bab5SJohan Hedberg static u8 hci_get_inquiry_mode(struct hci_dev *hdev) 8272177bab5SJohan Hedberg { 8282177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 8292177bab5SJohan Hedberg return 0x02; 8302177bab5SJohan Hedberg 8312177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 8322177bab5SJohan Hedberg return 0x01; 8332177bab5SJohan Hedberg 8342177bab5SJohan Hedberg if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 && 8352177bab5SJohan Hedberg hdev->lmp_subver == 0x0757) 8362177bab5SJohan Hedberg return 0x01; 8372177bab5SJohan Hedberg 8382177bab5SJohan Hedberg if (hdev->manufacturer == 15) { 8392177bab5SJohan Hedberg if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963) 8402177bab5SJohan Hedberg return 0x01; 8412177bab5SJohan Hedberg if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963) 8422177bab5SJohan Hedberg return 0x01; 8432177bab5SJohan Hedberg if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965) 8442177bab5SJohan Hedberg return 0x01; 8452177bab5SJohan Hedberg } 8462177bab5SJohan Hedberg 8472177bab5SJohan Hedberg if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 && 8482177bab5SJohan Hedberg hdev->lmp_subver == 0x1805) 8492177bab5SJohan Hedberg return 0x01; 8502177bab5SJohan Hedberg 8512177bab5SJohan Hedberg return 0x00; 8522177bab5SJohan Hedberg } 8532177bab5SJohan Hedberg 85442c6b129SJohan Hedberg static void hci_setup_inquiry_mode(struct hci_request *req) 8552177bab5SJohan Hedberg { 8562177bab5SJohan Hedberg u8 mode; 8572177bab5SJohan Hedberg 85842c6b129SJohan Hedberg mode = hci_get_inquiry_mode(req->hdev); 8592177bab5SJohan Hedberg 86042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 8612177bab5SJohan Hedberg } 8622177bab5SJohan Hedberg 86342c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 8642177bab5SJohan Hedberg { 86542c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 86642c6b129SJohan Hedberg 8672177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 8682177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 8692177bab5SJohan Hedberg * command otherwise. 8702177bab5SJohan Hedberg */ 8712177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 8722177bab5SJohan Hedberg 8732177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 8742177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 8752177bab5SJohan Hedberg */ 8762177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 8772177bab5SJohan Hedberg return; 8782177bab5SJohan Hedberg 8792177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 8802177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 8812177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 8822177bab5SJohan Hedberg events[4] |= 0x04; /* Read Remote Extended Features Complete */ 8832177bab5SJohan Hedberg events[5] |= 0x08; /* Synchronous Connection Complete */ 8842177bab5SJohan Hedberg events[5] |= 0x10; /* Synchronous Connection Changed */ 885c7882cbdSMarcel Holtmann } else { 886c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 887c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 888c7882cbdSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 889c7882cbdSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 890c7882cbdSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information Complete */ 891c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 892c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 893c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 894c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 895c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 896c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 8972177bab5SJohan Hedberg } 8982177bab5SJohan Hedberg 8992177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 9002177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 9012177bab5SJohan Hedberg 9022177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 9032177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 9042177bab5SJohan Hedberg 9052177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 9062177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 9072177bab5SJohan Hedberg 9082177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 9092177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 9102177bab5SJohan Hedberg 9112177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 9122177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 9132177bab5SJohan Hedberg 9142177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 9152177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 9162177bab5SJohan Hedberg 9172177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 9182177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 9192177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 9202177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 9212177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 9222177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 9232177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 9242177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 9252177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 9262177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 9272177bab5SJohan Hedberg * Features Notification 9282177bab5SJohan Hedberg */ 9292177bab5SJohan Hedberg } 9302177bab5SJohan Hedberg 9312177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 9322177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 9332177bab5SJohan Hedberg 93442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 9352177bab5SJohan Hedberg 9362177bab5SJohan Hedberg if (lmp_le_capable(hdev)) { 9372177bab5SJohan Hedberg memset(events, 0, sizeof(events)); 9382177bab5SJohan Hedberg events[0] = 0x1f; 93942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, 9402177bab5SJohan Hedberg sizeof(events), events); 9412177bab5SJohan Hedberg } 9422177bab5SJohan Hedberg } 9432177bab5SJohan Hedberg 94442c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 9452177bab5SJohan Hedberg { 94642c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 94742c6b129SJohan Hedberg 9482177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 94942c6b129SJohan Hedberg bredr_setup(req); 95056f87901SJohan Hedberg else 95156f87901SJohan Hedberg clear_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 9522177bab5SJohan Hedberg 9532177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 95442c6b129SJohan Hedberg le_setup(req); 9552177bab5SJohan Hedberg 95642c6b129SJohan Hedberg hci_setup_event_mask(req); 9572177bab5SJohan Hedberg 9583f8e2d75SJohan Hedberg /* AVM Berlin (31), aka "BlueFRITZ!", doesn't support the read 9593f8e2d75SJohan Hedberg * local supported commands HCI command. 9603f8e2d75SJohan Hedberg */ 9613f8e2d75SJohan Hedberg if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) 96242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 9632177bab5SJohan Hedberg 9642177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 96557af75a8SMarcel Holtmann /* When SSP is available, then the host features page 96657af75a8SMarcel Holtmann * should also be available as well. However some 96757af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 96857af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 96957af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 97057af75a8SMarcel Holtmann */ 97157af75a8SMarcel Holtmann hdev->max_page = 0x01; 97257af75a8SMarcel Holtmann 9732177bab5SJohan Hedberg if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) { 9742177bab5SJohan Hedberg u8 mode = 0x01; 97542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 9762177bab5SJohan Hedberg sizeof(mode), &mode); 9772177bab5SJohan Hedberg } else { 9782177bab5SJohan Hedberg struct hci_cp_write_eir cp; 9792177bab5SJohan Hedberg 9802177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 9812177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 9822177bab5SJohan Hedberg 98342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 9842177bab5SJohan Hedberg } 9852177bab5SJohan Hedberg } 9862177bab5SJohan Hedberg 9872177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 98842c6b129SJohan Hedberg hci_setup_inquiry_mode(req); 9892177bab5SJohan Hedberg 9902177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 99142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 9922177bab5SJohan Hedberg 9932177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 9942177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 9952177bab5SJohan Hedberg 9962177bab5SJohan Hedberg cp.page = 0x01; 99742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 99842c6b129SJohan Hedberg sizeof(cp), &cp); 9992177bab5SJohan Hedberg } 10002177bab5SJohan Hedberg 10012177bab5SJohan Hedberg if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) { 10022177bab5SJohan Hedberg u8 enable = 1; 100342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 10042177bab5SJohan Hedberg &enable); 10052177bab5SJohan Hedberg } 10062177bab5SJohan Hedberg } 10072177bab5SJohan Hedberg 100842c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 10092177bab5SJohan Hedberg { 101042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 10112177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 10122177bab5SJohan Hedberg u16 link_policy = 0; 10132177bab5SJohan Hedberg 10142177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 10152177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 10162177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 10172177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 10182177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 10192177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 10202177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 10212177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 10222177bab5SJohan Hedberg 10232177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 102442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 10252177bab5SJohan Hedberg } 10262177bab5SJohan Hedberg 102742c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 10282177bab5SJohan Hedberg { 102942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 10302177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 10312177bab5SJohan Hedberg 1032c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 1033c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 1034c73eee91SJohan Hedberg return; 1035c73eee91SJohan Hedberg 10362177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 10372177bab5SJohan Hedberg 10382177bab5SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) { 10392177bab5SJohan Hedberg cp.le = 0x01; 10402177bab5SJohan Hedberg cp.simul = lmp_le_br_capable(hdev); 10412177bab5SJohan Hedberg } 10422177bab5SJohan Hedberg 10432177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 104442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 10452177bab5SJohan Hedberg &cp); 10462177bab5SJohan Hedberg } 10472177bab5SJohan Hedberg 1048d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 1049d62e6d67SJohan Hedberg { 1050d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 1051d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 1052d62e6d67SJohan Hedberg 1053d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 1054d62e6d67SJohan Hedberg * enable all necessary events for it. 1055d62e6d67SJohan Hedberg */ 1056d62e6d67SJohan Hedberg if (hdev->features[2][0] & 0x01) { 1057d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 1058d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 1059d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 1060d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 1061d62e6d67SJohan Hedberg } 1062d62e6d67SJohan Hedberg 1063d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 1064d62e6d67SJohan Hedberg * enable all necessary events for it. 1065d62e6d67SJohan Hedberg */ 1066d62e6d67SJohan Hedberg if (hdev->features[2][0] & 0x02) { 1067d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 1068d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 1069d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 1070d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 1071d62e6d67SJohan Hedberg } 1072d62e6d67SJohan Hedberg 1073d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 1074d62e6d67SJohan Hedberg } 1075d62e6d67SJohan Hedberg 107642c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 10772177bab5SJohan Hedberg { 107842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 1079d2c5d77fSJohan Hedberg u8 p; 108042c6b129SJohan Hedberg 1081b8f4e068SGustavo Padovan /* Some Broadcom based Bluetooth controllers do not support the 1082b8f4e068SGustavo Padovan * Delete Stored Link Key command. They are clearly indicating its 1083b8f4e068SGustavo Padovan * absence in the bit mask of supported commands. 1084b8f4e068SGustavo Padovan * 1085b8f4e068SGustavo Padovan * Check the supported commands and only if the the command is marked 1086b8f4e068SGustavo Padovan * as supported send it. If not supported assume that the controller 1087b8f4e068SGustavo Padovan * does not have actual support for stored link keys which makes this 1088b8f4e068SGustavo Padovan * command redundant anyway. 1089b8f4e068SGustavo Padovan */ 109059f45d57SJohan Hedberg if (hdev->commands[6] & 0x80) { 109159f45d57SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 109259f45d57SJohan Hedberg 109359f45d57SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 109459f45d57SJohan Hedberg cp.delete_all = 0x01; 109559f45d57SJohan Hedberg hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 109659f45d57SJohan Hedberg sizeof(cp), &cp); 109759f45d57SJohan Hedberg } 109859f45d57SJohan Hedberg 10992177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 110042c6b129SJohan Hedberg hci_setup_link_policy(req); 11012177bab5SJohan Hedberg 110279830f66SMarcel Holtmann if (lmp_le_capable(hdev)) { 110379830f66SMarcel Holtmann /* If the controller has a public BD_ADDR, then by 110479830f66SMarcel Holtmann * default use that one. If this is a LE only 110579830f66SMarcel Holtmann * controller without one, default to the random 110679830f66SMarcel Holtmann * address. 110779830f66SMarcel Holtmann */ 110879830f66SMarcel Holtmann if (bacmp(&hdev->bdaddr, BDADDR_ANY)) 110979830f66SMarcel Holtmann hdev->own_addr_type = ADDR_LE_DEV_PUBLIC; 111079830f66SMarcel Holtmann else 111179830f66SMarcel Holtmann hdev->own_addr_type = ADDR_LE_DEV_RANDOM; 111279830f66SMarcel Holtmann 111342c6b129SJohan Hedberg hci_set_le_support(req); 111479830f66SMarcel Holtmann } 1115d2c5d77fSJohan Hedberg 1116d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 1117d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 1118d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 1119d2c5d77fSJohan Hedberg 1120d2c5d77fSJohan Hedberg cp.page = p; 1121d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 1122d2c5d77fSJohan Hedberg sizeof(cp), &cp); 1123d2c5d77fSJohan Hedberg } 11242177bab5SJohan Hedberg } 11252177bab5SJohan Hedberg 11265d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 11275d4e7e8dSJohan Hedberg { 11285d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 11295d4e7e8dSJohan Hedberg 1130d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 1131d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 1132d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 1133d62e6d67SJohan Hedberg 11345d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 11355d4e7e8dSJohan Hedberg if (hdev->features[2][0] & 0x04) 11365d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 11375d4e7e8dSJohan Hedberg } 11385d4e7e8dSJohan Hedberg 11392177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 11402177bab5SJohan Hedberg { 11412177bab5SJohan Hedberg int err; 11422177bab5SJohan Hedberg 11432177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 11442177bab5SJohan Hedberg if (err < 0) 11452177bab5SJohan Hedberg return err; 11462177bab5SJohan Hedberg 11472177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 11482177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 11492177bab5SJohan Hedberg * first stage init. 11502177bab5SJohan Hedberg */ 11512177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 11522177bab5SJohan Hedberg return 0; 11532177bab5SJohan Hedberg 11542177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 11552177bab5SJohan Hedberg if (err < 0) 11562177bab5SJohan Hedberg return err; 11572177bab5SJohan Hedberg 11585d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 11595d4e7e8dSJohan Hedberg if (err < 0) 11605d4e7e8dSJohan Hedberg return err; 11615d4e7e8dSJohan Hedberg 1162baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 1163baf27f6eSMarcel Holtmann if (err < 0) 1164baf27f6eSMarcel Holtmann return err; 1165baf27f6eSMarcel Holtmann 1166baf27f6eSMarcel Holtmann /* Only create debugfs entries during the initial setup 1167baf27f6eSMarcel Holtmann * phase and not every time the controller gets powered on. 1168baf27f6eSMarcel Holtmann */ 1169baf27f6eSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 1170baf27f6eSMarcel Holtmann return 0; 1171baf27f6eSMarcel Holtmann 1172dfb826a8SMarcel Holtmann debugfs_create_file("features", 0444, hdev->debugfs, hdev, 1173dfb826a8SMarcel Holtmann &features_fops); 1174ceeb3bc0SMarcel Holtmann debugfs_create_u16("manufacturer", 0444, hdev->debugfs, 1175ceeb3bc0SMarcel Holtmann &hdev->manufacturer); 1176ceeb3bc0SMarcel Holtmann debugfs_create_u8("hci_version", 0444, hdev->debugfs, &hdev->hci_ver); 1177ceeb3bc0SMarcel Holtmann debugfs_create_u16("hci_revision", 0444, hdev->debugfs, &hdev->hci_rev); 117870afe0b8SMarcel Holtmann debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev, 117970afe0b8SMarcel Holtmann &blacklist_fops); 118047219839SMarcel Holtmann debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 118147219839SMarcel Holtmann 1182baf27f6eSMarcel Holtmann if (lmp_bredr_capable(hdev)) { 1183baf27f6eSMarcel Holtmann debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, 1184baf27f6eSMarcel Holtmann hdev, &inquiry_cache_fops); 118502d08d15SMarcel Holtmann debugfs_create_file("link_keys", 0400, hdev->debugfs, 118602d08d15SMarcel Holtmann hdev, &link_keys_fops); 118712c269d7SMarcel Holtmann debugfs_create_file("use_debug_keys", 0444, hdev->debugfs, 118812c269d7SMarcel Holtmann hdev, &use_debug_keys_fops); 1189babdbb3cSMarcel Holtmann debugfs_create_file("dev_class", 0444, hdev->debugfs, 1190babdbb3cSMarcel Holtmann hdev, &dev_class_fops); 1191041000b9SMarcel Holtmann debugfs_create_file("voice_setting", 0444, hdev->debugfs, 1192041000b9SMarcel Holtmann hdev, &voice_setting_fops); 1193baf27f6eSMarcel Holtmann } 1194baf27f6eSMarcel Holtmann 1195ebd1e33bSMarcel Holtmann if (lmp_ssp_capable(hdev)) 1196ebd1e33bSMarcel Holtmann debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 1197ebd1e33bSMarcel Holtmann hdev, &auto_accept_delay_fops); 1198ebd1e33bSMarcel Holtmann 11992bfa3531SMarcel Holtmann if (lmp_sniff_capable(hdev)) { 12002bfa3531SMarcel Holtmann debugfs_create_file("idle_timeout", 0644, hdev->debugfs, 12012bfa3531SMarcel Holtmann hdev, &idle_timeout_fops); 12022bfa3531SMarcel Holtmann debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs, 12032bfa3531SMarcel Holtmann hdev, &sniff_min_interval_fops); 12042bfa3531SMarcel Holtmann debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs, 12052bfa3531SMarcel Holtmann hdev, &sniff_max_interval_fops); 12062bfa3531SMarcel Holtmann } 12072bfa3531SMarcel Holtmann 1208d0f729b8SMarcel Holtmann if (lmp_le_capable(hdev)) { 1209d0f729b8SMarcel Holtmann debugfs_create_u8("white_list_size", 0444, hdev->debugfs, 1210d0f729b8SMarcel Holtmann &hdev->le_white_list_size); 1211e7b8fc92SMarcel Holtmann debugfs_create_file("static_address", 0444, hdev->debugfs, 1212e7b8fc92SMarcel Holtmann hdev, &static_address_fops); 121392202185SMarcel Holtmann debugfs_create_file("own_address_type", 0644, hdev->debugfs, 121492202185SMarcel Holtmann hdev, &own_address_type_fops); 12158f8625cdSMarcel Holtmann debugfs_create_file("long_term_keys", 0400, hdev->debugfs, 12168f8625cdSMarcel Holtmann hdev, &long_term_keys_fops); 1217d0f729b8SMarcel Holtmann } 1218e7b8fc92SMarcel Holtmann 1219baf27f6eSMarcel Holtmann return 0; 12202177bab5SJohan Hedberg } 12212177bab5SJohan Hedberg 122242c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 12231da177e4SLinus Torvalds { 12241da177e4SLinus Torvalds __u8 scan = opt; 12251da177e4SLinus Torvalds 122642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 12271da177e4SLinus Torvalds 12281da177e4SLinus Torvalds /* Inquiry and Page scans */ 122942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 12301da177e4SLinus Torvalds } 12311da177e4SLinus Torvalds 123242c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 12331da177e4SLinus Torvalds { 12341da177e4SLinus Torvalds __u8 auth = opt; 12351da177e4SLinus Torvalds 123642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 12371da177e4SLinus Torvalds 12381da177e4SLinus Torvalds /* Authentication */ 123942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 12401da177e4SLinus Torvalds } 12411da177e4SLinus Torvalds 124242c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 12431da177e4SLinus Torvalds { 12441da177e4SLinus Torvalds __u8 encrypt = opt; 12451da177e4SLinus Torvalds 124642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 12471da177e4SLinus Torvalds 1248e4e8e37cSMarcel Holtmann /* Encryption */ 124942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 12501da177e4SLinus Torvalds } 12511da177e4SLinus Torvalds 125242c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1253e4e8e37cSMarcel Holtmann { 1254e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1255e4e8e37cSMarcel Holtmann 125642c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1257e4e8e37cSMarcel Holtmann 1258e4e8e37cSMarcel Holtmann /* Default link policy */ 125942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1260e4e8e37cSMarcel Holtmann } 1261e4e8e37cSMarcel Holtmann 12621da177e4SLinus Torvalds /* Get HCI device by index. 12631da177e4SLinus Torvalds * Device is held on return. */ 12641da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 12651da177e4SLinus Torvalds { 12668035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 12671da177e4SLinus Torvalds 12681da177e4SLinus Torvalds BT_DBG("%d", index); 12691da177e4SLinus Torvalds 12701da177e4SLinus Torvalds if (index < 0) 12711da177e4SLinus Torvalds return NULL; 12721da177e4SLinus Torvalds 12731da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 12748035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 12751da177e4SLinus Torvalds if (d->id == index) { 12761da177e4SLinus Torvalds hdev = hci_dev_hold(d); 12771da177e4SLinus Torvalds break; 12781da177e4SLinus Torvalds } 12791da177e4SLinus Torvalds } 12801da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 12811da177e4SLinus Torvalds return hdev; 12821da177e4SLinus Torvalds } 12831da177e4SLinus Torvalds 12841da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1285ff9ef578SJohan Hedberg 128630dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 128730dc78e1SJohan Hedberg { 128830dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 128930dc78e1SJohan Hedberg 12906fbe195dSAndre Guedes switch (discov->state) { 1291343f935bSAndre Guedes case DISCOVERY_FINDING: 12926fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 129330dc78e1SJohan Hedberg return true; 129430dc78e1SJohan Hedberg 12956fbe195dSAndre Guedes default: 129630dc78e1SJohan Hedberg return false; 129730dc78e1SJohan Hedberg } 12986fbe195dSAndre Guedes } 129930dc78e1SJohan Hedberg 1300ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1301ff9ef578SJohan Hedberg { 1302ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1303ff9ef578SJohan Hedberg 1304ff9ef578SJohan Hedberg if (hdev->discovery.state == state) 1305ff9ef578SJohan Hedberg return; 1306ff9ef578SJohan Hedberg 1307ff9ef578SJohan Hedberg switch (state) { 1308ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 13097b99b659SAndre Guedes if (hdev->discovery.state != DISCOVERY_STARTING) 1310ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1311ff9ef578SJohan Hedberg break; 1312ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1313ff9ef578SJohan Hedberg break; 1314343f935bSAndre Guedes case DISCOVERY_FINDING: 1315ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1316ff9ef578SJohan Hedberg break; 131730dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 131830dc78e1SJohan Hedberg break; 1319ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1320ff9ef578SJohan Hedberg break; 1321ff9ef578SJohan Hedberg } 1322ff9ef578SJohan Hedberg 1323ff9ef578SJohan Hedberg hdev->discovery.state = state; 1324ff9ef578SJohan Hedberg } 1325ff9ef578SJohan Hedberg 13261f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 13271da177e4SLinus Torvalds { 132830883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1329b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 13301da177e4SLinus Torvalds 1331561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1332561aafbcSJohan Hedberg list_del(&p->all); 1333b57c1a56SJohan Hedberg kfree(p); 13341da177e4SLinus Torvalds } 1335561aafbcSJohan Hedberg 1336561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1337561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 13381da177e4SLinus Torvalds } 13391da177e4SLinus Torvalds 1340a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1341a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 13421da177e4SLinus Torvalds { 134330883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 13441da177e4SLinus Torvalds struct inquiry_entry *e; 13451da177e4SLinus Torvalds 13466ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 13471da177e4SLinus Torvalds 1348561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 13491da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 13501da177e4SLinus Torvalds return e; 13511da177e4SLinus Torvalds } 13521da177e4SLinus Torvalds 1353b57c1a56SJohan Hedberg return NULL; 1354b57c1a56SJohan Hedberg } 1355b57c1a56SJohan Hedberg 1356561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1357561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1358561aafbcSJohan Hedberg { 135930883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1360561aafbcSJohan Hedberg struct inquiry_entry *e; 1361561aafbcSJohan Hedberg 13626ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1363561aafbcSJohan Hedberg 1364561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1365561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1366561aafbcSJohan Hedberg return e; 1367561aafbcSJohan Hedberg } 1368561aafbcSJohan Hedberg 1369561aafbcSJohan Hedberg return NULL; 1370561aafbcSJohan Hedberg } 1371561aafbcSJohan Hedberg 137230dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 137330dc78e1SJohan Hedberg bdaddr_t *bdaddr, 137430dc78e1SJohan Hedberg int state) 137530dc78e1SJohan Hedberg { 137630dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 137730dc78e1SJohan Hedberg struct inquiry_entry *e; 137830dc78e1SJohan Hedberg 13796ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 138030dc78e1SJohan Hedberg 138130dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 138230dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 138330dc78e1SJohan Hedberg return e; 138430dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 138530dc78e1SJohan Hedberg return e; 138630dc78e1SJohan Hedberg } 138730dc78e1SJohan Hedberg 138830dc78e1SJohan Hedberg return NULL; 138930dc78e1SJohan Hedberg } 139030dc78e1SJohan Hedberg 1391a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1392a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1393a3d4e20aSJohan Hedberg { 1394a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1395a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1396a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1397a3d4e20aSJohan Hedberg 1398a3d4e20aSJohan Hedberg list_del(&ie->list); 1399a3d4e20aSJohan Hedberg 1400a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1401a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1402a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1403a3d4e20aSJohan Hedberg break; 1404a3d4e20aSJohan Hedberg pos = &p->list; 1405a3d4e20aSJohan Hedberg } 1406a3d4e20aSJohan Hedberg 1407a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1408a3d4e20aSJohan Hedberg } 1409a3d4e20aSJohan Hedberg 14103175405bSJohan Hedberg bool hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1411388fc8faSJohan Hedberg bool name_known, bool *ssp) 14121da177e4SLinus Torvalds { 141330883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 141470f23020SAndrei Emeltchenko struct inquiry_entry *ie; 14151da177e4SLinus Torvalds 14166ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 14171da177e4SLinus Torvalds 14182b2fec4dSSzymon Janc hci_remove_remote_oob_data(hdev, &data->bdaddr); 14192b2fec4dSSzymon Janc 1420388fc8faSJohan Hedberg if (ssp) 1421388fc8faSJohan Hedberg *ssp = data->ssp_mode; 1422388fc8faSJohan Hedberg 142370f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1424a3d4e20aSJohan Hedberg if (ie) { 1425388fc8faSJohan Hedberg if (ie->data.ssp_mode && ssp) 1426388fc8faSJohan Hedberg *ssp = true; 1427388fc8faSJohan Hedberg 1428a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1429a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1430a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1431a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1432a3d4e20aSJohan Hedberg } 1433a3d4e20aSJohan Hedberg 1434561aafbcSJohan Hedberg goto update; 1435a3d4e20aSJohan Hedberg } 1436561aafbcSJohan Hedberg 14371da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 143870f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 143970f23020SAndrei Emeltchenko if (!ie) 14403175405bSJohan Hedberg return false; 144170f23020SAndrei Emeltchenko 1442561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1443561aafbcSJohan Hedberg 1444561aafbcSJohan Hedberg if (name_known) { 1445561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1446561aafbcSJohan Hedberg } else { 1447561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1448561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1449561aafbcSJohan Hedberg } 1450561aafbcSJohan Hedberg 1451561aafbcSJohan Hedberg update: 1452561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1453561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1454561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1455561aafbcSJohan Hedberg list_del(&ie->list); 14561da177e4SLinus Torvalds } 14571da177e4SLinus Torvalds 145870f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 145970f23020SAndrei Emeltchenko ie->timestamp = jiffies; 14601da177e4SLinus Torvalds cache->timestamp = jiffies; 14613175405bSJohan Hedberg 14623175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 14633175405bSJohan Hedberg return false; 14643175405bSJohan Hedberg 14653175405bSJohan Hedberg return true; 14661da177e4SLinus Torvalds } 14671da177e4SLinus Torvalds 14681da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 14691da177e4SLinus Torvalds { 147030883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 14711da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 14721da177e4SLinus Torvalds struct inquiry_entry *e; 14731da177e4SLinus Torvalds int copied = 0; 14741da177e4SLinus Torvalds 1475561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 14761da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1477b57c1a56SJohan Hedberg 1478b57c1a56SJohan Hedberg if (copied >= num) 1479b57c1a56SJohan Hedberg break; 1480b57c1a56SJohan Hedberg 14811da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 14821da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 14831da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 14841da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 14851da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 14861da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1487b57c1a56SJohan Hedberg 14881da177e4SLinus Torvalds info++; 1489b57c1a56SJohan Hedberg copied++; 14901da177e4SLinus Torvalds } 14911da177e4SLinus Torvalds 14921da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 14931da177e4SLinus Torvalds return copied; 14941da177e4SLinus Torvalds } 14951da177e4SLinus Torvalds 149642c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 14971da177e4SLinus Torvalds { 14981da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 149942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 15001da177e4SLinus Torvalds struct hci_cp_inquiry cp; 15011da177e4SLinus Torvalds 15021da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 15031da177e4SLinus Torvalds 15041da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 15051da177e4SLinus Torvalds return; 15061da177e4SLinus Torvalds 15071da177e4SLinus Torvalds /* Start Inquiry */ 15081da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 15091da177e4SLinus Torvalds cp.length = ir->length; 15101da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 151142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 15121da177e4SLinus Torvalds } 15131da177e4SLinus Torvalds 15143e13fa1eSAndre Guedes static int wait_inquiry(void *word) 15153e13fa1eSAndre Guedes { 15163e13fa1eSAndre Guedes schedule(); 15173e13fa1eSAndre Guedes return signal_pending(current); 15183e13fa1eSAndre Guedes } 15193e13fa1eSAndre Guedes 15201da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 15211da177e4SLinus Torvalds { 15221da177e4SLinus Torvalds __u8 __user *ptr = arg; 15231da177e4SLinus Torvalds struct hci_inquiry_req ir; 15241da177e4SLinus Torvalds struct hci_dev *hdev; 15251da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 15261da177e4SLinus Torvalds long timeo; 15271da177e4SLinus Torvalds __u8 *buf; 15281da177e4SLinus Torvalds 15291da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 15301da177e4SLinus Torvalds return -EFAULT; 15311da177e4SLinus Torvalds 15325a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 15335a08ecceSAndrei Emeltchenko if (!hdev) 15341da177e4SLinus Torvalds return -ENODEV; 15351da177e4SLinus Torvalds 15360736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 15370736cfa8SMarcel Holtmann err = -EBUSY; 15380736cfa8SMarcel Holtmann goto done; 15390736cfa8SMarcel Holtmann } 15400736cfa8SMarcel Holtmann 15415b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 15425b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 15435b69bef5SMarcel Holtmann goto done; 15445b69bef5SMarcel Holtmann } 15455b69bef5SMarcel Holtmann 154656f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 154756f87901SJohan Hedberg err = -EOPNOTSUPP; 154856f87901SJohan Hedberg goto done; 154956f87901SJohan Hedberg } 155056f87901SJohan Hedberg 155109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 15521da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1553a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 15541f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 15551da177e4SLinus Torvalds do_inquiry = 1; 15561da177e4SLinus Torvalds } 155709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 15581da177e4SLinus Torvalds 155904837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 156070f23020SAndrei Emeltchenko 156170f23020SAndrei Emeltchenko if (do_inquiry) { 156201178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 156301178cd4SJohan Hedberg timeo); 156470f23020SAndrei Emeltchenko if (err < 0) 15651da177e4SLinus Torvalds goto done; 15663e13fa1eSAndre Guedes 15673e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 15683e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 15693e13fa1eSAndre Guedes */ 15703e13fa1eSAndre Guedes if (wait_on_bit(&hdev->flags, HCI_INQUIRY, wait_inquiry, 15713e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 15723e13fa1eSAndre Guedes return -EINTR; 157370f23020SAndrei Emeltchenko } 15741da177e4SLinus Torvalds 15758fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 15768fc9ced3SGustavo Padovan * 255 entries 15778fc9ced3SGustavo Padovan */ 15781da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 15791da177e4SLinus Torvalds 15801da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 15811da177e4SLinus Torvalds * copy it to the user space. 15821da177e4SLinus Torvalds */ 158370f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 158470f23020SAndrei Emeltchenko if (!buf) { 15851da177e4SLinus Torvalds err = -ENOMEM; 15861da177e4SLinus Torvalds goto done; 15871da177e4SLinus Torvalds } 15881da177e4SLinus Torvalds 158909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 15901da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 159109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 15921da177e4SLinus Torvalds 15931da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 15941da177e4SLinus Torvalds 15951da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 15961da177e4SLinus Torvalds ptr += sizeof(ir); 15971da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 15981da177e4SLinus Torvalds ir.num_rsp)) 15991da177e4SLinus Torvalds err = -EFAULT; 16001da177e4SLinus Torvalds } else 16011da177e4SLinus Torvalds err = -EFAULT; 16021da177e4SLinus Torvalds 16031da177e4SLinus Torvalds kfree(buf); 16041da177e4SLinus Torvalds 16051da177e4SLinus Torvalds done: 16061da177e4SLinus Torvalds hci_dev_put(hdev); 16071da177e4SLinus Torvalds return err; 16081da177e4SLinus Torvalds } 16091da177e4SLinus Torvalds 1610cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 16111da177e4SLinus Torvalds { 16121da177e4SLinus Torvalds int ret = 0; 16131da177e4SLinus Torvalds 16141da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 16151da177e4SLinus Torvalds 16161da177e4SLinus Torvalds hci_req_lock(hdev); 16171da177e4SLinus Torvalds 161894324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 161994324962SJohan Hovold ret = -ENODEV; 162094324962SJohan Hovold goto done; 162194324962SJohan Hovold } 162294324962SJohan Hovold 1623a5c8f270SMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) { 1624a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1625a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1626bf543036SJohan Hedberg */ 1627a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 1628611b30f7SMarcel Holtmann ret = -ERFKILL; 1629611b30f7SMarcel Holtmann goto done; 1630611b30f7SMarcel Holtmann } 1631611b30f7SMarcel Holtmann 1632a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1633a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1634a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1635a5c8f270SMarcel Holtmann * or not. 1636a5c8f270SMarcel Holtmann * 1637a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1638a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1639a5c8f270SMarcel Holtmann */ 1640a5c8f270SMarcel Holtmann if (hdev->dev_type == HCI_BREDR && 1641a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1642a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1643a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1644a5c8f270SMarcel Holtmann goto done; 1645a5c8f270SMarcel Holtmann } 1646a5c8f270SMarcel Holtmann } 1647a5c8f270SMarcel Holtmann 16481da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 16491da177e4SLinus Torvalds ret = -EALREADY; 16501da177e4SLinus Torvalds goto done; 16511da177e4SLinus Torvalds } 16521da177e4SLinus Torvalds 16531da177e4SLinus Torvalds if (hdev->open(hdev)) { 16541da177e4SLinus Torvalds ret = -EIO; 16551da177e4SLinus Torvalds goto done; 16561da177e4SLinus Torvalds } 16571da177e4SLinus Torvalds 16581da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 16591da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1660f41c70c4SMarcel Holtmann 1661f41c70c4SMarcel Holtmann if (hdev->setup && test_bit(HCI_SETUP, &hdev->dev_flags)) 1662f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1663f41c70c4SMarcel Holtmann 1664f41c70c4SMarcel Holtmann if (!ret) { 1665f41c70c4SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 1666f41c70c4SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 1667f41c70c4SMarcel Holtmann 16680736cfa8SMarcel Holtmann if (!test_bit(HCI_RAW, &hdev->flags) && 16690736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 16702177bab5SJohan Hedberg ret = __hci_init(hdev); 16711da177e4SLinus Torvalds } 16721da177e4SLinus Torvalds 1673f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1674f41c70c4SMarcel Holtmann 16751da177e4SLinus Torvalds if (!ret) { 16761da177e4SLinus Torvalds hci_dev_hold(hdev); 16771da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 16781da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 1679bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 16800736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 16811514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 168209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1683744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 168409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 168556e5cb86SJohan Hedberg } 16861da177e4SLinus Torvalds } else { 16871da177e4SLinus Torvalds /* Init failed, cleanup */ 16883eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1689c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1690b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 16911da177e4SLinus Torvalds 16921da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16931da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 16941da177e4SLinus Torvalds 16951da177e4SLinus Torvalds if (hdev->flush) 16961da177e4SLinus Torvalds hdev->flush(hdev); 16971da177e4SLinus Torvalds 16981da177e4SLinus Torvalds if (hdev->sent_cmd) { 16991da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 17001da177e4SLinus Torvalds hdev->sent_cmd = NULL; 17011da177e4SLinus Torvalds } 17021da177e4SLinus Torvalds 17031da177e4SLinus Torvalds hdev->close(hdev); 17041da177e4SLinus Torvalds hdev->flags = 0; 17051da177e4SLinus Torvalds } 17061da177e4SLinus Torvalds 17071da177e4SLinus Torvalds done: 17081da177e4SLinus Torvalds hci_req_unlock(hdev); 17091da177e4SLinus Torvalds return ret; 17101da177e4SLinus Torvalds } 17111da177e4SLinus Torvalds 1712cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1713cbed0ca1SJohan Hedberg 1714cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1715cbed0ca1SJohan Hedberg { 1716cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1717cbed0ca1SJohan Hedberg int err; 1718cbed0ca1SJohan Hedberg 1719cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1720cbed0ca1SJohan Hedberg if (!hdev) 1721cbed0ca1SJohan Hedberg return -ENODEV; 1722cbed0ca1SJohan Hedberg 1723e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1724e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1725e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1726e1d08f40SJohan Hedberg * completed. 1727e1d08f40SJohan Hedberg */ 1728e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 1729e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1730e1d08f40SJohan Hedberg 1731a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1732a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1733a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1734a5c8f270SMarcel Holtmann */ 1735e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1736e1d08f40SJohan Hedberg 1737cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1738cbed0ca1SJohan Hedberg 1739cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1740cbed0ca1SJohan Hedberg 1741cbed0ca1SJohan Hedberg return err; 1742cbed0ca1SJohan Hedberg } 1743cbed0ca1SJohan Hedberg 17441da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 17451da177e4SLinus Torvalds { 17461da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 17471da177e4SLinus Torvalds 174878c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 174978c04c0bSVinicius Costa Gomes 17501da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 17511da177e4SLinus Torvalds hci_req_lock(hdev); 17521da177e4SLinus Torvalds 17531da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 1754b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 17551da177e4SLinus Torvalds hci_req_unlock(hdev); 17561da177e4SLinus Torvalds return 0; 17571da177e4SLinus Torvalds } 17581da177e4SLinus Torvalds 17593eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 17603eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1761b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 17621da177e4SLinus Torvalds 176316ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 1764e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 176516ab91abSJohan Hedberg hdev->discov_timeout = 0; 17665e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 1767310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 176816ab91abSJohan Hedberg } 176916ab91abSJohan Hedberg 1770a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 17717d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 17727d78525dSJohan Hedberg 17737ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 17747ba8b4beSAndre Guedes 177509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17761f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 17771da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 177809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17791da177e4SLinus Torvalds 17801da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 17811da177e4SLinus Torvalds 17821da177e4SLinus Torvalds if (hdev->flush) 17831da177e4SLinus Torvalds hdev->flush(hdev); 17841da177e4SLinus Torvalds 17851da177e4SLinus Torvalds /* Reset device */ 17861da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17871da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 17888af59467SJohan Hedberg if (!test_bit(HCI_RAW, &hdev->flags) && 17893a6afbd2SMarcel Holtmann !test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 1790a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 17911da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 179201178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 17931da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 17941da177e4SLinus Torvalds } 17951da177e4SLinus Torvalds 1796c347b765SGustavo F. Padovan /* flush cmd work */ 1797c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 17981da177e4SLinus Torvalds 17991da177e4SLinus Torvalds /* Drop queues */ 18001da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 18011da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 18021da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 18031da177e4SLinus Torvalds 18041da177e4SLinus Torvalds /* Drop last sent command */ 18051da177e4SLinus Torvalds if (hdev->sent_cmd) { 1806b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 18071da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 18081da177e4SLinus Torvalds hdev->sent_cmd = NULL; 18091da177e4SLinus Torvalds } 18101da177e4SLinus Torvalds 1811b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 1812b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 1813b6ddb638SJohan Hedberg 18141da177e4SLinus Torvalds /* After this point our queues are empty 18151da177e4SLinus Torvalds * and no tasks are scheduled. */ 18161da177e4SLinus Torvalds hdev->close(hdev); 18171da177e4SLinus Torvalds 181835b973c9SJohan Hedberg /* Clear flags */ 181935b973c9SJohan Hedberg hdev->flags = 0; 182035b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 182135b973c9SJohan Hedberg 182293c311a0SMarcel Holtmann if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 182393c311a0SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 182409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1825744cf19eSJohan Hedberg mgmt_powered(hdev, 0); 182609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 18278ee56540SMarcel Holtmann } 182893c311a0SMarcel Holtmann } 18295add6af8SJohan Hedberg 1830ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1831536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1832ced5c338SAndrei Emeltchenko 1833e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 183409b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 1835e59fda8dSJohan Hedberg 18361da177e4SLinus Torvalds hci_req_unlock(hdev); 18371da177e4SLinus Torvalds 18381da177e4SLinus Torvalds hci_dev_put(hdev); 18391da177e4SLinus Torvalds return 0; 18401da177e4SLinus Torvalds } 18411da177e4SLinus Torvalds 18421da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 18431da177e4SLinus Torvalds { 18441da177e4SLinus Torvalds struct hci_dev *hdev; 18451da177e4SLinus Torvalds int err; 18461da177e4SLinus Torvalds 184770f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 184870f23020SAndrei Emeltchenko if (!hdev) 18491da177e4SLinus Torvalds return -ENODEV; 18508ee56540SMarcel Holtmann 18510736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 18520736cfa8SMarcel Holtmann err = -EBUSY; 18530736cfa8SMarcel Holtmann goto done; 18540736cfa8SMarcel Holtmann } 18550736cfa8SMarcel Holtmann 18568ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 18578ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 18588ee56540SMarcel Holtmann 18591da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 18608ee56540SMarcel Holtmann 18610736cfa8SMarcel Holtmann done: 18621da177e4SLinus Torvalds hci_dev_put(hdev); 18631da177e4SLinus Torvalds return err; 18641da177e4SLinus Torvalds } 18651da177e4SLinus Torvalds 18661da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 18671da177e4SLinus Torvalds { 18681da177e4SLinus Torvalds struct hci_dev *hdev; 18691da177e4SLinus Torvalds int ret = 0; 18701da177e4SLinus Torvalds 187170f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 187270f23020SAndrei Emeltchenko if (!hdev) 18731da177e4SLinus Torvalds return -ENODEV; 18741da177e4SLinus Torvalds 18751da177e4SLinus Torvalds hci_req_lock(hdev); 18761da177e4SLinus Torvalds 1877808a049eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 1878808a049eSMarcel Holtmann ret = -ENETDOWN; 18791da177e4SLinus Torvalds goto done; 1880808a049eSMarcel Holtmann } 18811da177e4SLinus Torvalds 18820736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 18830736cfa8SMarcel Holtmann ret = -EBUSY; 18840736cfa8SMarcel Holtmann goto done; 18850736cfa8SMarcel Holtmann } 18860736cfa8SMarcel Holtmann 18871da177e4SLinus Torvalds /* Drop queues */ 18881da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 18891da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 18901da177e4SLinus Torvalds 189109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 18921f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 18931da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 189409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 18951da177e4SLinus Torvalds 18961da177e4SLinus Torvalds if (hdev->flush) 18971da177e4SLinus Torvalds hdev->flush(hdev); 18981da177e4SLinus Torvalds 18991da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 19006ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 19011da177e4SLinus Torvalds 19021da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 190301178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 19041da177e4SLinus Torvalds 19051da177e4SLinus Torvalds done: 19061da177e4SLinus Torvalds hci_req_unlock(hdev); 19071da177e4SLinus Torvalds hci_dev_put(hdev); 19081da177e4SLinus Torvalds return ret; 19091da177e4SLinus Torvalds } 19101da177e4SLinus Torvalds 19111da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 19121da177e4SLinus Torvalds { 19131da177e4SLinus Torvalds struct hci_dev *hdev; 19141da177e4SLinus Torvalds int ret = 0; 19151da177e4SLinus Torvalds 191670f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 191770f23020SAndrei Emeltchenko if (!hdev) 19181da177e4SLinus Torvalds return -ENODEV; 19191da177e4SLinus Torvalds 19200736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 19210736cfa8SMarcel Holtmann ret = -EBUSY; 19220736cfa8SMarcel Holtmann goto done; 19230736cfa8SMarcel Holtmann } 19240736cfa8SMarcel Holtmann 19251da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 19261da177e4SLinus Torvalds 19270736cfa8SMarcel Holtmann done: 19281da177e4SLinus Torvalds hci_dev_put(hdev); 19291da177e4SLinus Torvalds return ret; 19301da177e4SLinus Torvalds } 19311da177e4SLinus Torvalds 19321da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 19331da177e4SLinus Torvalds { 19341da177e4SLinus Torvalds struct hci_dev *hdev; 19351da177e4SLinus Torvalds struct hci_dev_req dr; 19361da177e4SLinus Torvalds int err = 0; 19371da177e4SLinus Torvalds 19381da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 19391da177e4SLinus Torvalds return -EFAULT; 19401da177e4SLinus Torvalds 194170f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 194270f23020SAndrei Emeltchenko if (!hdev) 19431da177e4SLinus Torvalds return -ENODEV; 19441da177e4SLinus Torvalds 19450736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 19460736cfa8SMarcel Holtmann err = -EBUSY; 19470736cfa8SMarcel Holtmann goto done; 19480736cfa8SMarcel Holtmann } 19490736cfa8SMarcel Holtmann 19505b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 19515b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 19525b69bef5SMarcel Holtmann goto done; 19535b69bef5SMarcel Holtmann } 19545b69bef5SMarcel Holtmann 195556f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 195656f87901SJohan Hedberg err = -EOPNOTSUPP; 195756f87901SJohan Hedberg goto done; 195856f87901SJohan Hedberg } 195956f87901SJohan Hedberg 19601da177e4SLinus Torvalds switch (cmd) { 19611da177e4SLinus Torvalds case HCISETAUTH: 196201178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19635f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19641da177e4SLinus Torvalds break; 19651da177e4SLinus Torvalds 19661da177e4SLinus Torvalds case HCISETENCRYPT: 19671da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 19681da177e4SLinus Torvalds err = -EOPNOTSUPP; 19691da177e4SLinus Torvalds break; 19701da177e4SLinus Torvalds } 19711da177e4SLinus Torvalds 19721da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 19731da177e4SLinus Torvalds /* Auth must be enabled first */ 197401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19755f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19761da177e4SLinus Torvalds if (err) 19771da177e4SLinus Torvalds break; 19781da177e4SLinus Torvalds } 19791da177e4SLinus Torvalds 198001178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 19815f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19821da177e4SLinus Torvalds break; 19831da177e4SLinus Torvalds 19841da177e4SLinus Torvalds case HCISETSCAN: 198501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 19865f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19871da177e4SLinus Torvalds break; 19881da177e4SLinus Torvalds 19891da177e4SLinus Torvalds case HCISETLINKPOL: 199001178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 19915f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19921da177e4SLinus Torvalds break; 19931da177e4SLinus Torvalds 19941da177e4SLinus Torvalds case HCISETLINKMODE: 1995e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 1996e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 1997e4e8e37cSMarcel Holtmann break; 1998e4e8e37cSMarcel Holtmann 1999e4e8e37cSMarcel Holtmann case HCISETPTYPE: 2000e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 20011da177e4SLinus Torvalds break; 20021da177e4SLinus Torvalds 20031da177e4SLinus Torvalds case HCISETACLMTU: 20041da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 20051da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 20061da177e4SLinus Torvalds break; 20071da177e4SLinus Torvalds 20081da177e4SLinus Torvalds case HCISETSCOMTU: 20091da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 20101da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 20111da177e4SLinus Torvalds break; 20121da177e4SLinus Torvalds 20131da177e4SLinus Torvalds default: 20141da177e4SLinus Torvalds err = -EINVAL; 20151da177e4SLinus Torvalds break; 20161da177e4SLinus Torvalds } 2017e4e8e37cSMarcel Holtmann 20180736cfa8SMarcel Holtmann done: 20191da177e4SLinus Torvalds hci_dev_put(hdev); 20201da177e4SLinus Torvalds return err; 20211da177e4SLinus Torvalds } 20221da177e4SLinus Torvalds 20231da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 20241da177e4SLinus Torvalds { 20258035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 20261da177e4SLinus Torvalds struct hci_dev_list_req *dl; 20271da177e4SLinus Torvalds struct hci_dev_req *dr; 20281da177e4SLinus Torvalds int n = 0, size, err; 20291da177e4SLinus Torvalds __u16 dev_num; 20301da177e4SLinus Torvalds 20311da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 20321da177e4SLinus Torvalds return -EFAULT; 20331da177e4SLinus Torvalds 20341da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 20351da177e4SLinus Torvalds return -EINVAL; 20361da177e4SLinus Torvalds 20371da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 20381da177e4SLinus Torvalds 203970f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 204070f23020SAndrei Emeltchenko if (!dl) 20411da177e4SLinus Torvalds return -ENOMEM; 20421da177e4SLinus Torvalds 20431da177e4SLinus Torvalds dr = dl->dev_req; 20441da177e4SLinus Torvalds 2045f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 20468035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 2047a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 2048e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->power_off); 2049c542a06cSJohan Hedberg 2050a8b2d5c2SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 2051a8b2d5c2SJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->dev_flags); 2052c542a06cSJohan Hedberg 20531da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 20541da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 2055c542a06cSJohan Hedberg 20561da177e4SLinus Torvalds if (++n >= dev_num) 20571da177e4SLinus Torvalds break; 20581da177e4SLinus Torvalds } 2059f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 20601da177e4SLinus Torvalds 20611da177e4SLinus Torvalds dl->dev_num = n; 20621da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 20631da177e4SLinus Torvalds 20641da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 20651da177e4SLinus Torvalds kfree(dl); 20661da177e4SLinus Torvalds 20671da177e4SLinus Torvalds return err ? -EFAULT : 0; 20681da177e4SLinus Torvalds } 20691da177e4SLinus Torvalds 20701da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 20711da177e4SLinus Torvalds { 20721da177e4SLinus Torvalds struct hci_dev *hdev; 20731da177e4SLinus Torvalds struct hci_dev_info di; 20741da177e4SLinus Torvalds int err = 0; 20751da177e4SLinus Torvalds 20761da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 20771da177e4SLinus Torvalds return -EFAULT; 20781da177e4SLinus Torvalds 207970f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 208070f23020SAndrei Emeltchenko if (!hdev) 20811da177e4SLinus Torvalds return -ENODEV; 20821da177e4SLinus Torvalds 2083a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 20843243553fSJohan Hedberg cancel_delayed_work_sync(&hdev->power_off); 2085ab81cbf9SJohan Hedberg 2086a8b2d5c2SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 2087a8b2d5c2SJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->dev_flags); 2088c542a06cSJohan Hedberg 20891da177e4SLinus Torvalds strcpy(di.name, hdev->name); 20901da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 209160f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 20921da177e4SLinus Torvalds di.flags = hdev->flags; 20931da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2094572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 20951da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 20961da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 20971da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 20981da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2099572c7f84SJohan Hedberg } else { 2100572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2101572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2102572c7f84SJohan Hedberg di.sco_mtu = 0; 2103572c7f84SJohan Hedberg di.sco_pkts = 0; 2104572c7f84SJohan Hedberg } 21051da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 21061da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 21071da177e4SLinus Torvalds 21081da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 21091da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 21101da177e4SLinus Torvalds 21111da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 21121da177e4SLinus Torvalds err = -EFAULT; 21131da177e4SLinus Torvalds 21141da177e4SLinus Torvalds hci_dev_put(hdev); 21151da177e4SLinus Torvalds 21161da177e4SLinus Torvalds return err; 21171da177e4SLinus Torvalds } 21181da177e4SLinus Torvalds 21191da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 21201da177e4SLinus Torvalds 2121611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2122611b30f7SMarcel Holtmann { 2123611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2124611b30f7SMarcel Holtmann 2125611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2126611b30f7SMarcel Holtmann 21270736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 21280736cfa8SMarcel Holtmann return -EBUSY; 21290736cfa8SMarcel Holtmann 21305e130367SJohan Hedberg if (blocked) { 21315e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 2132bf543036SJohan Hedberg if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 2133611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 21345e130367SJohan Hedberg } else { 21355e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 21365e130367SJohan Hedberg } 2137611b30f7SMarcel Holtmann 2138611b30f7SMarcel Holtmann return 0; 2139611b30f7SMarcel Holtmann } 2140611b30f7SMarcel Holtmann 2141611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2142611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2143611b30f7SMarcel Holtmann }; 2144611b30f7SMarcel Holtmann 2145ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2146ab81cbf9SJohan Hedberg { 2147ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 214896570ffcSJohan Hedberg int err; 2149ab81cbf9SJohan Hedberg 2150ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2151ab81cbf9SJohan Hedberg 2152cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 215396570ffcSJohan Hedberg if (err < 0) { 215496570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 2155ab81cbf9SJohan Hedberg return; 215696570ffcSJohan Hedberg } 2157ab81cbf9SJohan Hedberg 2158a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2159a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2160a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2161a5c8f270SMarcel Holtmann */ 2162a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 2163a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 2164a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2165a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2166bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2167bf543036SJohan Hedberg hci_dev_do_close(hdev); 2168bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 216919202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 217019202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2171bf543036SJohan Hedberg } 2172ab81cbf9SJohan Hedberg 2173a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) 2174744cf19eSJohan Hedberg mgmt_index_added(hdev); 2175ab81cbf9SJohan Hedberg } 2176ab81cbf9SJohan Hedberg 2177ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2178ab81cbf9SJohan Hedberg { 21793243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 21803243553fSJohan Hedberg power_off.work); 2181ab81cbf9SJohan Hedberg 2182ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2183ab81cbf9SJohan Hedberg 21848ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2185ab81cbf9SJohan Hedberg } 2186ab81cbf9SJohan Hedberg 218716ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 218816ab91abSJohan Hedberg { 218916ab91abSJohan Hedberg struct hci_dev *hdev; 219016ab91abSJohan Hedberg 219116ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 219216ab91abSJohan Hedberg 219316ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 219416ab91abSJohan Hedberg 2195d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 219616ab91abSJohan Hedberg } 219716ab91abSJohan Hedberg 21982aeb9a1aSJohan Hedberg int hci_uuids_clear(struct hci_dev *hdev) 21992aeb9a1aSJohan Hedberg { 22004821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 22012aeb9a1aSJohan Hedberg 22024821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 22034821002cSJohan Hedberg list_del(&uuid->list); 22042aeb9a1aSJohan Hedberg kfree(uuid); 22052aeb9a1aSJohan Hedberg } 22062aeb9a1aSJohan Hedberg 22072aeb9a1aSJohan Hedberg return 0; 22082aeb9a1aSJohan Hedberg } 22092aeb9a1aSJohan Hedberg 221055ed8ca1SJohan Hedberg int hci_link_keys_clear(struct hci_dev *hdev) 221155ed8ca1SJohan Hedberg { 221255ed8ca1SJohan Hedberg struct list_head *p, *n; 221355ed8ca1SJohan Hedberg 221455ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 221555ed8ca1SJohan Hedberg struct link_key *key; 221655ed8ca1SJohan Hedberg 221755ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 221855ed8ca1SJohan Hedberg 221955ed8ca1SJohan Hedberg list_del(p); 222055ed8ca1SJohan Hedberg kfree(key); 222155ed8ca1SJohan Hedberg } 222255ed8ca1SJohan Hedberg 222355ed8ca1SJohan Hedberg return 0; 222455ed8ca1SJohan Hedberg } 222555ed8ca1SJohan Hedberg 2226b899efafSVinicius Costa Gomes int hci_smp_ltks_clear(struct hci_dev *hdev) 2227b899efafSVinicius Costa Gomes { 2228b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 2229b899efafSVinicius Costa Gomes 2230b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 2231b899efafSVinicius Costa Gomes list_del(&k->list); 2232b899efafSVinicius Costa Gomes kfree(k); 2233b899efafSVinicius Costa Gomes } 2234b899efafSVinicius Costa Gomes 2235b899efafSVinicius Costa Gomes return 0; 2236b899efafSVinicius Costa Gomes } 2237b899efafSVinicius Costa Gomes 223855ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 223955ed8ca1SJohan Hedberg { 224055ed8ca1SJohan Hedberg struct link_key *k; 224155ed8ca1SJohan Hedberg 22428035ded4SLuiz Augusto von Dentz list_for_each_entry(k, &hdev->link_keys, list) 224355ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 224455ed8ca1SJohan Hedberg return k; 224555ed8ca1SJohan Hedberg 224655ed8ca1SJohan Hedberg return NULL; 224755ed8ca1SJohan Hedberg } 224855ed8ca1SJohan Hedberg 2249745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2250d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2251d25e28abSJohan Hedberg { 2252d25e28abSJohan Hedberg /* Legacy key */ 2253d25e28abSJohan Hedberg if (key_type < 0x03) 2254745c0ce3SVishal Agarwal return true; 2255d25e28abSJohan Hedberg 2256d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2257d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2258745c0ce3SVishal Agarwal return false; 2259d25e28abSJohan Hedberg 2260d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2261d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2262745c0ce3SVishal Agarwal return false; 2263d25e28abSJohan Hedberg 2264d25e28abSJohan Hedberg /* Security mode 3 case */ 2265d25e28abSJohan Hedberg if (!conn) 2266745c0ce3SVishal Agarwal return true; 2267d25e28abSJohan Hedberg 2268d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2269d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2270745c0ce3SVishal Agarwal return true; 2271d25e28abSJohan Hedberg 2272d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2273d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2274745c0ce3SVishal Agarwal return true; 2275d25e28abSJohan Hedberg 2276d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2277d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2278745c0ce3SVishal Agarwal return true; 2279d25e28abSJohan Hedberg 2280d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2281d25e28abSJohan Hedberg * persistently */ 2282745c0ce3SVishal Agarwal return false; 2283d25e28abSJohan Hedberg } 2284d25e28abSJohan Hedberg 2285c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8]) 228675d262c2SVinicius Costa Gomes { 2287c9839a11SVinicius Costa Gomes struct smp_ltk *k; 228875d262c2SVinicius Costa Gomes 2289c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) { 2290c9839a11SVinicius Costa Gomes if (k->ediv != ediv || 2291c9839a11SVinicius Costa Gomes memcmp(rand, k->rand, sizeof(k->rand))) 229275d262c2SVinicius Costa Gomes continue; 229375d262c2SVinicius Costa Gomes 229475d262c2SVinicius Costa Gomes return k; 229575d262c2SVinicius Costa Gomes } 229675d262c2SVinicius Costa Gomes 229775d262c2SVinicius Costa Gomes return NULL; 229875d262c2SVinicius Costa Gomes } 229975d262c2SVinicius Costa Gomes 2300c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2301c9839a11SVinicius Costa Gomes u8 addr_type) 230275d262c2SVinicius Costa Gomes { 2303c9839a11SVinicius Costa Gomes struct smp_ltk *k; 230475d262c2SVinicius Costa Gomes 2305c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) 2306c9839a11SVinicius Costa Gomes if (addr_type == k->bdaddr_type && 2307c9839a11SVinicius Costa Gomes bacmp(bdaddr, &k->bdaddr) == 0) 230875d262c2SVinicius Costa Gomes return k; 230975d262c2SVinicius Costa Gomes 231075d262c2SVinicius Costa Gomes return NULL; 231175d262c2SVinicius Costa Gomes } 231275d262c2SVinicius Costa Gomes 2313d25e28abSJohan Hedberg int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key, 2314d25e28abSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len) 231555ed8ca1SJohan Hedberg { 231655ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2317745c0ce3SVishal Agarwal u8 old_key_type; 2318745c0ce3SVishal Agarwal bool persistent; 231955ed8ca1SJohan Hedberg 232055ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 232155ed8ca1SJohan Hedberg if (old_key) { 232255ed8ca1SJohan Hedberg old_key_type = old_key->type; 232355ed8ca1SJohan Hedberg key = old_key; 232455ed8ca1SJohan Hedberg } else { 232512adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 232655ed8ca1SJohan Hedberg key = kzalloc(sizeof(*key), GFP_ATOMIC); 232755ed8ca1SJohan Hedberg if (!key) 232855ed8ca1SJohan Hedberg return -ENOMEM; 232955ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 233055ed8ca1SJohan Hedberg } 233155ed8ca1SJohan Hedberg 23326ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 233355ed8ca1SJohan Hedberg 2334d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2335d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2336d25e28abSJohan Hedberg * previous key */ 2337d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2338a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2339d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2340655fe6ecSJohan Hedberg if (conn) 2341655fe6ecSJohan Hedberg conn->key_type = type; 2342655fe6ecSJohan Hedberg } 2343d25e28abSJohan Hedberg 234455ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 23459b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 234655ed8ca1SJohan Hedberg key->pin_len = pin_len; 234755ed8ca1SJohan Hedberg 2348b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 234955ed8ca1SJohan Hedberg key->type = old_key_type; 23504748fed2SJohan Hedberg else 23514748fed2SJohan Hedberg key->type = type; 23524748fed2SJohan Hedberg 23534df378a1SJohan Hedberg if (!new_key) 23544df378a1SJohan Hedberg return 0; 23554df378a1SJohan Hedberg 23564df378a1SJohan Hedberg persistent = hci_persistent_key(hdev, conn, type, old_key_type); 23574df378a1SJohan Hedberg 2358744cf19eSJohan Hedberg mgmt_new_link_key(hdev, key, persistent); 23594df378a1SJohan Hedberg 23606ec5bcadSVishal Agarwal if (conn) 23616ec5bcadSVishal Agarwal conn->flush_key = !persistent; 236255ed8ca1SJohan Hedberg 236355ed8ca1SJohan Hedberg return 0; 236455ed8ca1SJohan Hedberg } 236555ed8ca1SJohan Hedberg 2366c9839a11SVinicius Costa Gomes int hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type, u8 type, 23679a006657SAndrei Emeltchenko int new_key, u8 authenticated, u8 tk[16], u8 enc_size, __le16 236804124681SGustavo F. Padovan ediv, u8 rand[8]) 236975d262c2SVinicius Costa Gomes { 2370c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 237175d262c2SVinicius Costa Gomes 2372c9839a11SVinicius Costa Gomes if (!(type & HCI_SMP_STK) && !(type & HCI_SMP_LTK)) 2373c9839a11SVinicius Costa Gomes return 0; 237475d262c2SVinicius Costa Gomes 2375c9839a11SVinicius Costa Gomes old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type); 2376c9839a11SVinicius Costa Gomes if (old_key) 237775d262c2SVinicius Costa Gomes key = old_key; 2378c9839a11SVinicius Costa Gomes else { 2379c9839a11SVinicius Costa Gomes key = kzalloc(sizeof(*key), GFP_ATOMIC); 238075d262c2SVinicius Costa Gomes if (!key) 238175d262c2SVinicius Costa Gomes return -ENOMEM; 2382c9839a11SVinicius Costa Gomes list_add(&key->list, &hdev->long_term_keys); 238375d262c2SVinicius Costa Gomes } 238475d262c2SVinicius Costa Gomes 238575d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2386c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2387c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2388c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2389c9839a11SVinicius Costa Gomes key->ediv = ediv; 2390c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2391c9839a11SVinicius Costa Gomes key->type = type; 2392c9839a11SVinicius Costa Gomes memcpy(key->rand, rand, sizeof(key->rand)); 239375d262c2SVinicius Costa Gomes 2394c9839a11SVinicius Costa Gomes if (!new_key) 2395c9839a11SVinicius Costa Gomes return 0; 239675d262c2SVinicius Costa Gomes 2397261cc5aaSVinicius Costa Gomes if (type & HCI_SMP_LTK) 2398261cc5aaSVinicius Costa Gomes mgmt_new_ltk(hdev, key, 1); 2399261cc5aaSVinicius Costa Gomes 240075d262c2SVinicius Costa Gomes return 0; 240175d262c2SVinicius Costa Gomes } 240275d262c2SVinicius Costa Gomes 240355ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 240455ed8ca1SJohan Hedberg { 240555ed8ca1SJohan Hedberg struct link_key *key; 240655ed8ca1SJohan Hedberg 240755ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 240855ed8ca1SJohan Hedberg if (!key) 240955ed8ca1SJohan Hedberg return -ENOENT; 241055ed8ca1SJohan Hedberg 24116ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 241255ed8ca1SJohan Hedberg 241355ed8ca1SJohan Hedberg list_del(&key->list); 241455ed8ca1SJohan Hedberg kfree(key); 241555ed8ca1SJohan Hedberg 241655ed8ca1SJohan Hedberg return 0; 241755ed8ca1SJohan Hedberg } 241855ed8ca1SJohan Hedberg 2419b899efafSVinicius Costa Gomes int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr) 2420b899efafSVinicius Costa Gomes { 2421b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 2422b899efafSVinicius Costa Gomes 2423b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 2424b899efafSVinicius Costa Gomes if (bacmp(bdaddr, &k->bdaddr)) 2425b899efafSVinicius Costa Gomes continue; 2426b899efafSVinicius Costa Gomes 24276ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2428b899efafSVinicius Costa Gomes 2429b899efafSVinicius Costa Gomes list_del(&k->list); 2430b899efafSVinicius Costa Gomes kfree(k); 2431b899efafSVinicius Costa Gomes } 2432b899efafSVinicius Costa Gomes 2433b899efafSVinicius Costa Gomes return 0; 2434b899efafSVinicius Costa Gomes } 2435b899efafSVinicius Costa Gomes 24366bd32326SVille Tervo /* HCI command timer function */ 2437bda4f23aSAndrei Emeltchenko static void hci_cmd_timeout(unsigned long arg) 24386bd32326SVille Tervo { 24396bd32326SVille Tervo struct hci_dev *hdev = (void *) arg; 24406bd32326SVille Tervo 2441bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2442bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2443bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2444bda4f23aSAndrei Emeltchenko 2445bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 2446bda4f23aSAndrei Emeltchenko } else { 24476bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 2448bda4f23aSAndrei Emeltchenko } 2449bda4f23aSAndrei Emeltchenko 24506bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2451c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 24526bd32326SVille Tervo } 24536bd32326SVille Tervo 24542763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 24552763eda6SSzymon Janc bdaddr_t *bdaddr) 24562763eda6SSzymon Janc { 24572763eda6SSzymon Janc struct oob_data *data; 24582763eda6SSzymon Janc 24592763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 24602763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 24612763eda6SSzymon Janc return data; 24622763eda6SSzymon Janc 24632763eda6SSzymon Janc return NULL; 24642763eda6SSzymon Janc } 24652763eda6SSzymon Janc 24662763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 24672763eda6SSzymon Janc { 24682763eda6SSzymon Janc struct oob_data *data; 24692763eda6SSzymon Janc 24702763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 24712763eda6SSzymon Janc if (!data) 24722763eda6SSzymon Janc return -ENOENT; 24732763eda6SSzymon Janc 24746ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 24752763eda6SSzymon Janc 24762763eda6SSzymon Janc list_del(&data->list); 24772763eda6SSzymon Janc kfree(data); 24782763eda6SSzymon Janc 24792763eda6SSzymon Janc return 0; 24802763eda6SSzymon Janc } 24812763eda6SSzymon Janc 24822763eda6SSzymon Janc int hci_remote_oob_data_clear(struct hci_dev *hdev) 24832763eda6SSzymon Janc { 24842763eda6SSzymon Janc struct oob_data *data, *n; 24852763eda6SSzymon Janc 24862763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 24872763eda6SSzymon Janc list_del(&data->list); 24882763eda6SSzymon Janc kfree(data); 24892763eda6SSzymon Janc } 24902763eda6SSzymon Janc 24912763eda6SSzymon Janc return 0; 24922763eda6SSzymon Janc } 24932763eda6SSzymon Janc 24942763eda6SSzymon Janc int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash, 24952763eda6SSzymon Janc u8 *randomizer) 24962763eda6SSzymon Janc { 24972763eda6SSzymon Janc struct oob_data *data; 24982763eda6SSzymon Janc 24992763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 25002763eda6SSzymon Janc 25012763eda6SSzymon Janc if (!data) { 25022763eda6SSzymon Janc data = kmalloc(sizeof(*data), GFP_ATOMIC); 25032763eda6SSzymon Janc if (!data) 25042763eda6SSzymon Janc return -ENOMEM; 25052763eda6SSzymon Janc 25062763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 25072763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 25082763eda6SSzymon Janc } 25092763eda6SSzymon Janc 25102763eda6SSzymon Janc memcpy(data->hash, hash, sizeof(data->hash)); 25112763eda6SSzymon Janc memcpy(data->randomizer, randomizer, sizeof(data->randomizer)); 25122763eda6SSzymon Janc 25136ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 25142763eda6SSzymon Janc 25152763eda6SSzymon Janc return 0; 25162763eda6SSzymon Janc } 25172763eda6SSzymon Janc 2518b9ee0a78SMarcel Holtmann struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev, 2519b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2520b2a66aadSAntti Julku { 2521b2a66aadSAntti Julku struct bdaddr_list *b; 2522b2a66aadSAntti Julku 2523b9ee0a78SMarcel Holtmann list_for_each_entry(b, &hdev->blacklist, list) { 2524b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2525b2a66aadSAntti Julku return b; 2526b9ee0a78SMarcel Holtmann } 2527b2a66aadSAntti Julku 2528b2a66aadSAntti Julku return NULL; 2529b2a66aadSAntti Julku } 2530b2a66aadSAntti Julku 2531b2a66aadSAntti Julku int hci_blacklist_clear(struct hci_dev *hdev) 2532b2a66aadSAntti Julku { 2533b2a66aadSAntti Julku struct list_head *p, *n; 2534b2a66aadSAntti Julku 2535b2a66aadSAntti Julku list_for_each_safe(p, n, &hdev->blacklist) { 2536b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 2537b2a66aadSAntti Julku 2538b2a66aadSAntti Julku list_del(p); 2539b2a66aadSAntti Julku kfree(b); 2540b2a66aadSAntti Julku } 2541b2a66aadSAntti Julku 2542b2a66aadSAntti Julku return 0; 2543b2a66aadSAntti Julku } 2544b2a66aadSAntti Julku 254588c1fe4bSJohan Hedberg int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 2546b2a66aadSAntti Julku { 2547b2a66aadSAntti Julku struct bdaddr_list *entry; 2548b2a66aadSAntti Julku 2549b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2550b2a66aadSAntti Julku return -EBADF; 2551b2a66aadSAntti Julku 2552b9ee0a78SMarcel Holtmann if (hci_blacklist_lookup(hdev, bdaddr, type)) 25535e762444SAntti Julku return -EEXIST; 2554b2a66aadSAntti Julku 2555b2a66aadSAntti Julku entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL); 25565e762444SAntti Julku if (!entry) 25575e762444SAntti Julku return -ENOMEM; 2558b2a66aadSAntti Julku 2559b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2560b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2561b2a66aadSAntti Julku 2562b2a66aadSAntti Julku list_add(&entry->list, &hdev->blacklist); 2563b2a66aadSAntti Julku 256488c1fe4bSJohan Hedberg return mgmt_device_blocked(hdev, bdaddr, type); 2565b2a66aadSAntti Julku } 2566b2a66aadSAntti Julku 256788c1fe4bSJohan Hedberg int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 2568b2a66aadSAntti Julku { 2569b2a66aadSAntti Julku struct bdaddr_list *entry; 2570b2a66aadSAntti Julku 2571b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 25725e762444SAntti Julku return hci_blacklist_clear(hdev); 2573b2a66aadSAntti Julku 2574b9ee0a78SMarcel Holtmann entry = hci_blacklist_lookup(hdev, bdaddr, type); 25751ec918ceSSzymon Janc if (!entry) 25765e762444SAntti Julku return -ENOENT; 2577b2a66aadSAntti Julku 2578b2a66aadSAntti Julku list_del(&entry->list); 2579b2a66aadSAntti Julku kfree(entry); 2580b2a66aadSAntti Julku 258188c1fe4bSJohan Hedberg return mgmt_device_unblocked(hdev, bdaddr, type); 2582b2a66aadSAntti Julku } 2583b2a66aadSAntti Julku 25844c87eaabSAndre Guedes static void inquiry_complete(struct hci_dev *hdev, u8 status) 25857ba8b4beSAndre Guedes { 25864c87eaabSAndre Guedes if (status) { 25874c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 25887ba8b4beSAndre Guedes 25894c87eaabSAndre Guedes hci_dev_lock(hdev); 25904c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 25914c87eaabSAndre Guedes hci_dev_unlock(hdev); 25924c87eaabSAndre Guedes return; 25934c87eaabSAndre Guedes } 25947ba8b4beSAndre Guedes } 25957ba8b4beSAndre Guedes 25964c87eaabSAndre Guedes static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status) 25977ba8b4beSAndre Guedes { 25984c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 25994c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 26004c87eaabSAndre Guedes struct hci_request req; 26014c87eaabSAndre Guedes struct hci_cp_inquiry cp; 26027ba8b4beSAndre Guedes int err; 26037ba8b4beSAndre Guedes 26044c87eaabSAndre Guedes if (status) { 26054c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 26064c87eaabSAndre Guedes return; 26077ba8b4beSAndre Guedes } 26087ba8b4beSAndre Guedes 26094c87eaabSAndre Guedes switch (hdev->discovery.type) { 26104c87eaabSAndre Guedes case DISCOV_TYPE_LE: 26114c87eaabSAndre Guedes hci_dev_lock(hdev); 26124c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 26134c87eaabSAndre Guedes hci_dev_unlock(hdev); 26144c87eaabSAndre Guedes break; 26157dbfac1dSAndre Guedes 26164c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 26174c87eaabSAndre Guedes hci_req_init(&req, hdev); 26187dbfac1dSAndre Guedes 26197dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 26204c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 26214c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 26224c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 26234c87eaabSAndre Guedes 26244c87eaabSAndre Guedes hci_dev_lock(hdev); 26254c87eaabSAndre Guedes 26264c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 26274c87eaabSAndre Guedes 26284c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 26294c87eaabSAndre Guedes if (err) { 26304c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 26314c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 26327dbfac1dSAndre Guedes } 26337dbfac1dSAndre Guedes 26344c87eaabSAndre Guedes hci_dev_unlock(hdev); 26354c87eaabSAndre Guedes break; 26364c87eaabSAndre Guedes } 26377dbfac1dSAndre Guedes } 26387dbfac1dSAndre Guedes 26397ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 26407ba8b4beSAndre Guedes { 26417ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 26427ba8b4beSAndre Guedes le_scan_disable.work); 26437ba8b4beSAndre Guedes struct hci_cp_le_set_scan_enable cp; 26444c87eaabSAndre Guedes struct hci_request req; 26454c87eaabSAndre Guedes int err; 26467ba8b4beSAndre Guedes 26477ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 26487ba8b4beSAndre Guedes 26494c87eaabSAndre Guedes hci_req_init(&req, hdev); 26507ba8b4beSAndre Guedes 26517ba8b4beSAndre Guedes memset(&cp, 0, sizeof(cp)); 26524c87eaabSAndre Guedes cp.enable = LE_SCAN_DISABLE; 26534c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 26547ba8b4beSAndre Guedes 26554c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 26564c87eaabSAndre Guedes if (err) 26574c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 265828b75a89SAndre Guedes } 265928b75a89SAndre Guedes 26609be0dab7SDavid Herrmann /* Alloc HCI device */ 26619be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 26629be0dab7SDavid Herrmann { 26639be0dab7SDavid Herrmann struct hci_dev *hdev; 26649be0dab7SDavid Herrmann 26659be0dab7SDavid Herrmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 26669be0dab7SDavid Herrmann if (!hdev) 26679be0dab7SDavid Herrmann return NULL; 26689be0dab7SDavid Herrmann 2669b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 2670b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 2671b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 2672b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 2673b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 2674bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 2675bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 2676b1b813d4SDavid Herrmann 2677b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 2678b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 2679b1b813d4SDavid Herrmann 2680bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 2681bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 2682bef64738SMarcel Holtmann 2683b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 2684b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 2685b1b813d4SDavid Herrmann 2686b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 2687b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 2688b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 2689b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 2690b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 2691b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 26926b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 2693b1b813d4SDavid Herrmann 2694b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 2695b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 2696b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 2697b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 2698b1b813d4SDavid Herrmann 2699b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 2700b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 2701b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 2702b1b813d4SDavid Herrmann 2703b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 2704b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 2705b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 2706b1b813d4SDavid Herrmann 2707b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 2708b1b813d4SDavid Herrmann 2709bda4f23aSAndrei Emeltchenko setup_timer(&hdev->cmd_timer, hci_cmd_timeout, (unsigned long) hdev); 2710b1b813d4SDavid Herrmann 2711b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 2712b1b813d4SDavid Herrmann discovery_init(hdev); 27139be0dab7SDavid Herrmann 27149be0dab7SDavid Herrmann return hdev; 27159be0dab7SDavid Herrmann } 27169be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 27179be0dab7SDavid Herrmann 27189be0dab7SDavid Herrmann /* Free HCI device */ 27199be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 27209be0dab7SDavid Herrmann { 27219be0dab7SDavid Herrmann /* will free via device release */ 27229be0dab7SDavid Herrmann put_device(&hdev->dev); 27239be0dab7SDavid Herrmann } 27249be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 27259be0dab7SDavid Herrmann 27261da177e4SLinus Torvalds /* Register HCI device */ 27271da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 27281da177e4SLinus Torvalds { 2729b1b813d4SDavid Herrmann int id, error; 27301da177e4SLinus Torvalds 2731010666a1SDavid Herrmann if (!hdev->open || !hdev->close) 27321da177e4SLinus Torvalds return -EINVAL; 27331da177e4SLinus Torvalds 273408add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 273508add513SMat Martineau * so the index can be used as the AMP controller ID. 273608add513SMat Martineau */ 27373df92b31SSasha Levin switch (hdev->dev_type) { 27383df92b31SSasha Levin case HCI_BREDR: 27393df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 27401da177e4SLinus Torvalds break; 27413df92b31SSasha Levin case HCI_AMP: 27423df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 27433df92b31SSasha Levin break; 27443df92b31SSasha Levin default: 27453df92b31SSasha Levin return -EINVAL; 27461da177e4SLinus Torvalds } 27471da177e4SLinus Torvalds 27483df92b31SSasha Levin if (id < 0) 27493df92b31SSasha Levin return id; 27503df92b31SSasha Levin 27511da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 27521da177e4SLinus Torvalds hdev->id = id; 27532d8b3a11SAndrei Emeltchenko 27542d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 27552d8b3a11SAndrei Emeltchenko 2756d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 2757d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 275833ca954dSDavid Herrmann if (!hdev->workqueue) { 275933ca954dSDavid Herrmann error = -ENOMEM; 276033ca954dSDavid Herrmann goto err; 276133ca954dSDavid Herrmann } 2762f48fd9c8SMarcel Holtmann 2763d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 2764d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 27656ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 27666ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 27676ead1bbcSJohan Hedberg error = -ENOMEM; 27686ead1bbcSJohan Hedberg goto err; 27696ead1bbcSJohan Hedberg } 27706ead1bbcSJohan Hedberg 27710153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 27720153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 27730153e2ecSMarcel Holtmann 2774bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 2775bdc3e0f1SMarcel Holtmann 2776bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 277733ca954dSDavid Herrmann if (error < 0) 277833ca954dSDavid Herrmann goto err_wqueue; 27791da177e4SLinus Torvalds 2780611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 2781a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 2782a8c5fb1aSGustavo Padovan hdev); 2783611b30f7SMarcel Holtmann if (hdev->rfkill) { 2784611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 2785611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 2786611b30f7SMarcel Holtmann hdev->rfkill = NULL; 2787611b30f7SMarcel Holtmann } 2788611b30f7SMarcel Holtmann } 2789611b30f7SMarcel Holtmann 27905e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 27915e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 27925e130367SJohan Hedberg 2793a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 2794004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2795ce2be9acSAndrei Emeltchenko 279601cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 279756f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 279856f87901SJohan Hedberg * through reading supported features during init. 279956f87901SJohan Hedberg */ 280056f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 280156f87901SJohan Hedberg } 2802ce2be9acSAndrei Emeltchenko 2803fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 2804fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 2805fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 2806fcee3377SGustavo Padovan 28071da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 2808dc946bd8SDavid Herrmann hci_dev_hold(hdev); 28091da177e4SLinus Torvalds 281019202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 2811fbe96d6fSMarcel Holtmann 28121da177e4SLinus Torvalds return id; 2813f48fd9c8SMarcel Holtmann 281433ca954dSDavid Herrmann err_wqueue: 281533ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 28166ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 281733ca954dSDavid Herrmann err: 28183df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 2819f48fd9c8SMarcel Holtmann 282033ca954dSDavid Herrmann return error; 28211da177e4SLinus Torvalds } 28221da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 28231da177e4SLinus Torvalds 28241da177e4SLinus Torvalds /* Unregister HCI device */ 282559735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 28261da177e4SLinus Torvalds { 28273df92b31SSasha Levin int i, id; 2828ef222013SMarcel Holtmann 2829c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 28301da177e4SLinus Torvalds 283194324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 283294324962SJohan Hovold 28333df92b31SSasha Levin id = hdev->id; 28343df92b31SSasha Levin 2835f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 28361da177e4SLinus Torvalds list_del(&hdev->list); 2837f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 28381da177e4SLinus Torvalds 28391da177e4SLinus Torvalds hci_dev_do_close(hdev); 28401da177e4SLinus Torvalds 2841cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 2842ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 2843ef222013SMarcel Holtmann 2844b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 2845b9b5ef18SGustavo Padovan 2846ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 2847a8b2d5c2SJohan Hedberg !test_bit(HCI_SETUP, &hdev->dev_flags)) { 284809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2849744cf19eSJohan Hedberg mgmt_index_removed(hdev); 285009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 285156e5cb86SJohan Hedberg } 2852ab81cbf9SJohan Hedberg 28532e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 28542e58ef3eSJohan Hedberg * pending list */ 28552e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 28562e58ef3eSJohan Hedberg 28571da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 28581da177e4SLinus Torvalds 2859611b30f7SMarcel Holtmann if (hdev->rfkill) { 2860611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 2861611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 2862611b30f7SMarcel Holtmann } 2863611b30f7SMarcel Holtmann 2864bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 2865147e2d59SDave Young 28660153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 28670153e2ecSMarcel Holtmann 2868f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 28696ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 2870f48fd9c8SMarcel Holtmann 287109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2872e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 28732aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 287455ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 2875b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 28762763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 287709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 2878e2e0cacbSJohan Hedberg 2879dc946bd8SDavid Herrmann hci_dev_put(hdev); 28803df92b31SSasha Levin 28813df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 28821da177e4SLinus Torvalds } 28831da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 28841da177e4SLinus Torvalds 28851da177e4SLinus Torvalds /* Suspend HCI device */ 28861da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 28871da177e4SLinus Torvalds { 28881da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 28891da177e4SLinus Torvalds return 0; 28901da177e4SLinus Torvalds } 28911da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 28921da177e4SLinus Torvalds 28931da177e4SLinus Torvalds /* Resume HCI device */ 28941da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 28951da177e4SLinus Torvalds { 28961da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 28971da177e4SLinus Torvalds return 0; 28981da177e4SLinus Torvalds } 28991da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 29001da177e4SLinus Torvalds 290176bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 2902e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 290376bca880SMarcel Holtmann { 290476bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 290576bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 290676bca880SMarcel Holtmann kfree_skb(skb); 290776bca880SMarcel Holtmann return -ENXIO; 290876bca880SMarcel Holtmann } 290976bca880SMarcel Holtmann 2910d82603c6SJorrit Schippers /* Incoming skb */ 291176bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 291276bca880SMarcel Holtmann 291376bca880SMarcel Holtmann /* Time stamp */ 291476bca880SMarcel Holtmann __net_timestamp(skb); 291576bca880SMarcel Holtmann 291676bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 2917b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 2918c78ae283SMarcel Holtmann 291976bca880SMarcel Holtmann return 0; 292076bca880SMarcel Holtmann } 292176bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 292276bca880SMarcel Holtmann 292333e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 29241e429f38SGustavo F. Padovan int count, __u8 index) 292533e882a5SSuraj Sumangala { 292633e882a5SSuraj Sumangala int len = 0; 292733e882a5SSuraj Sumangala int hlen = 0; 292833e882a5SSuraj Sumangala int remain = count; 292933e882a5SSuraj Sumangala struct sk_buff *skb; 293033e882a5SSuraj Sumangala struct bt_skb_cb *scb; 293133e882a5SSuraj Sumangala 293233e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 293333e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 293433e882a5SSuraj Sumangala return -EILSEQ; 293533e882a5SSuraj Sumangala 293633e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 293733e882a5SSuraj Sumangala 293833e882a5SSuraj Sumangala if (!skb) { 293933e882a5SSuraj Sumangala switch (type) { 294033e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 294133e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 294233e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 294333e882a5SSuraj Sumangala break; 294433e882a5SSuraj Sumangala case HCI_EVENT_PKT: 294533e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 294633e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 294733e882a5SSuraj Sumangala break; 294833e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 294933e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 295033e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 295133e882a5SSuraj Sumangala break; 295233e882a5SSuraj Sumangala } 295333e882a5SSuraj Sumangala 29541e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 295533e882a5SSuraj Sumangala if (!skb) 295633e882a5SSuraj Sumangala return -ENOMEM; 295733e882a5SSuraj Sumangala 295833e882a5SSuraj Sumangala scb = (void *) skb->cb; 295933e882a5SSuraj Sumangala scb->expect = hlen; 296033e882a5SSuraj Sumangala scb->pkt_type = type; 296133e882a5SSuraj Sumangala 296233e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 296333e882a5SSuraj Sumangala } 296433e882a5SSuraj Sumangala 296533e882a5SSuraj Sumangala while (count) { 296633e882a5SSuraj Sumangala scb = (void *) skb->cb; 296789bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 296833e882a5SSuraj Sumangala 296933e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 297033e882a5SSuraj Sumangala 297133e882a5SSuraj Sumangala count -= len; 297233e882a5SSuraj Sumangala data += len; 297333e882a5SSuraj Sumangala scb->expect -= len; 297433e882a5SSuraj Sumangala remain = count; 297533e882a5SSuraj Sumangala 297633e882a5SSuraj Sumangala switch (type) { 297733e882a5SSuraj Sumangala case HCI_EVENT_PKT: 297833e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 297933e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 298033e882a5SSuraj Sumangala scb->expect = h->plen; 298133e882a5SSuraj Sumangala 298233e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 298333e882a5SSuraj Sumangala kfree_skb(skb); 298433e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 298533e882a5SSuraj Sumangala return -ENOMEM; 298633e882a5SSuraj Sumangala } 298733e882a5SSuraj Sumangala } 298833e882a5SSuraj Sumangala break; 298933e882a5SSuraj Sumangala 299033e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 299133e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 299233e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 299333e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 299433e882a5SSuraj Sumangala 299533e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 299633e882a5SSuraj Sumangala kfree_skb(skb); 299733e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 299833e882a5SSuraj Sumangala return -ENOMEM; 299933e882a5SSuraj Sumangala } 300033e882a5SSuraj Sumangala } 300133e882a5SSuraj Sumangala break; 300233e882a5SSuraj Sumangala 300333e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 300433e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 300533e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 300633e882a5SSuraj Sumangala scb->expect = h->dlen; 300733e882a5SSuraj Sumangala 300833e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 300933e882a5SSuraj Sumangala kfree_skb(skb); 301033e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 301133e882a5SSuraj Sumangala return -ENOMEM; 301233e882a5SSuraj Sumangala } 301333e882a5SSuraj Sumangala } 301433e882a5SSuraj Sumangala break; 301533e882a5SSuraj Sumangala } 301633e882a5SSuraj Sumangala 301733e882a5SSuraj Sumangala if (scb->expect == 0) { 301833e882a5SSuraj Sumangala /* Complete frame */ 301933e882a5SSuraj Sumangala 302033e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 3021e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 302233e882a5SSuraj Sumangala 302333e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 302433e882a5SSuraj Sumangala return remain; 302533e882a5SSuraj Sumangala } 302633e882a5SSuraj Sumangala } 302733e882a5SSuraj Sumangala 302833e882a5SSuraj Sumangala return remain; 302933e882a5SSuraj Sumangala } 303033e882a5SSuraj Sumangala 3031ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 3032ef222013SMarcel Holtmann { 3033f39a3c06SSuraj Sumangala int rem = 0; 3034f39a3c06SSuraj Sumangala 3035ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 3036ef222013SMarcel Holtmann return -EILSEQ; 3037ef222013SMarcel Holtmann 3038da5f6c37SGustavo F. Padovan while (count) { 30391e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, type - 1); 3040f39a3c06SSuraj Sumangala if (rem < 0) 3041f39a3c06SSuraj Sumangala return rem; 3042ef222013SMarcel Holtmann 3043f39a3c06SSuraj Sumangala data += (count - rem); 3044f39a3c06SSuraj Sumangala count = rem; 3045f81c6224SJoe Perches } 3046ef222013SMarcel Holtmann 3047f39a3c06SSuraj Sumangala return rem; 3048ef222013SMarcel Holtmann } 3049ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 3050ef222013SMarcel Holtmann 305199811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 305299811510SSuraj Sumangala 305399811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 305499811510SSuraj Sumangala { 305599811510SSuraj Sumangala int type; 305699811510SSuraj Sumangala int rem = 0; 305799811510SSuraj Sumangala 3058da5f6c37SGustavo F. Padovan while (count) { 305999811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 306099811510SSuraj Sumangala 306199811510SSuraj Sumangala if (!skb) { 306299811510SSuraj Sumangala struct { char type; } *pkt; 306399811510SSuraj Sumangala 306499811510SSuraj Sumangala /* Start of the frame */ 306599811510SSuraj Sumangala pkt = data; 306699811510SSuraj Sumangala type = pkt->type; 306799811510SSuraj Sumangala 306899811510SSuraj Sumangala data++; 306999811510SSuraj Sumangala count--; 307099811510SSuraj Sumangala } else 307199811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 307299811510SSuraj Sumangala 30731e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 30741e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 307599811510SSuraj Sumangala if (rem < 0) 307699811510SSuraj Sumangala return rem; 307799811510SSuraj Sumangala 307899811510SSuraj Sumangala data += (count - rem); 307999811510SSuraj Sumangala count = rem; 3080f81c6224SJoe Perches } 308199811510SSuraj Sumangala 308299811510SSuraj Sumangala return rem; 308399811510SSuraj Sumangala } 308499811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 308599811510SSuraj Sumangala 30861da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 30871da177e4SLinus Torvalds 30881da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 30891da177e4SLinus Torvalds { 30901da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 30911da177e4SLinus Torvalds 3092f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 30931da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 3094f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 30951da177e4SLinus Torvalds 30961da177e4SLinus Torvalds return 0; 30971da177e4SLinus Torvalds } 30981da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 30991da177e4SLinus Torvalds 31001da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 31011da177e4SLinus Torvalds { 31021da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 31031da177e4SLinus Torvalds 3104f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 31051da177e4SLinus Torvalds list_del(&cb->list); 3106f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 31071da177e4SLinus Torvalds 31081da177e4SLinus Torvalds return 0; 31091da177e4SLinus Torvalds } 31101da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 31111da177e4SLinus Torvalds 311251086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 31131da177e4SLinus Torvalds { 31140d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 31151da177e4SLinus Torvalds 31161da177e4SLinus Torvalds /* Time stamp */ 3117a61bbcf2SPatrick McHardy __net_timestamp(skb); 31181da177e4SLinus Torvalds 3119cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3120cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3121cd82e61cSMarcel Holtmann 3122cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3123cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3124470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 31251da177e4SLinus Torvalds } 31261da177e4SLinus Torvalds 31271da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 31281da177e4SLinus Torvalds skb_orphan(skb); 31291da177e4SLinus Torvalds 31307bd8f09fSMarcel Holtmann if (hdev->send(hdev, skb) < 0) 313151086991SMarcel Holtmann BT_ERR("%s sending frame failed", hdev->name); 31321da177e4SLinus Torvalds } 31331da177e4SLinus Torvalds 31343119ae95SJohan Hedberg void hci_req_init(struct hci_request *req, struct hci_dev *hdev) 31353119ae95SJohan Hedberg { 31363119ae95SJohan Hedberg skb_queue_head_init(&req->cmd_q); 31373119ae95SJohan Hedberg req->hdev = hdev; 31385d73e034SAndre Guedes req->err = 0; 31393119ae95SJohan Hedberg } 31403119ae95SJohan Hedberg 31413119ae95SJohan Hedberg int hci_req_run(struct hci_request *req, hci_req_complete_t complete) 31423119ae95SJohan Hedberg { 31433119ae95SJohan Hedberg struct hci_dev *hdev = req->hdev; 31443119ae95SJohan Hedberg struct sk_buff *skb; 31453119ae95SJohan Hedberg unsigned long flags; 31463119ae95SJohan Hedberg 31473119ae95SJohan Hedberg BT_DBG("length %u", skb_queue_len(&req->cmd_q)); 31483119ae95SJohan Hedberg 31495d73e034SAndre Guedes /* If an error occured during request building, remove all HCI 31505d73e034SAndre Guedes * commands queued on the HCI request queue. 31515d73e034SAndre Guedes */ 31525d73e034SAndre Guedes if (req->err) { 31535d73e034SAndre Guedes skb_queue_purge(&req->cmd_q); 31545d73e034SAndre Guedes return req->err; 31555d73e034SAndre Guedes } 31565d73e034SAndre Guedes 31573119ae95SJohan Hedberg /* Do not allow empty requests */ 31583119ae95SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 3159382b0c39SAndre Guedes return -ENODATA; 31603119ae95SJohan Hedberg 31613119ae95SJohan Hedberg skb = skb_peek_tail(&req->cmd_q); 31623119ae95SJohan Hedberg bt_cb(skb)->req.complete = complete; 31633119ae95SJohan Hedberg 31643119ae95SJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 31653119ae95SJohan Hedberg skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q); 31663119ae95SJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 31673119ae95SJohan Hedberg 31683119ae95SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 31693119ae95SJohan Hedberg 31703119ae95SJohan Hedberg return 0; 31713119ae95SJohan Hedberg } 31723119ae95SJohan Hedberg 31731ca3a9d0SJohan Hedberg static struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, 317407dc93ddSJohan Hedberg u32 plen, const void *param) 31751da177e4SLinus Torvalds { 31761da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 31771da177e4SLinus Torvalds struct hci_command_hdr *hdr; 31781da177e4SLinus Torvalds struct sk_buff *skb; 31791da177e4SLinus Torvalds 31801da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 31811ca3a9d0SJohan Hedberg if (!skb) 31821ca3a9d0SJohan Hedberg return NULL; 31831da177e4SLinus Torvalds 31841da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 3185a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 31861da177e4SLinus Torvalds hdr->plen = plen; 31871da177e4SLinus Torvalds 31881da177e4SLinus Torvalds if (plen) 31891da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 31901da177e4SLinus Torvalds 31911da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 31921da177e4SLinus Torvalds 31930d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 3194c78ae283SMarcel Holtmann 31951ca3a9d0SJohan Hedberg return skb; 31961ca3a9d0SJohan Hedberg } 31971ca3a9d0SJohan Hedberg 31981ca3a9d0SJohan Hedberg /* Send HCI command */ 319907dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 320007dc93ddSJohan Hedberg const void *param) 32011ca3a9d0SJohan Hedberg { 32021ca3a9d0SJohan Hedberg struct sk_buff *skb; 32031ca3a9d0SJohan Hedberg 32041ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 32051ca3a9d0SJohan Hedberg 32061ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 32071ca3a9d0SJohan Hedberg if (!skb) { 32081ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 32091ca3a9d0SJohan Hedberg return -ENOMEM; 32101ca3a9d0SJohan Hedberg } 32111ca3a9d0SJohan Hedberg 321211714b3dSJohan Hedberg /* Stand-alone HCI commands must be flaged as 321311714b3dSJohan Hedberg * single-command requests. 321411714b3dSJohan Hedberg */ 321511714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 321611714b3dSJohan Hedberg 32171da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3218c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 32191da177e4SLinus Torvalds 32201da177e4SLinus Torvalds return 0; 32211da177e4SLinus Torvalds } 32221da177e4SLinus Torvalds 322371c76a17SJohan Hedberg /* Queue a command to an asynchronous HCI request */ 322407dc93ddSJohan Hedberg void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen, 322507dc93ddSJohan Hedberg const void *param, u8 event) 322671c76a17SJohan Hedberg { 322771c76a17SJohan Hedberg struct hci_dev *hdev = req->hdev; 322871c76a17SJohan Hedberg struct sk_buff *skb; 322971c76a17SJohan Hedberg 323071c76a17SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 323171c76a17SJohan Hedberg 323234739c1eSAndre Guedes /* If an error occured during request building, there is no point in 323334739c1eSAndre Guedes * queueing the HCI command. We can simply return. 323434739c1eSAndre Guedes */ 323534739c1eSAndre Guedes if (req->err) 323634739c1eSAndre Guedes return; 323734739c1eSAndre Guedes 323871c76a17SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 323971c76a17SJohan Hedberg if (!skb) { 32405d73e034SAndre Guedes BT_ERR("%s no memory for command (opcode 0x%4.4x)", 32415d73e034SAndre Guedes hdev->name, opcode); 32425d73e034SAndre Guedes req->err = -ENOMEM; 3243e348fe6bSAndre Guedes return; 324471c76a17SJohan Hedberg } 324571c76a17SJohan Hedberg 324671c76a17SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 324771c76a17SJohan Hedberg bt_cb(skb)->req.start = true; 324871c76a17SJohan Hedberg 324902350a72SJohan Hedberg bt_cb(skb)->req.event = event; 325002350a72SJohan Hedberg 325171c76a17SJohan Hedberg skb_queue_tail(&req->cmd_q, skb); 325271c76a17SJohan Hedberg } 325371c76a17SJohan Hedberg 325407dc93ddSJohan Hedberg void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, 325507dc93ddSJohan Hedberg const void *param) 325602350a72SJohan Hedberg { 325702350a72SJohan Hedberg hci_req_add_ev(req, opcode, plen, param, 0); 325802350a72SJohan Hedberg } 325902350a72SJohan Hedberg 32601da177e4SLinus Torvalds /* Get data from the previously sent command */ 3261a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 32621da177e4SLinus Torvalds { 32631da177e4SLinus Torvalds struct hci_command_hdr *hdr; 32641da177e4SLinus Torvalds 32651da177e4SLinus Torvalds if (!hdev->sent_cmd) 32661da177e4SLinus Torvalds return NULL; 32671da177e4SLinus Torvalds 32681da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 32691da177e4SLinus Torvalds 3270a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 32711da177e4SLinus Torvalds return NULL; 32721da177e4SLinus Torvalds 3273f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 32741da177e4SLinus Torvalds 32751da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 32761da177e4SLinus Torvalds } 32771da177e4SLinus Torvalds 32781da177e4SLinus Torvalds /* Send ACL data */ 32791da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 32801da177e4SLinus Torvalds { 32811da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 32821da177e4SLinus Torvalds int len = skb->len; 32831da177e4SLinus Torvalds 3284badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3285badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 32869c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3287aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3288aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 32891da177e4SLinus Torvalds } 32901da177e4SLinus Torvalds 3291ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 329273d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 32931da177e4SLinus Torvalds { 3294ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 32951da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 32961da177e4SLinus Torvalds struct sk_buff *list; 32971da177e4SLinus Torvalds 3298087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3299087bfd99SGustavo Padovan skb->data_len = 0; 3300087bfd99SGustavo Padovan 3301087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3302204a6e54SAndrei Emeltchenko 3303204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3304204a6e54SAndrei Emeltchenko case HCI_BREDR: 3305087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3306204a6e54SAndrei Emeltchenko break; 3307204a6e54SAndrei Emeltchenko case HCI_AMP: 3308204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3309204a6e54SAndrei Emeltchenko break; 3310204a6e54SAndrei Emeltchenko default: 3311204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 3312204a6e54SAndrei Emeltchenko return; 3313204a6e54SAndrei Emeltchenko } 3314087bfd99SGustavo Padovan 331570f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 331670f23020SAndrei Emeltchenko if (!list) { 33171da177e4SLinus Torvalds /* Non fragmented */ 33181da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 33191da177e4SLinus Torvalds 332073d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 33211da177e4SLinus Torvalds } else { 33221da177e4SLinus Torvalds /* Fragmented */ 33231da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 33241da177e4SLinus Torvalds 33251da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 33261da177e4SLinus Torvalds 33271da177e4SLinus Torvalds /* Queue all fragments atomically */ 3328af3e6359SGustavo F. Padovan spin_lock(&queue->lock); 33291da177e4SLinus Torvalds 333073d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3331e702112fSAndrei Emeltchenko 3332e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3333e702112fSAndrei Emeltchenko flags |= ACL_CONT; 33341da177e4SLinus Torvalds do { 33351da177e4SLinus Torvalds skb = list; list = list->next; 33361da177e4SLinus Torvalds 33370d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3338e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 33391da177e4SLinus Torvalds 33401da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 33411da177e4SLinus Torvalds 334273d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 33431da177e4SLinus Torvalds } while (list); 33441da177e4SLinus Torvalds 3345af3e6359SGustavo F. Padovan spin_unlock(&queue->lock); 33461da177e4SLinus Torvalds } 334773d80debSLuiz Augusto von Dentz } 334873d80debSLuiz Augusto von Dentz 334973d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 335073d80debSLuiz Augusto von Dentz { 3351ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 335273d80debSLuiz Augusto von Dentz 3353f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 335473d80debSLuiz Augusto von Dentz 3355ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 33561da177e4SLinus Torvalds 33573eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 33581da177e4SLinus Torvalds } 33591da177e4SLinus Torvalds 33601da177e4SLinus Torvalds /* Send SCO data */ 33610d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 33621da177e4SLinus Torvalds { 33631da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 33641da177e4SLinus Torvalds struct hci_sco_hdr hdr; 33651da177e4SLinus Torvalds 33661da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 33671da177e4SLinus Torvalds 3368aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 33691da177e4SLinus Torvalds hdr.dlen = skb->len; 33701da177e4SLinus Torvalds 3371badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3372badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 33739c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 33741da177e4SLinus Torvalds 33750d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 3376c78ae283SMarcel Holtmann 33771da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 33783eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 33791da177e4SLinus Torvalds } 33801da177e4SLinus Torvalds 33811da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 33821da177e4SLinus Torvalds 33831da177e4SLinus Torvalds /* HCI Connection scheduler */ 33846039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3385a8c5fb1aSGustavo Padovan int *quote) 33861da177e4SLinus Torvalds { 33871da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 33888035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3389abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 33901da177e4SLinus Torvalds 33911da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 33921da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3393bf4c6325SGustavo F. Padovan 3394bf4c6325SGustavo F. Padovan rcu_read_lock(); 3395bf4c6325SGustavo F. Padovan 3396bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3397769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 33981da177e4SLinus Torvalds continue; 3399769be974SMarcel Holtmann 3400769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3401769be974SMarcel Holtmann continue; 3402769be974SMarcel Holtmann 34031da177e4SLinus Torvalds num++; 34041da177e4SLinus Torvalds 34051da177e4SLinus Torvalds if (c->sent < min) { 34061da177e4SLinus Torvalds min = c->sent; 34071da177e4SLinus Torvalds conn = c; 34081da177e4SLinus Torvalds } 340952087a79SLuiz Augusto von Dentz 341052087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 341152087a79SLuiz Augusto von Dentz break; 34121da177e4SLinus Torvalds } 34131da177e4SLinus Torvalds 3414bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3415bf4c6325SGustavo F. Padovan 34161da177e4SLinus Torvalds if (conn) { 34176ed58ec5SVille Tervo int cnt, q; 34186ed58ec5SVille Tervo 34196ed58ec5SVille Tervo switch (conn->type) { 34206ed58ec5SVille Tervo case ACL_LINK: 34216ed58ec5SVille Tervo cnt = hdev->acl_cnt; 34226ed58ec5SVille Tervo break; 34236ed58ec5SVille Tervo case SCO_LINK: 34246ed58ec5SVille Tervo case ESCO_LINK: 34256ed58ec5SVille Tervo cnt = hdev->sco_cnt; 34266ed58ec5SVille Tervo break; 34276ed58ec5SVille Tervo case LE_LINK: 34286ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 34296ed58ec5SVille Tervo break; 34306ed58ec5SVille Tervo default: 34316ed58ec5SVille Tervo cnt = 0; 34326ed58ec5SVille Tervo BT_ERR("Unknown link type"); 34336ed58ec5SVille Tervo } 34346ed58ec5SVille Tervo 34356ed58ec5SVille Tervo q = cnt / num; 34361da177e4SLinus Torvalds *quote = q ? q : 1; 34371da177e4SLinus Torvalds } else 34381da177e4SLinus Torvalds *quote = 0; 34391da177e4SLinus Torvalds 34401da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 34411da177e4SLinus Torvalds return conn; 34421da177e4SLinus Torvalds } 34431da177e4SLinus Torvalds 34446039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 34451da177e4SLinus Torvalds { 34461da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 34471da177e4SLinus Torvalds struct hci_conn *c; 34481da177e4SLinus Torvalds 3449bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 34501da177e4SLinus Torvalds 3451bf4c6325SGustavo F. Padovan rcu_read_lock(); 3452bf4c6325SGustavo F. Padovan 34531da177e4SLinus Torvalds /* Kill stalled connections */ 3454bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3455bae1f5d9SVille Tervo if (c->type == type && c->sent) { 34566ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 34576ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 3458bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 34591da177e4SLinus Torvalds } 34601da177e4SLinus Torvalds } 3461bf4c6325SGustavo F. Padovan 3462bf4c6325SGustavo F. Padovan rcu_read_unlock(); 34631da177e4SLinus Torvalds } 34641da177e4SLinus Torvalds 34656039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 346673d80debSLuiz Augusto von Dentz int *quote) 346773d80debSLuiz Augusto von Dentz { 346873d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 346973d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3470abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 347173d80debSLuiz Augusto von Dentz struct hci_conn *conn; 347273d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 347373d80debSLuiz Augusto von Dentz 347473d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 347573d80debSLuiz Augusto von Dentz 3476bf4c6325SGustavo F. Padovan rcu_read_lock(); 3477bf4c6325SGustavo F. Padovan 3478bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 347973d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 348073d80debSLuiz Augusto von Dentz 348173d80debSLuiz Augusto von Dentz if (conn->type != type) 348273d80debSLuiz Augusto von Dentz continue; 348373d80debSLuiz Augusto von Dentz 348473d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 348573d80debSLuiz Augusto von Dentz continue; 348673d80debSLuiz Augusto von Dentz 348773d80debSLuiz Augusto von Dentz conn_num++; 348873d80debSLuiz Augusto von Dentz 34898192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 349073d80debSLuiz Augusto von Dentz struct sk_buff *skb; 349173d80debSLuiz Augusto von Dentz 349273d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 349373d80debSLuiz Augusto von Dentz continue; 349473d80debSLuiz Augusto von Dentz 349573d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 349673d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 349773d80debSLuiz Augusto von Dentz continue; 349873d80debSLuiz Augusto von Dentz 349973d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 350073d80debSLuiz Augusto von Dentz num = 0; 350173d80debSLuiz Augusto von Dentz min = ~0; 350273d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 350373d80debSLuiz Augusto von Dentz } 350473d80debSLuiz Augusto von Dentz 350573d80debSLuiz Augusto von Dentz num++; 350673d80debSLuiz Augusto von Dentz 350773d80debSLuiz Augusto von Dentz if (conn->sent < min) { 350873d80debSLuiz Augusto von Dentz min = conn->sent; 350973d80debSLuiz Augusto von Dentz chan = tmp; 351073d80debSLuiz Augusto von Dentz } 351173d80debSLuiz Augusto von Dentz } 351273d80debSLuiz Augusto von Dentz 351373d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 351473d80debSLuiz Augusto von Dentz break; 351573d80debSLuiz Augusto von Dentz } 351673d80debSLuiz Augusto von Dentz 3517bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3518bf4c6325SGustavo F. Padovan 351973d80debSLuiz Augusto von Dentz if (!chan) 352073d80debSLuiz Augusto von Dentz return NULL; 352173d80debSLuiz Augusto von Dentz 352273d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 352373d80debSLuiz Augusto von Dentz case ACL_LINK: 352473d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 352573d80debSLuiz Augusto von Dentz break; 3526bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3527bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3528bd1eb66bSAndrei Emeltchenko break; 352973d80debSLuiz Augusto von Dentz case SCO_LINK: 353073d80debSLuiz Augusto von Dentz case ESCO_LINK: 353173d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 353273d80debSLuiz Augusto von Dentz break; 353373d80debSLuiz Augusto von Dentz case LE_LINK: 353473d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 353573d80debSLuiz Augusto von Dentz break; 353673d80debSLuiz Augusto von Dentz default: 353773d80debSLuiz Augusto von Dentz cnt = 0; 353873d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 353973d80debSLuiz Augusto von Dentz } 354073d80debSLuiz Augusto von Dentz 354173d80debSLuiz Augusto von Dentz q = cnt / num; 354273d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 354373d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 354473d80debSLuiz Augusto von Dentz return chan; 354573d80debSLuiz Augusto von Dentz } 354673d80debSLuiz Augusto von Dentz 354702b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 354802b20f0bSLuiz Augusto von Dentz { 354902b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 355002b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 355102b20f0bSLuiz Augusto von Dentz int num = 0; 355202b20f0bSLuiz Augusto von Dentz 355302b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 355402b20f0bSLuiz Augusto von Dentz 3555bf4c6325SGustavo F. Padovan rcu_read_lock(); 3556bf4c6325SGustavo F. Padovan 3557bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 355802b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 355902b20f0bSLuiz Augusto von Dentz 356002b20f0bSLuiz Augusto von Dentz if (conn->type != type) 356102b20f0bSLuiz Augusto von Dentz continue; 356202b20f0bSLuiz Augusto von Dentz 356302b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 356402b20f0bSLuiz Augusto von Dentz continue; 356502b20f0bSLuiz Augusto von Dentz 356602b20f0bSLuiz Augusto von Dentz num++; 356702b20f0bSLuiz Augusto von Dentz 35688192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 356902b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 357002b20f0bSLuiz Augusto von Dentz 357102b20f0bSLuiz Augusto von Dentz if (chan->sent) { 357202b20f0bSLuiz Augusto von Dentz chan->sent = 0; 357302b20f0bSLuiz Augusto von Dentz continue; 357402b20f0bSLuiz Augusto von Dentz } 357502b20f0bSLuiz Augusto von Dentz 357602b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 357702b20f0bSLuiz Augusto von Dentz continue; 357802b20f0bSLuiz Augusto von Dentz 357902b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 358002b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 358102b20f0bSLuiz Augusto von Dentz continue; 358202b20f0bSLuiz Augusto von Dentz 358302b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 358402b20f0bSLuiz Augusto von Dentz 358502b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 358602b20f0bSLuiz Augusto von Dentz skb->priority); 358702b20f0bSLuiz Augusto von Dentz } 358802b20f0bSLuiz Augusto von Dentz 358902b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 359002b20f0bSLuiz Augusto von Dentz break; 359102b20f0bSLuiz Augusto von Dentz } 3592bf4c6325SGustavo F. Padovan 3593bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3594bf4c6325SGustavo F. Padovan 359502b20f0bSLuiz Augusto von Dentz } 359602b20f0bSLuiz Augusto von Dentz 3597b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 3598b71d385aSAndrei Emeltchenko { 3599b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 3600b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 3601b71d385aSAndrei Emeltchenko } 3602b71d385aSAndrei Emeltchenko 36036039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 36041da177e4SLinus Torvalds { 36051da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 36061da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 36071da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 360863d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 36095f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 3610bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 36111da177e4SLinus Torvalds } 361263d2bc1bSAndrei Emeltchenko } 36131da177e4SLinus Torvalds 36146039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 361563d2bc1bSAndrei Emeltchenko { 361663d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 361763d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 361863d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 361963d2bc1bSAndrei Emeltchenko int quote; 362063d2bc1bSAndrei Emeltchenko 362163d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 362204837f64SMarcel Holtmann 362373d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 362473d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 3625ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3626ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 362773d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 362873d80debSLuiz Augusto von Dentz skb->len, skb->priority); 362973d80debSLuiz Augusto von Dentz 3630ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3631ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3632ec1cce24SLuiz Augusto von Dentz break; 3633ec1cce24SLuiz Augusto von Dentz 3634ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3635ec1cce24SLuiz Augusto von Dentz 363673d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 363773d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 363804837f64SMarcel Holtmann 363957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 36401da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 36411da177e4SLinus Torvalds 36421da177e4SLinus Torvalds hdev->acl_cnt--; 364373d80debSLuiz Augusto von Dentz chan->sent++; 364473d80debSLuiz Augusto von Dentz chan->conn->sent++; 36451da177e4SLinus Torvalds } 36461da177e4SLinus Torvalds } 364702b20f0bSLuiz Augusto von Dentz 364802b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 364902b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 36501da177e4SLinus Torvalds } 36511da177e4SLinus Torvalds 36526039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 3653b71d385aSAndrei Emeltchenko { 365463d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 3655b71d385aSAndrei Emeltchenko struct hci_chan *chan; 3656b71d385aSAndrei Emeltchenko struct sk_buff *skb; 3657b71d385aSAndrei Emeltchenko int quote; 3658bd1eb66bSAndrei Emeltchenko u8 type; 3659b71d385aSAndrei Emeltchenko 366063d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 3661b71d385aSAndrei Emeltchenko 3662bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3663bd1eb66bSAndrei Emeltchenko 3664bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 3665bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 3666bd1eb66bSAndrei Emeltchenko else 3667bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 3668bd1eb66bSAndrei Emeltchenko 3669b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 3670bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 3671b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 3672b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 3673b71d385aSAndrei Emeltchenko int blocks; 3674b71d385aSAndrei Emeltchenko 3675b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 3676b71d385aSAndrei Emeltchenko skb->len, skb->priority); 3677b71d385aSAndrei Emeltchenko 3678b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 3679b71d385aSAndrei Emeltchenko if (skb->priority < priority) 3680b71d385aSAndrei Emeltchenko break; 3681b71d385aSAndrei Emeltchenko 3682b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 3683b71d385aSAndrei Emeltchenko 3684b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 3685b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 3686b71d385aSAndrei Emeltchenko return; 3687b71d385aSAndrei Emeltchenko 3688b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 3689b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 3690b71d385aSAndrei Emeltchenko 369157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3692b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 3693b71d385aSAndrei Emeltchenko 3694b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 3695b71d385aSAndrei Emeltchenko quote -= blocks; 3696b71d385aSAndrei Emeltchenko 3697b71d385aSAndrei Emeltchenko chan->sent += blocks; 3698b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 3699b71d385aSAndrei Emeltchenko } 3700b71d385aSAndrei Emeltchenko } 3701b71d385aSAndrei Emeltchenko 3702b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 3703bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 3704b71d385aSAndrei Emeltchenko } 3705b71d385aSAndrei Emeltchenko 37066039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 3707b71d385aSAndrei Emeltchenko { 3708b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3709b71d385aSAndrei Emeltchenko 3710bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 3711bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 3712bd1eb66bSAndrei Emeltchenko return; 3713bd1eb66bSAndrei Emeltchenko 3714bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 3715bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 3716b71d385aSAndrei Emeltchenko return; 3717b71d385aSAndrei Emeltchenko 3718b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 3719b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 3720b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 3721b71d385aSAndrei Emeltchenko break; 3722b71d385aSAndrei Emeltchenko 3723b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 3724b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 3725b71d385aSAndrei Emeltchenko break; 3726b71d385aSAndrei Emeltchenko } 3727b71d385aSAndrei Emeltchenko } 3728b71d385aSAndrei Emeltchenko 37291da177e4SLinus Torvalds /* Schedule SCO */ 37306039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 37311da177e4SLinus Torvalds { 37321da177e4SLinus Torvalds struct hci_conn *conn; 37331da177e4SLinus Torvalds struct sk_buff *skb; 37341da177e4SLinus Torvalds int quote; 37351da177e4SLinus Torvalds 37361da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 37371da177e4SLinus Torvalds 373852087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 373952087a79SLuiz Augusto von Dentz return; 374052087a79SLuiz Augusto von Dentz 37411da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 37421da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 37431da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 374457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 37451da177e4SLinus Torvalds 37461da177e4SLinus Torvalds conn->sent++; 37471da177e4SLinus Torvalds if (conn->sent == ~0) 37481da177e4SLinus Torvalds conn->sent = 0; 37491da177e4SLinus Torvalds } 37501da177e4SLinus Torvalds } 37511da177e4SLinus Torvalds } 37521da177e4SLinus Torvalds 37536039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 3754b6a0dc82SMarcel Holtmann { 3755b6a0dc82SMarcel Holtmann struct hci_conn *conn; 3756b6a0dc82SMarcel Holtmann struct sk_buff *skb; 3757b6a0dc82SMarcel Holtmann int quote; 3758b6a0dc82SMarcel Holtmann 3759b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 3760b6a0dc82SMarcel Holtmann 376152087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 376252087a79SLuiz Augusto von Dentz return; 376352087a79SLuiz Augusto von Dentz 37648fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 37658fc9ced3SGustavo Padovan "e))) { 3766b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 3767b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 376857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3769b6a0dc82SMarcel Holtmann 3770b6a0dc82SMarcel Holtmann conn->sent++; 3771b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 3772b6a0dc82SMarcel Holtmann conn->sent = 0; 3773b6a0dc82SMarcel Holtmann } 3774b6a0dc82SMarcel Holtmann } 3775b6a0dc82SMarcel Holtmann } 3776b6a0dc82SMarcel Holtmann 37776039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 37786ed58ec5SVille Tervo { 377973d80debSLuiz Augusto von Dentz struct hci_chan *chan; 37806ed58ec5SVille Tervo struct sk_buff *skb; 378102b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 37826ed58ec5SVille Tervo 37836ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 37846ed58ec5SVille Tervo 378552087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 378652087a79SLuiz Augusto von Dentz return; 378752087a79SLuiz Augusto von Dentz 37886ed58ec5SVille Tervo if (!test_bit(HCI_RAW, &hdev->flags)) { 37896ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 37906ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 3791bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 37926ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 3793bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 37946ed58ec5SVille Tervo } 37956ed58ec5SVille Tervo 37966ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 379702b20f0bSLuiz Augusto von Dentz tmp = cnt; 379873d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 3799ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3800ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 380173d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 380273d80debSLuiz Augusto von Dentz skb->len, skb->priority); 38036ed58ec5SVille Tervo 3804ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3805ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3806ec1cce24SLuiz Augusto von Dentz break; 3807ec1cce24SLuiz Augusto von Dentz 3808ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3809ec1cce24SLuiz Augusto von Dentz 381057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 38116ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 38126ed58ec5SVille Tervo 38136ed58ec5SVille Tervo cnt--; 381473d80debSLuiz Augusto von Dentz chan->sent++; 381573d80debSLuiz Augusto von Dentz chan->conn->sent++; 38166ed58ec5SVille Tervo } 38176ed58ec5SVille Tervo } 381873d80debSLuiz Augusto von Dentz 38196ed58ec5SVille Tervo if (hdev->le_pkts) 38206ed58ec5SVille Tervo hdev->le_cnt = cnt; 38216ed58ec5SVille Tervo else 38226ed58ec5SVille Tervo hdev->acl_cnt = cnt; 382302b20f0bSLuiz Augusto von Dentz 382402b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 382502b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 38266ed58ec5SVille Tervo } 38276ed58ec5SVille Tervo 38283eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 38291da177e4SLinus Torvalds { 38303eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 38311da177e4SLinus Torvalds struct sk_buff *skb; 38321da177e4SLinus Torvalds 38336ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 38346ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 38351da177e4SLinus Torvalds 383652de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 38371da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 38381da177e4SLinus Torvalds hci_sched_acl(hdev); 38391da177e4SLinus Torvalds hci_sched_sco(hdev); 3840b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 38416ed58ec5SVille Tervo hci_sched_le(hdev); 384252de599eSMarcel Holtmann } 38436ed58ec5SVille Tervo 38441da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 38451da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 384657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 38471da177e4SLinus Torvalds } 38481da177e4SLinus Torvalds 384925985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 38501da177e4SLinus Torvalds 38511da177e4SLinus Torvalds /* ACL data packet */ 38526039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 38531da177e4SLinus Torvalds { 38541da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 38551da177e4SLinus Torvalds struct hci_conn *conn; 38561da177e4SLinus Torvalds __u16 handle, flags; 38571da177e4SLinus Torvalds 38581da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 38591da177e4SLinus Torvalds 38601da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 38611da177e4SLinus Torvalds flags = hci_flags(handle); 38621da177e4SLinus Torvalds handle = hci_handle(handle); 38631da177e4SLinus Torvalds 3864f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 3865a8c5fb1aSGustavo Padovan handle, flags); 38661da177e4SLinus Torvalds 38671da177e4SLinus Torvalds hdev->stat.acl_rx++; 38681da177e4SLinus Torvalds 38691da177e4SLinus Torvalds hci_dev_lock(hdev); 38701da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 38711da177e4SLinus Torvalds hci_dev_unlock(hdev); 38721da177e4SLinus Torvalds 38731da177e4SLinus Torvalds if (conn) { 387465983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 387504837f64SMarcel Holtmann 38761da177e4SLinus Torvalds /* Send to upper protocol */ 3877686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 38781da177e4SLinus Torvalds return; 38791da177e4SLinus Torvalds } else { 38801da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 38811da177e4SLinus Torvalds hdev->name, handle); 38821da177e4SLinus Torvalds } 38831da177e4SLinus Torvalds 38841da177e4SLinus Torvalds kfree_skb(skb); 38851da177e4SLinus Torvalds } 38861da177e4SLinus Torvalds 38871da177e4SLinus Torvalds /* SCO data packet */ 38886039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 38891da177e4SLinus Torvalds { 38901da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 38911da177e4SLinus Torvalds struct hci_conn *conn; 38921da177e4SLinus Torvalds __u16 handle; 38931da177e4SLinus Torvalds 38941da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 38951da177e4SLinus Torvalds 38961da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 38971da177e4SLinus Torvalds 3898f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 38991da177e4SLinus Torvalds 39001da177e4SLinus Torvalds hdev->stat.sco_rx++; 39011da177e4SLinus Torvalds 39021da177e4SLinus Torvalds hci_dev_lock(hdev); 39031da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 39041da177e4SLinus Torvalds hci_dev_unlock(hdev); 39051da177e4SLinus Torvalds 39061da177e4SLinus Torvalds if (conn) { 39071da177e4SLinus Torvalds /* Send to upper protocol */ 3908686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 39091da177e4SLinus Torvalds return; 39101da177e4SLinus Torvalds } else { 39111da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 39121da177e4SLinus Torvalds hdev->name, handle); 39131da177e4SLinus Torvalds } 39141da177e4SLinus Torvalds 39151da177e4SLinus Torvalds kfree_skb(skb); 39161da177e4SLinus Torvalds } 39171da177e4SLinus Torvalds 39189238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 39199238f36aSJohan Hedberg { 39209238f36aSJohan Hedberg struct sk_buff *skb; 39219238f36aSJohan Hedberg 39229238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 39239238f36aSJohan Hedberg if (!skb) 39249238f36aSJohan Hedberg return true; 39259238f36aSJohan Hedberg 39269238f36aSJohan Hedberg return bt_cb(skb)->req.start; 39279238f36aSJohan Hedberg } 39289238f36aSJohan Hedberg 392942c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 393042c6b129SJohan Hedberg { 393142c6b129SJohan Hedberg struct hci_command_hdr *sent; 393242c6b129SJohan Hedberg struct sk_buff *skb; 393342c6b129SJohan Hedberg u16 opcode; 393442c6b129SJohan Hedberg 393542c6b129SJohan Hedberg if (!hdev->sent_cmd) 393642c6b129SJohan Hedberg return; 393742c6b129SJohan Hedberg 393842c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 393942c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 394042c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 394142c6b129SJohan Hedberg return; 394242c6b129SJohan Hedberg 394342c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 394442c6b129SJohan Hedberg if (!skb) 394542c6b129SJohan Hedberg return; 394642c6b129SJohan Hedberg 394742c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 394842c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 394942c6b129SJohan Hedberg } 395042c6b129SJohan Hedberg 39519238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 39529238f36aSJohan Hedberg { 39539238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 39549238f36aSJohan Hedberg struct sk_buff *skb; 39559238f36aSJohan Hedberg unsigned long flags; 39569238f36aSJohan Hedberg 39579238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 39589238f36aSJohan Hedberg 395942c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 396042c6b129SJohan Hedberg * sent we need to do special handling of it. 39619238f36aSJohan Hedberg */ 396242c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 396342c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 396442c6b129SJohan Hedberg * reset complete event during init and any pending 396542c6b129SJohan Hedberg * command will never be completed. In such a case we 396642c6b129SJohan Hedberg * need to resend whatever was the last sent 396742c6b129SJohan Hedberg * command. 396842c6b129SJohan Hedberg */ 396942c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 397042c6b129SJohan Hedberg hci_resend_last(hdev); 397142c6b129SJohan Hedberg 39729238f36aSJohan Hedberg return; 397342c6b129SJohan Hedberg } 39749238f36aSJohan Hedberg 39759238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 39769238f36aSJohan Hedberg * this request the request is not yet complete. 39779238f36aSJohan Hedberg */ 39789238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 39799238f36aSJohan Hedberg return; 39809238f36aSJohan Hedberg 39819238f36aSJohan Hedberg /* If this was the last command in a request the complete 39829238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 39839238f36aSJohan Hedberg * command queue (hdev->cmd_q). 39849238f36aSJohan Hedberg */ 39859238f36aSJohan Hedberg if (hdev->sent_cmd) { 39869238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 398753e21fbcSJohan Hedberg 398853e21fbcSJohan Hedberg if (req_complete) { 398953e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 399053e21fbcSJohan Hedberg * avoid calling the callback more than once if 399153e21fbcSJohan Hedberg * this function gets called again. 399253e21fbcSJohan Hedberg */ 399353e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 399453e21fbcSJohan Hedberg 39959238f36aSJohan Hedberg goto call_complete; 39969238f36aSJohan Hedberg } 399753e21fbcSJohan Hedberg } 39989238f36aSJohan Hedberg 39999238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 40009238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 40019238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 40029238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 40039238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 40049238f36aSJohan Hedberg break; 40059238f36aSJohan Hedberg } 40069238f36aSJohan Hedberg 40079238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 40089238f36aSJohan Hedberg kfree_skb(skb); 40099238f36aSJohan Hedberg } 40109238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 40119238f36aSJohan Hedberg 40129238f36aSJohan Hedberg call_complete: 40139238f36aSJohan Hedberg if (req_complete) 40149238f36aSJohan Hedberg req_complete(hdev, status); 40159238f36aSJohan Hedberg } 40169238f36aSJohan Hedberg 4017b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 40181da177e4SLinus Torvalds { 4019b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 40201da177e4SLinus Torvalds struct sk_buff *skb; 40211da177e4SLinus Torvalds 40221da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 40231da177e4SLinus Torvalds 40241da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4025cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4026cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4027cd82e61cSMarcel Holtmann 40281da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 40291da177e4SLinus Torvalds /* Send copy to the sockets */ 4030470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 40311da177e4SLinus Torvalds } 40321da177e4SLinus Torvalds 40330736cfa8SMarcel Holtmann if (test_bit(HCI_RAW, &hdev->flags) || 40340736cfa8SMarcel Holtmann test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 40351da177e4SLinus Torvalds kfree_skb(skb); 40361da177e4SLinus Torvalds continue; 40371da177e4SLinus Torvalds } 40381da177e4SLinus Torvalds 40391da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 40401da177e4SLinus Torvalds /* Don't process data packets in this states. */ 40410d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 40421da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 40431da177e4SLinus Torvalds case HCI_SCODATA_PKT: 40441da177e4SLinus Torvalds kfree_skb(skb); 40451da177e4SLinus Torvalds continue; 40463ff50b79SStephen Hemminger } 40471da177e4SLinus Torvalds } 40481da177e4SLinus Torvalds 40491da177e4SLinus Torvalds /* Process frame */ 40500d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 40511da177e4SLinus Torvalds case HCI_EVENT_PKT: 4052b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 40531da177e4SLinus Torvalds hci_event_packet(hdev, skb); 40541da177e4SLinus Torvalds break; 40551da177e4SLinus Torvalds 40561da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 40571da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 40581da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 40591da177e4SLinus Torvalds break; 40601da177e4SLinus Torvalds 40611da177e4SLinus Torvalds case HCI_SCODATA_PKT: 40621da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 40631da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 40641da177e4SLinus Torvalds break; 40651da177e4SLinus Torvalds 40661da177e4SLinus Torvalds default: 40671da177e4SLinus Torvalds kfree_skb(skb); 40681da177e4SLinus Torvalds break; 40691da177e4SLinus Torvalds } 40701da177e4SLinus Torvalds } 40711da177e4SLinus Torvalds } 40721da177e4SLinus Torvalds 4073c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 40741da177e4SLinus Torvalds { 4075c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 40761da177e4SLinus Torvalds struct sk_buff *skb; 40771da177e4SLinus Torvalds 40782104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 40792104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 40801da177e4SLinus Torvalds 40811da177e4SLinus Torvalds /* Send queued commands */ 40825a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 40835a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 40845a08ecceSAndrei Emeltchenko if (!skb) 40855a08ecceSAndrei Emeltchenko return; 40865a08ecceSAndrei Emeltchenko 40871da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 40881da177e4SLinus Torvalds 4089a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 409070f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 40911da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 409257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40937bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 40947bdb8a5cSSzymon Janc del_timer(&hdev->cmd_timer); 40957bdb8a5cSSzymon Janc else 40966bd32326SVille Tervo mod_timer(&hdev->cmd_timer, 40975f246e89SAndrei Emeltchenko jiffies + HCI_CMD_TIMEOUT); 40981da177e4SLinus Torvalds } else { 40991da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4100c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 41011da177e4SLinus Torvalds } 41021da177e4SLinus Torvalds } 41031da177e4SLinus Torvalds } 4104