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 6170afe0b8SMarcel Holtmann static int blacklist_show(struct seq_file *f, void *p) 6270afe0b8SMarcel Holtmann { 6370afe0b8SMarcel Holtmann struct hci_dev *hdev = f->private; 6470afe0b8SMarcel Holtmann struct bdaddr_list *b; 6570afe0b8SMarcel Holtmann 6670afe0b8SMarcel Holtmann hci_dev_lock(hdev); 6770afe0b8SMarcel Holtmann list_for_each_entry(b, &hdev->blacklist, list) 68b25f0785SMarcel Holtmann seq_printf(f, "%pMR (type %u)\n", &b->bdaddr, b->bdaddr_type); 6970afe0b8SMarcel Holtmann hci_dev_unlock(hdev); 7070afe0b8SMarcel Holtmann 7170afe0b8SMarcel Holtmann return 0; 7270afe0b8SMarcel Holtmann } 7370afe0b8SMarcel Holtmann 7470afe0b8SMarcel Holtmann static int blacklist_open(struct inode *inode, struct file *file) 7570afe0b8SMarcel Holtmann { 7670afe0b8SMarcel Holtmann return single_open(file, blacklist_show, inode->i_private); 7770afe0b8SMarcel Holtmann } 7870afe0b8SMarcel Holtmann 7970afe0b8SMarcel Holtmann static const struct file_operations blacklist_fops = { 8070afe0b8SMarcel Holtmann .open = blacklist_open, 8170afe0b8SMarcel Holtmann .read = seq_read, 8270afe0b8SMarcel Holtmann .llseek = seq_lseek, 8370afe0b8SMarcel Holtmann .release = single_release, 8470afe0b8SMarcel Holtmann }; 8570afe0b8SMarcel Holtmann 8647219839SMarcel Holtmann static int uuids_show(struct seq_file *f, void *p) 8747219839SMarcel Holtmann { 8847219839SMarcel Holtmann struct hci_dev *hdev = f->private; 8947219839SMarcel Holtmann struct bt_uuid *uuid; 9047219839SMarcel Holtmann 9147219839SMarcel Holtmann hci_dev_lock(hdev); 9247219839SMarcel Holtmann list_for_each_entry(uuid, &hdev->uuids, list) { 9347219839SMarcel Holtmann u32 data0, data5; 9447219839SMarcel Holtmann u16 data1, data2, data3, data4; 9547219839SMarcel Holtmann 9647219839SMarcel Holtmann data5 = get_unaligned_le32(uuid); 9747219839SMarcel Holtmann data4 = get_unaligned_le16(uuid + 4); 9847219839SMarcel Holtmann data3 = get_unaligned_le16(uuid + 6); 9947219839SMarcel Holtmann data2 = get_unaligned_le16(uuid + 8); 10047219839SMarcel Holtmann data1 = get_unaligned_le16(uuid + 10); 10147219839SMarcel Holtmann data0 = get_unaligned_le32(uuid + 12); 10247219839SMarcel Holtmann 10347219839SMarcel Holtmann seq_printf(f, "%.8x-%.4x-%.4x-%.4x-%.4x%.8x\n", 10447219839SMarcel Holtmann data0, data1, data2, data3, data4, data5); 10547219839SMarcel Holtmann } 10647219839SMarcel Holtmann hci_dev_unlock(hdev); 10747219839SMarcel Holtmann 10847219839SMarcel Holtmann return 0; 10947219839SMarcel Holtmann } 11047219839SMarcel Holtmann 11147219839SMarcel Holtmann static int uuids_open(struct inode *inode, struct file *file) 11247219839SMarcel Holtmann { 11347219839SMarcel Holtmann return single_open(file, uuids_show, inode->i_private); 11447219839SMarcel Holtmann } 11547219839SMarcel Holtmann 11647219839SMarcel Holtmann static const struct file_operations uuids_fops = { 11747219839SMarcel Holtmann .open = uuids_open, 11847219839SMarcel Holtmann .read = seq_read, 11947219839SMarcel Holtmann .llseek = seq_lseek, 12047219839SMarcel Holtmann .release = single_release, 12147219839SMarcel Holtmann }; 12247219839SMarcel Holtmann 123baf27f6eSMarcel Holtmann static int inquiry_cache_show(struct seq_file *f, void *p) 124baf27f6eSMarcel Holtmann { 125baf27f6eSMarcel Holtmann struct hci_dev *hdev = f->private; 126baf27f6eSMarcel Holtmann struct discovery_state *cache = &hdev->discovery; 127baf27f6eSMarcel Holtmann struct inquiry_entry *e; 128baf27f6eSMarcel Holtmann 129baf27f6eSMarcel Holtmann hci_dev_lock(hdev); 130baf27f6eSMarcel Holtmann 131baf27f6eSMarcel Holtmann list_for_each_entry(e, &cache->all, all) { 132baf27f6eSMarcel Holtmann struct inquiry_data *data = &e->data; 133baf27f6eSMarcel Holtmann seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n", 134baf27f6eSMarcel Holtmann &data->bdaddr, 135baf27f6eSMarcel Holtmann data->pscan_rep_mode, data->pscan_period_mode, 136baf27f6eSMarcel Holtmann data->pscan_mode, data->dev_class[2], 137baf27f6eSMarcel Holtmann data->dev_class[1], data->dev_class[0], 138baf27f6eSMarcel Holtmann __le16_to_cpu(data->clock_offset), 139baf27f6eSMarcel Holtmann data->rssi, data->ssp_mode, e->timestamp); 140baf27f6eSMarcel Holtmann } 141baf27f6eSMarcel Holtmann 142baf27f6eSMarcel Holtmann hci_dev_unlock(hdev); 143baf27f6eSMarcel Holtmann 144baf27f6eSMarcel Holtmann return 0; 145baf27f6eSMarcel Holtmann } 146baf27f6eSMarcel Holtmann 147baf27f6eSMarcel Holtmann static int inquiry_cache_open(struct inode *inode, struct file *file) 148baf27f6eSMarcel Holtmann { 149baf27f6eSMarcel Holtmann return single_open(file, inquiry_cache_show, inode->i_private); 150baf27f6eSMarcel Holtmann } 151baf27f6eSMarcel Holtmann 152baf27f6eSMarcel Holtmann static const struct file_operations inquiry_cache_fops = { 153baf27f6eSMarcel Holtmann .open = inquiry_cache_open, 154baf27f6eSMarcel Holtmann .read = seq_read, 155baf27f6eSMarcel Holtmann .llseek = seq_lseek, 156baf27f6eSMarcel Holtmann .release = single_release, 157baf27f6eSMarcel Holtmann }; 158baf27f6eSMarcel Holtmann 159041000b9SMarcel Holtmann static int voice_setting_get(void *data, u64 *val) 160041000b9SMarcel Holtmann { 161041000b9SMarcel Holtmann struct hci_dev *hdev = data; 162041000b9SMarcel Holtmann 163041000b9SMarcel Holtmann hci_dev_lock(hdev); 164041000b9SMarcel Holtmann *val = hdev->voice_setting; 165041000b9SMarcel Holtmann hci_dev_unlock(hdev); 166041000b9SMarcel Holtmann 167041000b9SMarcel Holtmann return 0; 168041000b9SMarcel Holtmann } 169041000b9SMarcel Holtmann 170041000b9SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get, 171041000b9SMarcel Holtmann NULL, "0x%4.4llx\n"); 172041000b9SMarcel Holtmann 173ebd1e33bSMarcel Holtmann static int auto_accept_delay_set(void *data, u64 val) 174ebd1e33bSMarcel Holtmann { 175ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 176ebd1e33bSMarcel Holtmann 177ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 178ebd1e33bSMarcel Holtmann hdev->auto_accept_delay = val; 179ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 180ebd1e33bSMarcel Holtmann 181ebd1e33bSMarcel Holtmann return 0; 182ebd1e33bSMarcel Holtmann } 183ebd1e33bSMarcel Holtmann 184ebd1e33bSMarcel Holtmann static int auto_accept_delay_get(void *data, u64 *val) 185ebd1e33bSMarcel Holtmann { 186ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 187ebd1e33bSMarcel Holtmann 188ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 189ebd1e33bSMarcel Holtmann *val = hdev->auto_accept_delay; 190ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 191ebd1e33bSMarcel Holtmann 192ebd1e33bSMarcel Holtmann return 0; 193ebd1e33bSMarcel Holtmann } 194ebd1e33bSMarcel Holtmann 195ebd1e33bSMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get, 196ebd1e33bSMarcel Holtmann auto_accept_delay_set, "%llu\n"); 197ebd1e33bSMarcel Holtmann 1982bfa3531SMarcel Holtmann static int idle_timeout_set(void *data, u64 val) 1992bfa3531SMarcel Holtmann { 2002bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 2012bfa3531SMarcel Holtmann 2022bfa3531SMarcel Holtmann if (val != 0 && (val < 500 || val > 3600000)) 2032bfa3531SMarcel Holtmann return -EINVAL; 2042bfa3531SMarcel Holtmann 2052bfa3531SMarcel Holtmann hci_dev_lock(hdev); 2062bfa3531SMarcel Holtmann hdev->idle_timeout= val; 2072bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 2082bfa3531SMarcel Holtmann 2092bfa3531SMarcel Holtmann return 0; 2102bfa3531SMarcel Holtmann } 2112bfa3531SMarcel Holtmann 2122bfa3531SMarcel Holtmann static int idle_timeout_get(void *data, u64 *val) 2132bfa3531SMarcel Holtmann { 2142bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 2152bfa3531SMarcel Holtmann 2162bfa3531SMarcel Holtmann hci_dev_lock(hdev); 2172bfa3531SMarcel Holtmann *val = hdev->idle_timeout; 2182bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 2192bfa3531SMarcel Holtmann 2202bfa3531SMarcel Holtmann return 0; 2212bfa3531SMarcel Holtmann } 2222bfa3531SMarcel Holtmann 2232bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(idle_timeout_fops, idle_timeout_get, 2242bfa3531SMarcel Holtmann idle_timeout_set, "%llu\n"); 2252bfa3531SMarcel Holtmann 2262bfa3531SMarcel Holtmann static int sniff_min_interval_set(void *data, u64 val) 2272bfa3531SMarcel Holtmann { 2282bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 2292bfa3531SMarcel Holtmann 2302bfa3531SMarcel Holtmann if (val == 0 || val % 2 || val > hdev->sniff_max_interval) 2312bfa3531SMarcel Holtmann return -EINVAL; 2322bfa3531SMarcel Holtmann 2332bfa3531SMarcel Holtmann hci_dev_lock(hdev); 2342bfa3531SMarcel Holtmann hdev->sniff_min_interval= val; 2352bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 2362bfa3531SMarcel Holtmann 2372bfa3531SMarcel Holtmann return 0; 2382bfa3531SMarcel Holtmann } 2392bfa3531SMarcel Holtmann 2402bfa3531SMarcel Holtmann static int sniff_min_interval_get(void *data, u64 *val) 2412bfa3531SMarcel Holtmann { 2422bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 2432bfa3531SMarcel Holtmann 2442bfa3531SMarcel Holtmann hci_dev_lock(hdev); 2452bfa3531SMarcel Holtmann *val = hdev->sniff_min_interval; 2462bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 2472bfa3531SMarcel Holtmann 2482bfa3531SMarcel Holtmann return 0; 2492bfa3531SMarcel Holtmann } 2502bfa3531SMarcel Holtmann 2512bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(sniff_min_interval_fops, sniff_min_interval_get, 2522bfa3531SMarcel Holtmann sniff_min_interval_set, "%llu\n"); 2532bfa3531SMarcel Holtmann 2542bfa3531SMarcel Holtmann static int sniff_max_interval_set(void *data, u64 val) 2552bfa3531SMarcel Holtmann { 2562bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 2572bfa3531SMarcel Holtmann 2582bfa3531SMarcel Holtmann if (val == 0 || val % 2 || val < hdev->sniff_min_interval) 2592bfa3531SMarcel Holtmann return -EINVAL; 2602bfa3531SMarcel Holtmann 2612bfa3531SMarcel Holtmann hci_dev_lock(hdev); 2622bfa3531SMarcel Holtmann hdev->sniff_max_interval= val; 2632bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 2642bfa3531SMarcel Holtmann 2652bfa3531SMarcel Holtmann return 0; 2662bfa3531SMarcel Holtmann } 2672bfa3531SMarcel Holtmann 2682bfa3531SMarcel Holtmann static int sniff_max_interval_get(void *data, u64 *val) 2692bfa3531SMarcel Holtmann { 2702bfa3531SMarcel Holtmann struct hci_dev *hdev = data; 2712bfa3531SMarcel Holtmann 2722bfa3531SMarcel Holtmann hci_dev_lock(hdev); 2732bfa3531SMarcel Holtmann *val = hdev->sniff_max_interval; 2742bfa3531SMarcel Holtmann hci_dev_unlock(hdev); 2752bfa3531SMarcel Holtmann 2762bfa3531SMarcel Holtmann return 0; 2772bfa3531SMarcel Holtmann } 2782bfa3531SMarcel Holtmann 2792bfa3531SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(sniff_max_interval_fops, sniff_max_interval_get, 2802bfa3531SMarcel Holtmann sniff_max_interval_set, "%llu\n"); 2812bfa3531SMarcel Holtmann 282e7b8fc92SMarcel Holtmann static int static_address_show(struct seq_file *f, void *p) 283e7b8fc92SMarcel Holtmann { 284e7b8fc92SMarcel Holtmann struct hci_dev *hdev = f->private; 285e7b8fc92SMarcel Holtmann 286e7b8fc92SMarcel Holtmann hci_dev_lock(hdev); 287e7b8fc92SMarcel Holtmann seq_printf(f, "%pMR\n", &hdev->static_addr); 288e7b8fc92SMarcel Holtmann hci_dev_unlock(hdev); 289e7b8fc92SMarcel Holtmann 290e7b8fc92SMarcel Holtmann return 0; 291e7b8fc92SMarcel Holtmann } 292e7b8fc92SMarcel Holtmann 293e7b8fc92SMarcel Holtmann static int static_address_open(struct inode *inode, struct file *file) 294e7b8fc92SMarcel Holtmann { 295e7b8fc92SMarcel Holtmann return single_open(file, static_address_show, inode->i_private); 296e7b8fc92SMarcel Holtmann } 297e7b8fc92SMarcel Holtmann 298e7b8fc92SMarcel Holtmann static const struct file_operations static_address_fops = { 299e7b8fc92SMarcel Holtmann .open = static_address_open, 300e7b8fc92SMarcel Holtmann .read = seq_read, 301e7b8fc92SMarcel Holtmann .llseek = seq_lseek, 302e7b8fc92SMarcel Holtmann .release = single_release, 303e7b8fc92SMarcel Holtmann }; 304e7b8fc92SMarcel Holtmann 3051da177e4SLinus Torvalds /* ---- HCI requests ---- */ 3061da177e4SLinus Torvalds 30742c6b129SJohan Hedberg static void hci_req_sync_complete(struct hci_dev *hdev, u8 result) 3081da177e4SLinus Torvalds { 30942c6b129SJohan Hedberg BT_DBG("%s result 0x%2.2x", hdev->name, result); 31075fb0e32SJohan Hedberg 3111da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 3121da177e4SLinus Torvalds hdev->req_result = result; 3131da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 3141da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 3151da177e4SLinus Torvalds } 3161da177e4SLinus Torvalds } 3171da177e4SLinus Torvalds 3181da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 3191da177e4SLinus Torvalds { 3201da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 3211da177e4SLinus Torvalds 3221da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 3231da177e4SLinus Torvalds hdev->req_result = err; 3241da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 3251da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 3261da177e4SLinus Torvalds } 3271da177e4SLinus Torvalds } 3281da177e4SLinus Torvalds 32977a63e0aSFengguang Wu static struct sk_buff *hci_get_cmd_complete(struct hci_dev *hdev, u16 opcode, 33077a63e0aSFengguang Wu u8 event) 33175e84b7cSJohan Hedberg { 33275e84b7cSJohan Hedberg struct hci_ev_cmd_complete *ev; 33375e84b7cSJohan Hedberg struct hci_event_hdr *hdr; 33475e84b7cSJohan Hedberg struct sk_buff *skb; 33575e84b7cSJohan Hedberg 33675e84b7cSJohan Hedberg hci_dev_lock(hdev); 33775e84b7cSJohan Hedberg 33875e84b7cSJohan Hedberg skb = hdev->recv_evt; 33975e84b7cSJohan Hedberg hdev->recv_evt = NULL; 34075e84b7cSJohan Hedberg 34175e84b7cSJohan Hedberg hci_dev_unlock(hdev); 34275e84b7cSJohan Hedberg 34375e84b7cSJohan Hedberg if (!skb) 34475e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 34575e84b7cSJohan Hedberg 34675e84b7cSJohan Hedberg if (skb->len < sizeof(*hdr)) { 34775e84b7cSJohan Hedberg BT_ERR("Too short HCI event"); 34875e84b7cSJohan Hedberg goto failed; 34975e84b7cSJohan Hedberg } 35075e84b7cSJohan Hedberg 35175e84b7cSJohan Hedberg hdr = (void *) skb->data; 35275e84b7cSJohan Hedberg skb_pull(skb, HCI_EVENT_HDR_SIZE); 35375e84b7cSJohan Hedberg 3547b1abbbeSJohan Hedberg if (event) { 3557b1abbbeSJohan Hedberg if (hdr->evt != event) 3567b1abbbeSJohan Hedberg goto failed; 3577b1abbbeSJohan Hedberg return skb; 3587b1abbbeSJohan Hedberg } 3597b1abbbeSJohan Hedberg 36075e84b7cSJohan Hedberg if (hdr->evt != HCI_EV_CMD_COMPLETE) { 36175e84b7cSJohan Hedberg BT_DBG("Last event is not cmd complete (0x%2.2x)", hdr->evt); 36275e84b7cSJohan Hedberg goto failed; 36375e84b7cSJohan Hedberg } 36475e84b7cSJohan Hedberg 36575e84b7cSJohan Hedberg if (skb->len < sizeof(*ev)) { 36675e84b7cSJohan Hedberg BT_ERR("Too short cmd_complete event"); 36775e84b7cSJohan Hedberg goto failed; 36875e84b7cSJohan Hedberg } 36975e84b7cSJohan Hedberg 37075e84b7cSJohan Hedberg ev = (void *) skb->data; 37175e84b7cSJohan Hedberg skb_pull(skb, sizeof(*ev)); 37275e84b7cSJohan Hedberg 37375e84b7cSJohan Hedberg if (opcode == __le16_to_cpu(ev->opcode)) 37475e84b7cSJohan Hedberg return skb; 37575e84b7cSJohan Hedberg 37675e84b7cSJohan Hedberg BT_DBG("opcode doesn't match (0x%2.2x != 0x%2.2x)", opcode, 37775e84b7cSJohan Hedberg __le16_to_cpu(ev->opcode)); 37875e84b7cSJohan Hedberg 37975e84b7cSJohan Hedberg failed: 38075e84b7cSJohan Hedberg kfree_skb(skb); 38175e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 38275e84b7cSJohan Hedberg } 38375e84b7cSJohan Hedberg 3847b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, 38507dc93ddSJohan Hedberg const void *param, u8 event, u32 timeout) 38675e84b7cSJohan Hedberg { 38775e84b7cSJohan Hedberg DECLARE_WAITQUEUE(wait, current); 38875e84b7cSJohan Hedberg struct hci_request req; 38975e84b7cSJohan Hedberg int err = 0; 39075e84b7cSJohan Hedberg 39175e84b7cSJohan Hedberg BT_DBG("%s", hdev->name); 39275e84b7cSJohan Hedberg 39375e84b7cSJohan Hedberg hci_req_init(&req, hdev); 39475e84b7cSJohan Hedberg 3957b1abbbeSJohan Hedberg hci_req_add_ev(&req, opcode, plen, param, event); 39675e84b7cSJohan Hedberg 39775e84b7cSJohan Hedberg hdev->req_status = HCI_REQ_PEND; 39875e84b7cSJohan Hedberg 39975e84b7cSJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 40075e84b7cSJohan Hedberg if (err < 0) 40175e84b7cSJohan Hedberg return ERR_PTR(err); 40275e84b7cSJohan Hedberg 40375e84b7cSJohan Hedberg add_wait_queue(&hdev->req_wait_q, &wait); 40475e84b7cSJohan Hedberg set_current_state(TASK_INTERRUPTIBLE); 40575e84b7cSJohan Hedberg 40675e84b7cSJohan Hedberg schedule_timeout(timeout); 40775e84b7cSJohan Hedberg 40875e84b7cSJohan Hedberg remove_wait_queue(&hdev->req_wait_q, &wait); 40975e84b7cSJohan Hedberg 41075e84b7cSJohan Hedberg if (signal_pending(current)) 41175e84b7cSJohan Hedberg return ERR_PTR(-EINTR); 41275e84b7cSJohan Hedberg 41375e84b7cSJohan Hedberg switch (hdev->req_status) { 41475e84b7cSJohan Hedberg case HCI_REQ_DONE: 41575e84b7cSJohan Hedberg err = -bt_to_errno(hdev->req_result); 41675e84b7cSJohan Hedberg break; 41775e84b7cSJohan Hedberg 41875e84b7cSJohan Hedberg case HCI_REQ_CANCELED: 41975e84b7cSJohan Hedberg err = -hdev->req_result; 42075e84b7cSJohan Hedberg break; 42175e84b7cSJohan Hedberg 42275e84b7cSJohan Hedberg default: 42375e84b7cSJohan Hedberg err = -ETIMEDOUT; 42475e84b7cSJohan Hedberg break; 42575e84b7cSJohan Hedberg } 42675e84b7cSJohan Hedberg 42775e84b7cSJohan Hedberg hdev->req_status = hdev->req_result = 0; 42875e84b7cSJohan Hedberg 42975e84b7cSJohan Hedberg BT_DBG("%s end: err %d", hdev->name, err); 43075e84b7cSJohan Hedberg 43175e84b7cSJohan Hedberg if (err < 0) 43275e84b7cSJohan Hedberg return ERR_PTR(err); 43375e84b7cSJohan Hedberg 4347b1abbbeSJohan Hedberg return hci_get_cmd_complete(hdev, opcode, event); 4357b1abbbeSJohan Hedberg } 4367b1abbbeSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync_ev); 4377b1abbbeSJohan Hedberg 4387b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 43907dc93ddSJohan Hedberg const void *param, u32 timeout) 4407b1abbbeSJohan Hedberg { 4417b1abbbeSJohan Hedberg return __hci_cmd_sync_ev(hdev, opcode, plen, param, 0, timeout); 44275e84b7cSJohan Hedberg } 44375e84b7cSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync); 44475e84b7cSJohan Hedberg 4451da177e4SLinus Torvalds /* Execute request and wait for completion. */ 44601178cd4SJohan Hedberg static int __hci_req_sync(struct hci_dev *hdev, 44742c6b129SJohan Hedberg void (*func)(struct hci_request *req, 44842c6b129SJohan Hedberg unsigned long opt), 4491da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 4501da177e4SLinus Torvalds { 45142c6b129SJohan Hedberg struct hci_request req; 4521da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 4531da177e4SLinus Torvalds int err = 0; 4541da177e4SLinus Torvalds 4551da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 4561da177e4SLinus Torvalds 45742c6b129SJohan Hedberg hci_req_init(&req, hdev); 45842c6b129SJohan Hedberg 4591da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 4601da177e4SLinus Torvalds 46142c6b129SJohan Hedberg func(&req, opt); 46253cce22dSJohan Hedberg 46342c6b129SJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 46442c6b129SJohan Hedberg if (err < 0) { 46553cce22dSJohan Hedberg hdev->req_status = 0; 466920c8300SAndre Guedes 467920c8300SAndre Guedes /* ENODATA means the HCI request command queue is empty. 468920c8300SAndre Guedes * This can happen when a request with conditionals doesn't 469920c8300SAndre Guedes * trigger any commands to be sent. This is normal behavior 470920c8300SAndre Guedes * and should not trigger an error return. 47142c6b129SJohan Hedberg */ 472920c8300SAndre Guedes if (err == -ENODATA) 47342c6b129SJohan Hedberg return 0; 474920c8300SAndre Guedes 475920c8300SAndre Guedes return err; 47653cce22dSJohan Hedberg } 47753cce22dSJohan Hedberg 478bc4445c7SAndre Guedes add_wait_queue(&hdev->req_wait_q, &wait); 479bc4445c7SAndre Guedes set_current_state(TASK_INTERRUPTIBLE); 480bc4445c7SAndre Guedes 4811da177e4SLinus Torvalds schedule_timeout(timeout); 4821da177e4SLinus Torvalds 4831da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 4841da177e4SLinus Torvalds 4851da177e4SLinus Torvalds if (signal_pending(current)) 4861da177e4SLinus Torvalds return -EINTR; 4871da177e4SLinus Torvalds 4881da177e4SLinus Torvalds switch (hdev->req_status) { 4891da177e4SLinus Torvalds case HCI_REQ_DONE: 490e175072fSJoe Perches err = -bt_to_errno(hdev->req_result); 4911da177e4SLinus Torvalds break; 4921da177e4SLinus Torvalds 4931da177e4SLinus Torvalds case HCI_REQ_CANCELED: 4941da177e4SLinus Torvalds err = -hdev->req_result; 4951da177e4SLinus Torvalds break; 4961da177e4SLinus Torvalds 4971da177e4SLinus Torvalds default: 4981da177e4SLinus Torvalds err = -ETIMEDOUT; 4991da177e4SLinus Torvalds break; 5003ff50b79SStephen Hemminger } 5011da177e4SLinus Torvalds 502a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 5031da177e4SLinus Torvalds 5041da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 5051da177e4SLinus Torvalds 5061da177e4SLinus Torvalds return err; 5071da177e4SLinus Torvalds } 5081da177e4SLinus Torvalds 50901178cd4SJohan Hedberg static int hci_req_sync(struct hci_dev *hdev, 51042c6b129SJohan Hedberg void (*req)(struct hci_request *req, 51142c6b129SJohan Hedberg unsigned long opt), 5121da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 5131da177e4SLinus Torvalds { 5141da177e4SLinus Torvalds int ret; 5151da177e4SLinus Torvalds 5167c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 5177c6a329eSMarcel Holtmann return -ENETDOWN; 5187c6a329eSMarcel Holtmann 5191da177e4SLinus Torvalds /* Serialize all requests */ 5201da177e4SLinus Torvalds hci_req_lock(hdev); 52101178cd4SJohan Hedberg ret = __hci_req_sync(hdev, req, opt, timeout); 5221da177e4SLinus Torvalds hci_req_unlock(hdev); 5231da177e4SLinus Torvalds 5241da177e4SLinus Torvalds return ret; 5251da177e4SLinus Torvalds } 5261da177e4SLinus Torvalds 52742c6b129SJohan Hedberg static void hci_reset_req(struct hci_request *req, unsigned long opt) 5281da177e4SLinus Torvalds { 52942c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 5301da177e4SLinus Torvalds 5311da177e4SLinus Torvalds /* Reset device */ 53242c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 53342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 5341da177e4SLinus Torvalds } 5351da177e4SLinus Torvalds 53642c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 5371da177e4SLinus Torvalds { 53842c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 5392455a3eaSAndrei Emeltchenko 5401da177e4SLinus Torvalds /* Read Local Supported Features */ 54142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 5421da177e4SLinus Torvalds 5431143e5a6SMarcel Holtmann /* Read Local Version */ 54442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 5452177bab5SJohan Hedberg 5462177bab5SJohan Hedberg /* Read BD Address */ 54742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 5481da177e4SLinus Torvalds } 5491da177e4SLinus Torvalds 55042c6b129SJohan Hedberg static void amp_init(struct hci_request *req) 551e61ef499SAndrei Emeltchenko { 55242c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 5532455a3eaSAndrei Emeltchenko 554e61ef499SAndrei Emeltchenko /* Read Local Version */ 55542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 5566bcbc489SAndrei Emeltchenko 557f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 558f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 559f6996cfeSMarcel Holtmann 560f6996cfeSMarcel Holtmann /* Read Local Supported Features */ 561f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 562f6996cfeSMarcel Holtmann 5636bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 56442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 565e71dfabaSAndrei Emeltchenko 566e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 56742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 5687528ca1cSMarcel Holtmann 569f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 570f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 571f38ba941SMarcel Holtmann 5727528ca1cSMarcel Holtmann /* Read Location Data */ 5737528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 574e61ef499SAndrei Emeltchenko } 575e61ef499SAndrei Emeltchenko 57642c6b129SJohan Hedberg static void hci_init1_req(struct hci_request *req, unsigned long opt) 577e61ef499SAndrei Emeltchenko { 57842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 579e61ef499SAndrei Emeltchenko 580e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 581e61ef499SAndrei Emeltchenko 58211778716SAndrei Emeltchenko /* Reset */ 58311778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 58442c6b129SJohan Hedberg hci_reset_req(req, 0); 58511778716SAndrei Emeltchenko 586e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 587e61ef499SAndrei Emeltchenko case HCI_BREDR: 58842c6b129SJohan Hedberg bredr_init(req); 589e61ef499SAndrei Emeltchenko break; 590e61ef499SAndrei Emeltchenko 591e61ef499SAndrei Emeltchenko case HCI_AMP: 59242c6b129SJohan Hedberg amp_init(req); 593e61ef499SAndrei Emeltchenko break; 594e61ef499SAndrei Emeltchenko 595e61ef499SAndrei Emeltchenko default: 596e61ef499SAndrei Emeltchenko BT_ERR("Unknown device type %d", hdev->dev_type); 597e61ef499SAndrei Emeltchenko break; 598e61ef499SAndrei Emeltchenko } 599e61ef499SAndrei Emeltchenko } 600e61ef499SAndrei Emeltchenko 60142c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 6022177bab5SJohan Hedberg { 6034ca048e3SMarcel Holtmann struct hci_dev *hdev = req->hdev; 6044ca048e3SMarcel Holtmann 6052177bab5SJohan Hedberg __le16 param; 6062177bab5SJohan Hedberg __u8 flt_type; 6072177bab5SJohan Hedberg 6082177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 60942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 6102177bab5SJohan Hedberg 6112177bab5SJohan Hedberg /* Read Class of Device */ 61242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 6132177bab5SJohan Hedberg 6142177bab5SJohan Hedberg /* Read Local Name */ 61542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 6162177bab5SJohan Hedberg 6172177bab5SJohan Hedberg /* Read Voice Setting */ 61842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 6192177bab5SJohan Hedberg 620b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 621b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 622b4cb9fb2SMarcel Holtmann 6234b836f39SMarcel Holtmann /* Read Current IAC LAP */ 6244b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 6254b836f39SMarcel Holtmann 6262177bab5SJohan Hedberg /* Clear Event Filters */ 6272177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 62842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 6292177bab5SJohan Hedberg 6302177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 6312177bab5SJohan Hedberg param = __constant_cpu_to_le16(0x7d00); 63242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 6332177bab5SJohan Hedberg 6344ca048e3SMarcel Holtmann /* AVM Berlin (31), aka "BlueFRITZ!", reports version 1.2, 6354ca048e3SMarcel Holtmann * but it does not support page scan related HCI commands. 6364ca048e3SMarcel Holtmann */ 6374ca048e3SMarcel Holtmann if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) { 638f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 639f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 640f332ec66SJohan Hedberg } 6412177bab5SJohan Hedberg } 6422177bab5SJohan Hedberg 64342c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 6442177bab5SJohan Hedberg { 645c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 646c73eee91SJohan Hedberg 6472177bab5SJohan Hedberg /* Read LE Buffer Size */ 64842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 6492177bab5SJohan Hedberg 6502177bab5SJohan Hedberg /* Read LE Local Supported Features */ 65142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 6522177bab5SJohan Hedberg 6532177bab5SJohan Hedberg /* Read LE Advertising Channel TX Power */ 65442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 6552177bab5SJohan Hedberg 6562177bab5SJohan Hedberg /* Read LE White List Size */ 65742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 0, NULL); 6582177bab5SJohan Hedberg 6592177bab5SJohan Hedberg /* Read LE Supported States */ 66042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 661c73eee91SJohan Hedberg 662c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 663c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 664c73eee91SJohan Hedberg set_bit(HCI_LE_ENABLED, &hdev->dev_flags); 6652177bab5SJohan Hedberg } 6662177bab5SJohan Hedberg 6672177bab5SJohan Hedberg static u8 hci_get_inquiry_mode(struct hci_dev *hdev) 6682177bab5SJohan Hedberg { 6692177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 6702177bab5SJohan Hedberg return 0x02; 6712177bab5SJohan Hedberg 6722177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 6732177bab5SJohan Hedberg return 0x01; 6742177bab5SJohan Hedberg 6752177bab5SJohan Hedberg if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 && 6762177bab5SJohan Hedberg hdev->lmp_subver == 0x0757) 6772177bab5SJohan Hedberg return 0x01; 6782177bab5SJohan Hedberg 6792177bab5SJohan Hedberg if (hdev->manufacturer == 15) { 6802177bab5SJohan Hedberg if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963) 6812177bab5SJohan Hedberg return 0x01; 6822177bab5SJohan Hedberg if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963) 6832177bab5SJohan Hedberg return 0x01; 6842177bab5SJohan Hedberg if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965) 6852177bab5SJohan Hedberg return 0x01; 6862177bab5SJohan Hedberg } 6872177bab5SJohan Hedberg 6882177bab5SJohan Hedberg if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 && 6892177bab5SJohan Hedberg hdev->lmp_subver == 0x1805) 6902177bab5SJohan Hedberg return 0x01; 6912177bab5SJohan Hedberg 6922177bab5SJohan Hedberg return 0x00; 6932177bab5SJohan Hedberg } 6942177bab5SJohan Hedberg 69542c6b129SJohan Hedberg static void hci_setup_inquiry_mode(struct hci_request *req) 6962177bab5SJohan Hedberg { 6972177bab5SJohan Hedberg u8 mode; 6982177bab5SJohan Hedberg 69942c6b129SJohan Hedberg mode = hci_get_inquiry_mode(req->hdev); 7002177bab5SJohan Hedberg 70142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 7022177bab5SJohan Hedberg } 7032177bab5SJohan Hedberg 70442c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 7052177bab5SJohan Hedberg { 70642c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 70742c6b129SJohan Hedberg 7082177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 7092177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 7102177bab5SJohan Hedberg * command otherwise. 7112177bab5SJohan Hedberg */ 7122177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 7132177bab5SJohan Hedberg 7142177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 7152177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 7162177bab5SJohan Hedberg */ 7172177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 7182177bab5SJohan Hedberg return; 7192177bab5SJohan Hedberg 7202177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 7212177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 7222177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 7232177bab5SJohan Hedberg events[4] |= 0x04; /* Read Remote Extended Features Complete */ 7242177bab5SJohan Hedberg events[5] |= 0x08; /* Synchronous Connection Complete */ 7252177bab5SJohan Hedberg events[5] |= 0x10; /* Synchronous Connection Changed */ 726c7882cbdSMarcel Holtmann } else { 727c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 728c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 729c7882cbdSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 730c7882cbdSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 731c7882cbdSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information Complete */ 732c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 733c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 734c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 735c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 736c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 737c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 7382177bab5SJohan Hedberg } 7392177bab5SJohan Hedberg 7402177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 7412177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 7422177bab5SJohan Hedberg 7432177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 7442177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 7452177bab5SJohan Hedberg 7462177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 7472177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 7482177bab5SJohan Hedberg 7492177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 7502177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 7512177bab5SJohan Hedberg 7522177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 7532177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 7542177bab5SJohan Hedberg 7552177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 7562177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 7572177bab5SJohan Hedberg 7582177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 7592177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 7602177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 7612177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 7622177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 7632177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 7642177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 7652177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 7662177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 7672177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 7682177bab5SJohan Hedberg * Features Notification 7692177bab5SJohan Hedberg */ 7702177bab5SJohan Hedberg } 7712177bab5SJohan Hedberg 7722177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 7732177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 7742177bab5SJohan Hedberg 77542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 7762177bab5SJohan Hedberg 7772177bab5SJohan Hedberg if (lmp_le_capable(hdev)) { 7782177bab5SJohan Hedberg memset(events, 0, sizeof(events)); 7792177bab5SJohan Hedberg events[0] = 0x1f; 78042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, 7812177bab5SJohan Hedberg sizeof(events), events); 7822177bab5SJohan Hedberg } 7832177bab5SJohan Hedberg } 7842177bab5SJohan Hedberg 78542c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 7862177bab5SJohan Hedberg { 78742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 78842c6b129SJohan Hedberg 7892177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 79042c6b129SJohan Hedberg bredr_setup(req); 79156f87901SJohan Hedberg else 79256f87901SJohan Hedberg clear_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 7932177bab5SJohan Hedberg 7942177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 79542c6b129SJohan Hedberg le_setup(req); 7962177bab5SJohan Hedberg 79742c6b129SJohan Hedberg hci_setup_event_mask(req); 7982177bab5SJohan Hedberg 7993f8e2d75SJohan Hedberg /* AVM Berlin (31), aka "BlueFRITZ!", doesn't support the read 8003f8e2d75SJohan Hedberg * local supported commands HCI command. 8013f8e2d75SJohan Hedberg */ 8023f8e2d75SJohan Hedberg if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) 80342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 8042177bab5SJohan Hedberg 8052177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 8062177bab5SJohan Hedberg if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) { 8072177bab5SJohan Hedberg u8 mode = 0x01; 80842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 8092177bab5SJohan Hedberg sizeof(mode), &mode); 8102177bab5SJohan Hedberg } else { 8112177bab5SJohan Hedberg struct hci_cp_write_eir cp; 8122177bab5SJohan Hedberg 8132177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 8142177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 8152177bab5SJohan Hedberg 81642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 8172177bab5SJohan Hedberg } 8182177bab5SJohan Hedberg } 8192177bab5SJohan Hedberg 8202177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 82142c6b129SJohan Hedberg hci_setup_inquiry_mode(req); 8222177bab5SJohan Hedberg 8232177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 82442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 8252177bab5SJohan Hedberg 8262177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 8272177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 8282177bab5SJohan Hedberg 8292177bab5SJohan Hedberg cp.page = 0x01; 83042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 83142c6b129SJohan Hedberg sizeof(cp), &cp); 8322177bab5SJohan Hedberg } 8332177bab5SJohan Hedberg 8342177bab5SJohan Hedberg if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) { 8352177bab5SJohan Hedberg u8 enable = 1; 83642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 8372177bab5SJohan Hedberg &enable); 8382177bab5SJohan Hedberg } 8392177bab5SJohan Hedberg } 8402177bab5SJohan Hedberg 84142c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 8422177bab5SJohan Hedberg { 84342c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 8442177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 8452177bab5SJohan Hedberg u16 link_policy = 0; 8462177bab5SJohan Hedberg 8472177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 8482177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 8492177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 8502177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 8512177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 8522177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 8532177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 8542177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 8552177bab5SJohan Hedberg 8562177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 85742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 8582177bab5SJohan Hedberg } 8592177bab5SJohan Hedberg 86042c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 8612177bab5SJohan Hedberg { 86242c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 8632177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 8642177bab5SJohan Hedberg 865c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 866c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 867c73eee91SJohan Hedberg return; 868c73eee91SJohan Hedberg 8692177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 8702177bab5SJohan Hedberg 8712177bab5SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) { 8722177bab5SJohan Hedberg cp.le = 0x01; 8732177bab5SJohan Hedberg cp.simul = lmp_le_br_capable(hdev); 8742177bab5SJohan Hedberg } 8752177bab5SJohan Hedberg 8762177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 87742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 8782177bab5SJohan Hedberg &cp); 8792177bab5SJohan Hedberg } 8802177bab5SJohan Hedberg 881d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 882d62e6d67SJohan Hedberg { 883d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 884d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 885d62e6d67SJohan Hedberg 886d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 887d62e6d67SJohan Hedberg * enable all necessary events for it. 888d62e6d67SJohan Hedberg */ 889d62e6d67SJohan Hedberg if (hdev->features[2][0] & 0x01) { 890d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 891d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 892d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 893d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 894d62e6d67SJohan Hedberg } 895d62e6d67SJohan Hedberg 896d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 897d62e6d67SJohan Hedberg * enable all necessary events for it. 898d62e6d67SJohan Hedberg */ 899d62e6d67SJohan Hedberg if (hdev->features[2][0] & 0x02) { 900d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 901d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 902d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 903d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 904d62e6d67SJohan Hedberg } 905d62e6d67SJohan Hedberg 906d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 907d62e6d67SJohan Hedberg } 908d62e6d67SJohan Hedberg 90942c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 9102177bab5SJohan Hedberg { 91142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 912d2c5d77fSJohan Hedberg u8 p; 91342c6b129SJohan Hedberg 914b8f4e068SGustavo Padovan /* Some Broadcom based Bluetooth controllers do not support the 915b8f4e068SGustavo Padovan * Delete Stored Link Key command. They are clearly indicating its 916b8f4e068SGustavo Padovan * absence in the bit mask of supported commands. 917b8f4e068SGustavo Padovan * 918b8f4e068SGustavo Padovan * Check the supported commands and only if the the command is marked 919b8f4e068SGustavo Padovan * as supported send it. If not supported assume that the controller 920b8f4e068SGustavo Padovan * does not have actual support for stored link keys which makes this 921b8f4e068SGustavo Padovan * command redundant anyway. 922b8f4e068SGustavo Padovan */ 92359f45d57SJohan Hedberg if (hdev->commands[6] & 0x80) { 92459f45d57SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 92559f45d57SJohan Hedberg 92659f45d57SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 92759f45d57SJohan Hedberg cp.delete_all = 0x01; 92859f45d57SJohan Hedberg hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 92959f45d57SJohan Hedberg sizeof(cp), &cp); 93059f45d57SJohan Hedberg } 93159f45d57SJohan Hedberg 9322177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 93342c6b129SJohan Hedberg hci_setup_link_policy(req); 9342177bab5SJohan Hedberg 935441ad2d0SMarcel Holtmann if (lmp_le_capable(hdev)) 93642c6b129SJohan Hedberg hci_set_le_support(req); 937d2c5d77fSJohan Hedberg 938d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 939d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 940d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 941d2c5d77fSJohan Hedberg 942d2c5d77fSJohan Hedberg cp.page = p; 943d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 944d2c5d77fSJohan Hedberg sizeof(cp), &cp); 945d2c5d77fSJohan Hedberg } 9462177bab5SJohan Hedberg } 9472177bab5SJohan Hedberg 9485d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 9495d4e7e8dSJohan Hedberg { 9505d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 9515d4e7e8dSJohan Hedberg 952d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 953d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 954d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 955d62e6d67SJohan Hedberg 9565d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 9575d4e7e8dSJohan Hedberg if (hdev->features[2][0] & 0x04) 9585d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 9595d4e7e8dSJohan Hedberg } 9605d4e7e8dSJohan Hedberg 9612177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 9622177bab5SJohan Hedberg { 9632177bab5SJohan Hedberg int err; 9642177bab5SJohan Hedberg 9652177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 9662177bab5SJohan Hedberg if (err < 0) 9672177bab5SJohan Hedberg return err; 9682177bab5SJohan Hedberg 9692177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 9702177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 9712177bab5SJohan Hedberg * first stage init. 9722177bab5SJohan Hedberg */ 9732177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 9742177bab5SJohan Hedberg return 0; 9752177bab5SJohan Hedberg 9762177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 9772177bab5SJohan Hedberg if (err < 0) 9782177bab5SJohan Hedberg return err; 9792177bab5SJohan Hedberg 9805d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 9815d4e7e8dSJohan Hedberg if (err < 0) 9825d4e7e8dSJohan Hedberg return err; 9835d4e7e8dSJohan Hedberg 984baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 985baf27f6eSMarcel Holtmann if (err < 0) 986baf27f6eSMarcel Holtmann return err; 987baf27f6eSMarcel Holtmann 988baf27f6eSMarcel Holtmann /* Only create debugfs entries during the initial setup 989baf27f6eSMarcel Holtmann * phase and not every time the controller gets powered on. 990baf27f6eSMarcel Holtmann */ 991baf27f6eSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 992baf27f6eSMarcel Holtmann return 0; 993baf27f6eSMarcel Holtmann 99470afe0b8SMarcel Holtmann debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev, 99570afe0b8SMarcel Holtmann &blacklist_fops); 99670afe0b8SMarcel Holtmann 99747219839SMarcel Holtmann debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 99847219839SMarcel Holtmann 999baf27f6eSMarcel Holtmann if (lmp_bredr_capable(hdev)) { 1000baf27f6eSMarcel Holtmann debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, 1001baf27f6eSMarcel Holtmann hdev, &inquiry_cache_fops); 1002041000b9SMarcel Holtmann debugfs_create_file("voice_setting", 0444, hdev->debugfs, 1003041000b9SMarcel Holtmann hdev, &voice_setting_fops); 1004baf27f6eSMarcel Holtmann } 1005baf27f6eSMarcel Holtmann 1006ebd1e33bSMarcel Holtmann if (lmp_ssp_capable(hdev)) 1007ebd1e33bSMarcel Holtmann debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 1008ebd1e33bSMarcel Holtmann hdev, &auto_accept_delay_fops); 1009ebd1e33bSMarcel Holtmann 10102bfa3531SMarcel Holtmann if (lmp_sniff_capable(hdev)) { 10112bfa3531SMarcel Holtmann debugfs_create_file("idle_timeout", 0644, hdev->debugfs, 10122bfa3531SMarcel Holtmann hdev, &idle_timeout_fops); 10132bfa3531SMarcel Holtmann debugfs_create_file("sniff_min_interval", 0644, hdev->debugfs, 10142bfa3531SMarcel Holtmann hdev, &sniff_min_interval_fops); 10152bfa3531SMarcel Holtmann debugfs_create_file("sniff_max_interval", 0644, hdev->debugfs, 10162bfa3531SMarcel Holtmann hdev, &sniff_max_interval_fops); 10172bfa3531SMarcel Holtmann } 10182bfa3531SMarcel Holtmann 1019e7b8fc92SMarcel Holtmann if (lmp_le_capable(hdev)) 1020e7b8fc92SMarcel Holtmann debugfs_create_file("static_address", 0444, hdev->debugfs, 1021e7b8fc92SMarcel Holtmann hdev, &static_address_fops); 1022e7b8fc92SMarcel Holtmann 1023baf27f6eSMarcel Holtmann return 0; 10242177bab5SJohan Hedberg } 10252177bab5SJohan Hedberg 102642c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 10271da177e4SLinus Torvalds { 10281da177e4SLinus Torvalds __u8 scan = opt; 10291da177e4SLinus Torvalds 103042c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 10311da177e4SLinus Torvalds 10321da177e4SLinus Torvalds /* Inquiry and Page scans */ 103342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 10341da177e4SLinus Torvalds } 10351da177e4SLinus Torvalds 103642c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 10371da177e4SLinus Torvalds { 10381da177e4SLinus Torvalds __u8 auth = opt; 10391da177e4SLinus Torvalds 104042c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 10411da177e4SLinus Torvalds 10421da177e4SLinus Torvalds /* Authentication */ 104342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 10441da177e4SLinus Torvalds } 10451da177e4SLinus Torvalds 104642c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 10471da177e4SLinus Torvalds { 10481da177e4SLinus Torvalds __u8 encrypt = opt; 10491da177e4SLinus Torvalds 105042c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 10511da177e4SLinus Torvalds 1052e4e8e37cSMarcel Holtmann /* Encryption */ 105342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 10541da177e4SLinus Torvalds } 10551da177e4SLinus Torvalds 105642c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1057e4e8e37cSMarcel Holtmann { 1058e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1059e4e8e37cSMarcel Holtmann 106042c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1061e4e8e37cSMarcel Holtmann 1062e4e8e37cSMarcel Holtmann /* Default link policy */ 106342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1064e4e8e37cSMarcel Holtmann } 1065e4e8e37cSMarcel Holtmann 10661da177e4SLinus Torvalds /* Get HCI device by index. 10671da177e4SLinus Torvalds * Device is held on return. */ 10681da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 10691da177e4SLinus Torvalds { 10708035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 10711da177e4SLinus Torvalds 10721da177e4SLinus Torvalds BT_DBG("%d", index); 10731da177e4SLinus Torvalds 10741da177e4SLinus Torvalds if (index < 0) 10751da177e4SLinus Torvalds return NULL; 10761da177e4SLinus Torvalds 10771da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 10788035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 10791da177e4SLinus Torvalds if (d->id == index) { 10801da177e4SLinus Torvalds hdev = hci_dev_hold(d); 10811da177e4SLinus Torvalds break; 10821da177e4SLinus Torvalds } 10831da177e4SLinus Torvalds } 10841da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 10851da177e4SLinus Torvalds return hdev; 10861da177e4SLinus Torvalds } 10871da177e4SLinus Torvalds 10881da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1089ff9ef578SJohan Hedberg 109030dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 109130dc78e1SJohan Hedberg { 109230dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 109330dc78e1SJohan Hedberg 10946fbe195dSAndre Guedes switch (discov->state) { 1095343f935bSAndre Guedes case DISCOVERY_FINDING: 10966fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 109730dc78e1SJohan Hedberg return true; 109830dc78e1SJohan Hedberg 10996fbe195dSAndre Guedes default: 110030dc78e1SJohan Hedberg return false; 110130dc78e1SJohan Hedberg } 11026fbe195dSAndre Guedes } 110330dc78e1SJohan Hedberg 1104ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1105ff9ef578SJohan Hedberg { 1106ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1107ff9ef578SJohan Hedberg 1108ff9ef578SJohan Hedberg if (hdev->discovery.state == state) 1109ff9ef578SJohan Hedberg return; 1110ff9ef578SJohan Hedberg 1111ff9ef578SJohan Hedberg switch (state) { 1112ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 11137b99b659SAndre Guedes if (hdev->discovery.state != DISCOVERY_STARTING) 1114ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1115ff9ef578SJohan Hedberg break; 1116ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1117ff9ef578SJohan Hedberg break; 1118343f935bSAndre Guedes case DISCOVERY_FINDING: 1119ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1120ff9ef578SJohan Hedberg break; 112130dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 112230dc78e1SJohan Hedberg break; 1123ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1124ff9ef578SJohan Hedberg break; 1125ff9ef578SJohan Hedberg } 1126ff9ef578SJohan Hedberg 1127ff9ef578SJohan Hedberg hdev->discovery.state = state; 1128ff9ef578SJohan Hedberg } 1129ff9ef578SJohan Hedberg 11301f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 11311da177e4SLinus Torvalds { 113230883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1133b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 11341da177e4SLinus Torvalds 1135561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1136561aafbcSJohan Hedberg list_del(&p->all); 1137b57c1a56SJohan Hedberg kfree(p); 11381da177e4SLinus Torvalds } 1139561aafbcSJohan Hedberg 1140561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1141561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 11421da177e4SLinus Torvalds } 11431da177e4SLinus Torvalds 1144a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1145a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 11461da177e4SLinus Torvalds { 114730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 11481da177e4SLinus Torvalds struct inquiry_entry *e; 11491da177e4SLinus Torvalds 11506ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 11511da177e4SLinus Torvalds 1152561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 11531da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 11541da177e4SLinus Torvalds return e; 11551da177e4SLinus Torvalds } 11561da177e4SLinus Torvalds 1157b57c1a56SJohan Hedberg return NULL; 1158b57c1a56SJohan Hedberg } 1159b57c1a56SJohan Hedberg 1160561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1161561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1162561aafbcSJohan Hedberg { 116330883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1164561aafbcSJohan Hedberg struct inquiry_entry *e; 1165561aafbcSJohan Hedberg 11666ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1167561aafbcSJohan Hedberg 1168561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1169561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1170561aafbcSJohan Hedberg return e; 1171561aafbcSJohan Hedberg } 1172561aafbcSJohan Hedberg 1173561aafbcSJohan Hedberg return NULL; 1174561aafbcSJohan Hedberg } 1175561aafbcSJohan Hedberg 117630dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 117730dc78e1SJohan Hedberg bdaddr_t *bdaddr, 117830dc78e1SJohan Hedberg int state) 117930dc78e1SJohan Hedberg { 118030dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 118130dc78e1SJohan Hedberg struct inquiry_entry *e; 118230dc78e1SJohan Hedberg 11836ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 118430dc78e1SJohan Hedberg 118530dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 118630dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 118730dc78e1SJohan Hedberg return e; 118830dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 118930dc78e1SJohan Hedberg return e; 119030dc78e1SJohan Hedberg } 119130dc78e1SJohan Hedberg 119230dc78e1SJohan Hedberg return NULL; 119330dc78e1SJohan Hedberg } 119430dc78e1SJohan Hedberg 1195a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1196a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1197a3d4e20aSJohan Hedberg { 1198a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1199a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1200a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1201a3d4e20aSJohan Hedberg 1202a3d4e20aSJohan Hedberg list_del(&ie->list); 1203a3d4e20aSJohan Hedberg 1204a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1205a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1206a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1207a3d4e20aSJohan Hedberg break; 1208a3d4e20aSJohan Hedberg pos = &p->list; 1209a3d4e20aSJohan Hedberg } 1210a3d4e20aSJohan Hedberg 1211a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1212a3d4e20aSJohan Hedberg } 1213a3d4e20aSJohan Hedberg 12143175405bSJohan Hedberg bool hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1215388fc8faSJohan Hedberg bool name_known, bool *ssp) 12161da177e4SLinus Torvalds { 121730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 121870f23020SAndrei Emeltchenko struct inquiry_entry *ie; 12191da177e4SLinus Torvalds 12206ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 12211da177e4SLinus Torvalds 12222b2fec4dSSzymon Janc hci_remove_remote_oob_data(hdev, &data->bdaddr); 12232b2fec4dSSzymon Janc 1224388fc8faSJohan Hedberg if (ssp) 1225388fc8faSJohan Hedberg *ssp = data->ssp_mode; 1226388fc8faSJohan Hedberg 122770f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1228a3d4e20aSJohan Hedberg if (ie) { 1229388fc8faSJohan Hedberg if (ie->data.ssp_mode && ssp) 1230388fc8faSJohan Hedberg *ssp = true; 1231388fc8faSJohan Hedberg 1232a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1233a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1234a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1235a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1236a3d4e20aSJohan Hedberg } 1237a3d4e20aSJohan Hedberg 1238561aafbcSJohan Hedberg goto update; 1239a3d4e20aSJohan Hedberg } 1240561aafbcSJohan Hedberg 12411da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 124270f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 124370f23020SAndrei Emeltchenko if (!ie) 12443175405bSJohan Hedberg return false; 124570f23020SAndrei Emeltchenko 1246561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1247561aafbcSJohan Hedberg 1248561aafbcSJohan Hedberg if (name_known) { 1249561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1250561aafbcSJohan Hedberg } else { 1251561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1252561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1253561aafbcSJohan Hedberg } 1254561aafbcSJohan Hedberg 1255561aafbcSJohan Hedberg update: 1256561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1257561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1258561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1259561aafbcSJohan Hedberg list_del(&ie->list); 12601da177e4SLinus Torvalds } 12611da177e4SLinus Torvalds 126270f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 126370f23020SAndrei Emeltchenko ie->timestamp = jiffies; 12641da177e4SLinus Torvalds cache->timestamp = jiffies; 12653175405bSJohan Hedberg 12663175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 12673175405bSJohan Hedberg return false; 12683175405bSJohan Hedberg 12693175405bSJohan Hedberg return true; 12701da177e4SLinus Torvalds } 12711da177e4SLinus Torvalds 12721da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 12731da177e4SLinus Torvalds { 127430883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 12751da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 12761da177e4SLinus Torvalds struct inquiry_entry *e; 12771da177e4SLinus Torvalds int copied = 0; 12781da177e4SLinus Torvalds 1279561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 12801da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1281b57c1a56SJohan Hedberg 1282b57c1a56SJohan Hedberg if (copied >= num) 1283b57c1a56SJohan Hedberg break; 1284b57c1a56SJohan Hedberg 12851da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 12861da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 12871da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 12881da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 12891da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 12901da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1291b57c1a56SJohan Hedberg 12921da177e4SLinus Torvalds info++; 1293b57c1a56SJohan Hedberg copied++; 12941da177e4SLinus Torvalds } 12951da177e4SLinus Torvalds 12961da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 12971da177e4SLinus Torvalds return copied; 12981da177e4SLinus Torvalds } 12991da177e4SLinus Torvalds 130042c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 13011da177e4SLinus Torvalds { 13021da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 130342c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 13041da177e4SLinus Torvalds struct hci_cp_inquiry cp; 13051da177e4SLinus Torvalds 13061da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 13071da177e4SLinus Torvalds 13081da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 13091da177e4SLinus Torvalds return; 13101da177e4SLinus Torvalds 13111da177e4SLinus Torvalds /* Start Inquiry */ 13121da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 13131da177e4SLinus Torvalds cp.length = ir->length; 13141da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 131542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 13161da177e4SLinus Torvalds } 13171da177e4SLinus Torvalds 13183e13fa1eSAndre Guedes static int wait_inquiry(void *word) 13193e13fa1eSAndre Guedes { 13203e13fa1eSAndre Guedes schedule(); 13213e13fa1eSAndre Guedes return signal_pending(current); 13223e13fa1eSAndre Guedes } 13233e13fa1eSAndre Guedes 13241da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 13251da177e4SLinus Torvalds { 13261da177e4SLinus Torvalds __u8 __user *ptr = arg; 13271da177e4SLinus Torvalds struct hci_inquiry_req ir; 13281da177e4SLinus Torvalds struct hci_dev *hdev; 13291da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 13301da177e4SLinus Torvalds long timeo; 13311da177e4SLinus Torvalds __u8 *buf; 13321da177e4SLinus Torvalds 13331da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 13341da177e4SLinus Torvalds return -EFAULT; 13351da177e4SLinus Torvalds 13365a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 13375a08ecceSAndrei Emeltchenko if (!hdev) 13381da177e4SLinus Torvalds return -ENODEV; 13391da177e4SLinus Torvalds 13400736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 13410736cfa8SMarcel Holtmann err = -EBUSY; 13420736cfa8SMarcel Holtmann goto done; 13430736cfa8SMarcel Holtmann } 13440736cfa8SMarcel Holtmann 13455b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 13465b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 13475b69bef5SMarcel Holtmann goto done; 13485b69bef5SMarcel Holtmann } 13495b69bef5SMarcel Holtmann 135056f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 135156f87901SJohan Hedberg err = -EOPNOTSUPP; 135256f87901SJohan Hedberg goto done; 135356f87901SJohan Hedberg } 135456f87901SJohan Hedberg 135509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13561da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1357a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 13581f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 13591da177e4SLinus Torvalds do_inquiry = 1; 13601da177e4SLinus Torvalds } 136109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13621da177e4SLinus Torvalds 136304837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 136470f23020SAndrei Emeltchenko 136570f23020SAndrei Emeltchenko if (do_inquiry) { 136601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 136701178cd4SJohan Hedberg timeo); 136870f23020SAndrei Emeltchenko if (err < 0) 13691da177e4SLinus Torvalds goto done; 13703e13fa1eSAndre Guedes 13713e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 13723e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 13733e13fa1eSAndre Guedes */ 13743e13fa1eSAndre Guedes if (wait_on_bit(&hdev->flags, HCI_INQUIRY, wait_inquiry, 13753e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 13763e13fa1eSAndre Guedes return -EINTR; 137770f23020SAndrei Emeltchenko } 13781da177e4SLinus Torvalds 13798fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 13808fc9ced3SGustavo Padovan * 255 entries 13818fc9ced3SGustavo Padovan */ 13821da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 13831da177e4SLinus Torvalds 13841da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 13851da177e4SLinus Torvalds * copy it to the user space. 13861da177e4SLinus Torvalds */ 138770f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 138870f23020SAndrei Emeltchenko if (!buf) { 13891da177e4SLinus Torvalds err = -ENOMEM; 13901da177e4SLinus Torvalds goto done; 13911da177e4SLinus Torvalds } 13921da177e4SLinus Torvalds 139309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13941da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 139509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13961da177e4SLinus Torvalds 13971da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 13981da177e4SLinus Torvalds 13991da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 14001da177e4SLinus Torvalds ptr += sizeof(ir); 14011da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 14021da177e4SLinus Torvalds ir.num_rsp)) 14031da177e4SLinus Torvalds err = -EFAULT; 14041da177e4SLinus Torvalds } else 14051da177e4SLinus Torvalds err = -EFAULT; 14061da177e4SLinus Torvalds 14071da177e4SLinus Torvalds kfree(buf); 14081da177e4SLinus Torvalds 14091da177e4SLinus Torvalds done: 14101da177e4SLinus Torvalds hci_dev_put(hdev); 14111da177e4SLinus Torvalds return err; 14121da177e4SLinus Torvalds } 14131da177e4SLinus Torvalds 1414cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 14151da177e4SLinus Torvalds { 14161da177e4SLinus Torvalds int ret = 0; 14171da177e4SLinus Torvalds 14181da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 14191da177e4SLinus Torvalds 14201da177e4SLinus Torvalds hci_req_lock(hdev); 14211da177e4SLinus Torvalds 142294324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 142394324962SJohan Hovold ret = -ENODEV; 142494324962SJohan Hovold goto done; 142594324962SJohan Hovold } 142694324962SJohan Hovold 1427a5c8f270SMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) { 1428a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1429a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1430bf543036SJohan Hedberg */ 1431a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 1432611b30f7SMarcel Holtmann ret = -ERFKILL; 1433611b30f7SMarcel Holtmann goto done; 1434611b30f7SMarcel Holtmann } 1435611b30f7SMarcel Holtmann 1436a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1437a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1438a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1439a5c8f270SMarcel Holtmann * or not. 1440a5c8f270SMarcel Holtmann * 1441a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1442a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1443a5c8f270SMarcel Holtmann */ 1444a5c8f270SMarcel Holtmann if (hdev->dev_type == HCI_BREDR && 1445a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1446a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1447a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1448a5c8f270SMarcel Holtmann goto done; 1449a5c8f270SMarcel Holtmann } 1450a5c8f270SMarcel Holtmann } 1451a5c8f270SMarcel Holtmann 14521da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 14531da177e4SLinus Torvalds ret = -EALREADY; 14541da177e4SLinus Torvalds goto done; 14551da177e4SLinus Torvalds } 14561da177e4SLinus Torvalds 14571da177e4SLinus Torvalds if (hdev->open(hdev)) { 14581da177e4SLinus Torvalds ret = -EIO; 14591da177e4SLinus Torvalds goto done; 14601da177e4SLinus Torvalds } 14611da177e4SLinus Torvalds 14621da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 14631da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1464f41c70c4SMarcel Holtmann 1465f41c70c4SMarcel Holtmann if (hdev->setup && test_bit(HCI_SETUP, &hdev->dev_flags)) 1466f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1467f41c70c4SMarcel Holtmann 1468f41c70c4SMarcel Holtmann if (!ret) { 1469f41c70c4SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 1470f41c70c4SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 1471f41c70c4SMarcel Holtmann 14720736cfa8SMarcel Holtmann if (!test_bit(HCI_RAW, &hdev->flags) && 14730736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 14742177bab5SJohan Hedberg ret = __hci_init(hdev); 14751da177e4SLinus Torvalds } 14761da177e4SLinus Torvalds 1477f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1478f41c70c4SMarcel Holtmann 14791da177e4SLinus Torvalds if (!ret) { 14801da177e4SLinus Torvalds hci_dev_hold(hdev); 14811da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 14821da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 1483bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 14840736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 14851514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 148609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1487744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 148809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 148956e5cb86SJohan Hedberg } 14901da177e4SLinus Torvalds } else { 14911da177e4SLinus Torvalds /* Init failed, cleanup */ 14923eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1493c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1494b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 14951da177e4SLinus Torvalds 14961da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 14971da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 14981da177e4SLinus Torvalds 14991da177e4SLinus Torvalds if (hdev->flush) 15001da177e4SLinus Torvalds hdev->flush(hdev); 15011da177e4SLinus Torvalds 15021da177e4SLinus Torvalds if (hdev->sent_cmd) { 15031da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 15041da177e4SLinus Torvalds hdev->sent_cmd = NULL; 15051da177e4SLinus Torvalds } 15061da177e4SLinus Torvalds 15071da177e4SLinus Torvalds hdev->close(hdev); 15081da177e4SLinus Torvalds hdev->flags = 0; 15091da177e4SLinus Torvalds } 15101da177e4SLinus Torvalds 15111da177e4SLinus Torvalds done: 15121da177e4SLinus Torvalds hci_req_unlock(hdev); 15131da177e4SLinus Torvalds return ret; 15141da177e4SLinus Torvalds } 15151da177e4SLinus Torvalds 1516cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1517cbed0ca1SJohan Hedberg 1518cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1519cbed0ca1SJohan Hedberg { 1520cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1521cbed0ca1SJohan Hedberg int err; 1522cbed0ca1SJohan Hedberg 1523cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1524cbed0ca1SJohan Hedberg if (!hdev) 1525cbed0ca1SJohan Hedberg return -ENODEV; 1526cbed0ca1SJohan Hedberg 1527e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1528e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1529e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1530e1d08f40SJohan Hedberg * completed. 1531e1d08f40SJohan Hedberg */ 1532e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 1533e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1534e1d08f40SJohan Hedberg 1535a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1536a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1537a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1538a5c8f270SMarcel Holtmann */ 1539e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1540e1d08f40SJohan Hedberg 1541cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1542cbed0ca1SJohan Hedberg 1543cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1544cbed0ca1SJohan Hedberg 1545cbed0ca1SJohan Hedberg return err; 1546cbed0ca1SJohan Hedberg } 1547cbed0ca1SJohan Hedberg 15481da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 15491da177e4SLinus Torvalds { 15501da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 15511da177e4SLinus Torvalds 155278c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 155378c04c0bSVinicius Costa Gomes 15541da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 15551da177e4SLinus Torvalds hci_req_lock(hdev); 15561da177e4SLinus Torvalds 15571da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 1558b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 15591da177e4SLinus Torvalds hci_req_unlock(hdev); 15601da177e4SLinus Torvalds return 0; 15611da177e4SLinus Torvalds } 15621da177e4SLinus Torvalds 15633eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 15643eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1565b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 15661da177e4SLinus Torvalds 156716ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 1568e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 156916ab91abSJohan Hedberg hdev->discov_timeout = 0; 15705e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 1571310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 157216ab91abSJohan Hedberg } 157316ab91abSJohan Hedberg 1574a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 15757d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 15767d78525dSJohan Hedberg 15777ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 15787ba8b4beSAndre Guedes 157909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 15801f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 15811da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 158209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 15831da177e4SLinus Torvalds 15841da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 15851da177e4SLinus Torvalds 15861da177e4SLinus Torvalds if (hdev->flush) 15871da177e4SLinus Torvalds hdev->flush(hdev); 15881da177e4SLinus Torvalds 15891da177e4SLinus Torvalds /* Reset device */ 15901da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 15911da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 15928af59467SJohan Hedberg if (!test_bit(HCI_RAW, &hdev->flags) && 15933a6afbd2SMarcel Holtmann !test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 1594a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 15951da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 159601178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 15971da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 15981da177e4SLinus Torvalds } 15991da177e4SLinus Torvalds 1600c347b765SGustavo F. Padovan /* flush cmd work */ 1601c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 16021da177e4SLinus Torvalds 16031da177e4SLinus Torvalds /* Drop queues */ 16041da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 16051da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16061da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 16071da177e4SLinus Torvalds 16081da177e4SLinus Torvalds /* Drop last sent command */ 16091da177e4SLinus Torvalds if (hdev->sent_cmd) { 1610b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 16111da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 16121da177e4SLinus Torvalds hdev->sent_cmd = NULL; 16131da177e4SLinus Torvalds } 16141da177e4SLinus Torvalds 1615b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 1616b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 1617b6ddb638SJohan Hedberg 16181da177e4SLinus Torvalds /* After this point our queues are empty 16191da177e4SLinus Torvalds * and no tasks are scheduled. */ 16201da177e4SLinus Torvalds hdev->close(hdev); 16211da177e4SLinus Torvalds 162235b973c9SJohan Hedberg /* Clear flags */ 162335b973c9SJohan Hedberg hdev->flags = 0; 162435b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 162535b973c9SJohan Hedberg 162693c311a0SMarcel Holtmann if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 162793c311a0SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 162809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1629744cf19eSJohan Hedberg mgmt_powered(hdev, 0); 163009fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 16318ee56540SMarcel Holtmann } 163293c311a0SMarcel Holtmann } 16335add6af8SJohan Hedberg 1634ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1635536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1636ced5c338SAndrei Emeltchenko 1637e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 163809b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 1639e59fda8dSJohan Hedberg 16401da177e4SLinus Torvalds hci_req_unlock(hdev); 16411da177e4SLinus Torvalds 16421da177e4SLinus Torvalds hci_dev_put(hdev); 16431da177e4SLinus Torvalds return 0; 16441da177e4SLinus Torvalds } 16451da177e4SLinus Torvalds 16461da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 16471da177e4SLinus Torvalds { 16481da177e4SLinus Torvalds struct hci_dev *hdev; 16491da177e4SLinus Torvalds int err; 16501da177e4SLinus Torvalds 165170f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 165270f23020SAndrei Emeltchenko if (!hdev) 16531da177e4SLinus Torvalds return -ENODEV; 16548ee56540SMarcel Holtmann 16550736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 16560736cfa8SMarcel Holtmann err = -EBUSY; 16570736cfa8SMarcel Holtmann goto done; 16580736cfa8SMarcel Holtmann } 16590736cfa8SMarcel Holtmann 16608ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 16618ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 16628ee56540SMarcel Holtmann 16631da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 16648ee56540SMarcel Holtmann 16650736cfa8SMarcel Holtmann done: 16661da177e4SLinus Torvalds hci_dev_put(hdev); 16671da177e4SLinus Torvalds return err; 16681da177e4SLinus Torvalds } 16691da177e4SLinus Torvalds 16701da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 16711da177e4SLinus Torvalds { 16721da177e4SLinus Torvalds struct hci_dev *hdev; 16731da177e4SLinus Torvalds int ret = 0; 16741da177e4SLinus Torvalds 167570f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 167670f23020SAndrei Emeltchenko if (!hdev) 16771da177e4SLinus Torvalds return -ENODEV; 16781da177e4SLinus Torvalds 16791da177e4SLinus Torvalds hci_req_lock(hdev); 16801da177e4SLinus Torvalds 1681808a049eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 1682808a049eSMarcel Holtmann ret = -ENETDOWN; 16831da177e4SLinus Torvalds goto done; 1684808a049eSMarcel Holtmann } 16851da177e4SLinus Torvalds 16860736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 16870736cfa8SMarcel Holtmann ret = -EBUSY; 16880736cfa8SMarcel Holtmann goto done; 16890736cfa8SMarcel Holtmann } 16900736cfa8SMarcel Holtmann 16911da177e4SLinus Torvalds /* Drop queues */ 16921da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 16931da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16941da177e4SLinus Torvalds 169509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 16961f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 16971da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 169809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 16991da177e4SLinus Torvalds 17001da177e4SLinus Torvalds if (hdev->flush) 17011da177e4SLinus Torvalds hdev->flush(hdev); 17021da177e4SLinus Torvalds 17031da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 17046ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 17051da177e4SLinus Torvalds 17061da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 170701178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 17081da177e4SLinus Torvalds 17091da177e4SLinus Torvalds done: 17101da177e4SLinus Torvalds hci_req_unlock(hdev); 17111da177e4SLinus Torvalds hci_dev_put(hdev); 17121da177e4SLinus Torvalds return ret; 17131da177e4SLinus Torvalds } 17141da177e4SLinus Torvalds 17151da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 17161da177e4SLinus Torvalds { 17171da177e4SLinus Torvalds struct hci_dev *hdev; 17181da177e4SLinus Torvalds int ret = 0; 17191da177e4SLinus Torvalds 172070f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 172170f23020SAndrei Emeltchenko if (!hdev) 17221da177e4SLinus Torvalds return -ENODEV; 17231da177e4SLinus Torvalds 17240736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 17250736cfa8SMarcel Holtmann ret = -EBUSY; 17260736cfa8SMarcel Holtmann goto done; 17270736cfa8SMarcel Holtmann } 17280736cfa8SMarcel Holtmann 17291da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 17301da177e4SLinus Torvalds 17310736cfa8SMarcel Holtmann done: 17321da177e4SLinus Torvalds hci_dev_put(hdev); 17331da177e4SLinus Torvalds return ret; 17341da177e4SLinus Torvalds } 17351da177e4SLinus Torvalds 17361da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 17371da177e4SLinus Torvalds { 17381da177e4SLinus Torvalds struct hci_dev *hdev; 17391da177e4SLinus Torvalds struct hci_dev_req dr; 17401da177e4SLinus Torvalds int err = 0; 17411da177e4SLinus Torvalds 17421da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 17431da177e4SLinus Torvalds return -EFAULT; 17441da177e4SLinus Torvalds 174570f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 174670f23020SAndrei Emeltchenko if (!hdev) 17471da177e4SLinus Torvalds return -ENODEV; 17481da177e4SLinus Torvalds 17490736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 17500736cfa8SMarcel Holtmann err = -EBUSY; 17510736cfa8SMarcel Holtmann goto done; 17520736cfa8SMarcel Holtmann } 17530736cfa8SMarcel Holtmann 17545b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 17555b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 17565b69bef5SMarcel Holtmann goto done; 17575b69bef5SMarcel Holtmann } 17585b69bef5SMarcel Holtmann 175956f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 176056f87901SJohan Hedberg err = -EOPNOTSUPP; 176156f87901SJohan Hedberg goto done; 176256f87901SJohan Hedberg } 176356f87901SJohan Hedberg 17641da177e4SLinus Torvalds switch (cmd) { 17651da177e4SLinus Torvalds case HCISETAUTH: 176601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 17675f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 17681da177e4SLinus Torvalds break; 17691da177e4SLinus Torvalds 17701da177e4SLinus Torvalds case HCISETENCRYPT: 17711da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 17721da177e4SLinus Torvalds err = -EOPNOTSUPP; 17731da177e4SLinus Torvalds break; 17741da177e4SLinus Torvalds } 17751da177e4SLinus Torvalds 17761da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 17771da177e4SLinus Torvalds /* Auth must be enabled first */ 177801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 17795f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 17801da177e4SLinus Torvalds if (err) 17811da177e4SLinus Torvalds break; 17821da177e4SLinus Torvalds } 17831da177e4SLinus Torvalds 178401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 17855f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 17861da177e4SLinus Torvalds break; 17871da177e4SLinus Torvalds 17881da177e4SLinus Torvalds case HCISETSCAN: 178901178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 17905f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 17911da177e4SLinus Torvalds break; 17921da177e4SLinus Torvalds 17931da177e4SLinus Torvalds case HCISETLINKPOL: 179401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 17955f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 17961da177e4SLinus Torvalds break; 17971da177e4SLinus Torvalds 17981da177e4SLinus Torvalds case HCISETLINKMODE: 1799e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 1800e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 1801e4e8e37cSMarcel Holtmann break; 1802e4e8e37cSMarcel Holtmann 1803e4e8e37cSMarcel Holtmann case HCISETPTYPE: 1804e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 18051da177e4SLinus Torvalds break; 18061da177e4SLinus Torvalds 18071da177e4SLinus Torvalds case HCISETACLMTU: 18081da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 18091da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 18101da177e4SLinus Torvalds break; 18111da177e4SLinus Torvalds 18121da177e4SLinus Torvalds case HCISETSCOMTU: 18131da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 18141da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 18151da177e4SLinus Torvalds break; 18161da177e4SLinus Torvalds 18171da177e4SLinus Torvalds default: 18181da177e4SLinus Torvalds err = -EINVAL; 18191da177e4SLinus Torvalds break; 18201da177e4SLinus Torvalds } 1821e4e8e37cSMarcel Holtmann 18220736cfa8SMarcel Holtmann done: 18231da177e4SLinus Torvalds hci_dev_put(hdev); 18241da177e4SLinus Torvalds return err; 18251da177e4SLinus Torvalds } 18261da177e4SLinus Torvalds 18271da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 18281da177e4SLinus Torvalds { 18298035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 18301da177e4SLinus Torvalds struct hci_dev_list_req *dl; 18311da177e4SLinus Torvalds struct hci_dev_req *dr; 18321da177e4SLinus Torvalds int n = 0, size, err; 18331da177e4SLinus Torvalds __u16 dev_num; 18341da177e4SLinus Torvalds 18351da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 18361da177e4SLinus Torvalds return -EFAULT; 18371da177e4SLinus Torvalds 18381da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 18391da177e4SLinus Torvalds return -EINVAL; 18401da177e4SLinus Torvalds 18411da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 18421da177e4SLinus Torvalds 184370f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 184470f23020SAndrei Emeltchenko if (!dl) 18451da177e4SLinus Torvalds return -ENOMEM; 18461da177e4SLinus Torvalds 18471da177e4SLinus Torvalds dr = dl->dev_req; 18481da177e4SLinus Torvalds 1849f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 18508035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 1851a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 1852e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->power_off); 1853c542a06cSJohan Hedberg 1854a8b2d5c2SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 1855a8b2d5c2SJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->dev_flags); 1856c542a06cSJohan Hedberg 18571da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 18581da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 1859c542a06cSJohan Hedberg 18601da177e4SLinus Torvalds if (++n >= dev_num) 18611da177e4SLinus Torvalds break; 18621da177e4SLinus Torvalds } 1863f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 18641da177e4SLinus Torvalds 18651da177e4SLinus Torvalds dl->dev_num = n; 18661da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 18671da177e4SLinus Torvalds 18681da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 18691da177e4SLinus Torvalds kfree(dl); 18701da177e4SLinus Torvalds 18711da177e4SLinus Torvalds return err ? -EFAULT : 0; 18721da177e4SLinus Torvalds } 18731da177e4SLinus Torvalds 18741da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 18751da177e4SLinus Torvalds { 18761da177e4SLinus Torvalds struct hci_dev *hdev; 18771da177e4SLinus Torvalds struct hci_dev_info di; 18781da177e4SLinus Torvalds int err = 0; 18791da177e4SLinus Torvalds 18801da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 18811da177e4SLinus Torvalds return -EFAULT; 18821da177e4SLinus Torvalds 188370f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 188470f23020SAndrei Emeltchenko if (!hdev) 18851da177e4SLinus Torvalds return -ENODEV; 18861da177e4SLinus Torvalds 1887a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 18883243553fSJohan Hedberg cancel_delayed_work_sync(&hdev->power_off); 1889ab81cbf9SJohan Hedberg 1890a8b2d5c2SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 1891a8b2d5c2SJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->dev_flags); 1892c542a06cSJohan Hedberg 18931da177e4SLinus Torvalds strcpy(di.name, hdev->name); 18941da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 189560f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 18961da177e4SLinus Torvalds di.flags = hdev->flags; 18971da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 1898572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 18991da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 19001da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 19011da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 19021da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 1903572c7f84SJohan Hedberg } else { 1904572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 1905572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 1906572c7f84SJohan Hedberg di.sco_mtu = 0; 1907572c7f84SJohan Hedberg di.sco_pkts = 0; 1908572c7f84SJohan Hedberg } 19091da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 19101da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 19111da177e4SLinus Torvalds 19121da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 19131da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 19141da177e4SLinus Torvalds 19151da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 19161da177e4SLinus Torvalds err = -EFAULT; 19171da177e4SLinus Torvalds 19181da177e4SLinus Torvalds hci_dev_put(hdev); 19191da177e4SLinus Torvalds 19201da177e4SLinus Torvalds return err; 19211da177e4SLinus Torvalds } 19221da177e4SLinus Torvalds 19231da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 19241da177e4SLinus Torvalds 1925611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 1926611b30f7SMarcel Holtmann { 1927611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 1928611b30f7SMarcel Holtmann 1929611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 1930611b30f7SMarcel Holtmann 19310736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 19320736cfa8SMarcel Holtmann return -EBUSY; 19330736cfa8SMarcel Holtmann 19345e130367SJohan Hedberg if (blocked) { 19355e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 1936bf543036SJohan Hedberg if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 1937611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 19385e130367SJohan Hedberg } else { 19395e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 19405e130367SJohan Hedberg } 1941611b30f7SMarcel Holtmann 1942611b30f7SMarcel Holtmann return 0; 1943611b30f7SMarcel Holtmann } 1944611b30f7SMarcel Holtmann 1945611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 1946611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 1947611b30f7SMarcel Holtmann }; 1948611b30f7SMarcel Holtmann 1949ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 1950ab81cbf9SJohan Hedberg { 1951ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 195296570ffcSJohan Hedberg int err; 1953ab81cbf9SJohan Hedberg 1954ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 1955ab81cbf9SJohan Hedberg 1956cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 195796570ffcSJohan Hedberg if (err < 0) { 195896570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 1959ab81cbf9SJohan Hedberg return; 196096570ffcSJohan Hedberg } 1961ab81cbf9SJohan Hedberg 1962a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 1963a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 1964a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 1965a5c8f270SMarcel Holtmann */ 1966a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 1967a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 1968a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1969a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 1970bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 1971bf543036SJohan Hedberg hci_dev_do_close(hdev); 1972bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 197319202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 197419202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 1975bf543036SJohan Hedberg } 1976ab81cbf9SJohan Hedberg 1977a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) 1978744cf19eSJohan Hedberg mgmt_index_added(hdev); 1979ab81cbf9SJohan Hedberg } 1980ab81cbf9SJohan Hedberg 1981ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 1982ab81cbf9SJohan Hedberg { 19833243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 19843243553fSJohan Hedberg power_off.work); 1985ab81cbf9SJohan Hedberg 1986ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 1987ab81cbf9SJohan Hedberg 19888ee56540SMarcel Holtmann hci_dev_do_close(hdev); 1989ab81cbf9SJohan Hedberg } 1990ab81cbf9SJohan Hedberg 199116ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 199216ab91abSJohan Hedberg { 199316ab91abSJohan Hedberg struct hci_dev *hdev; 199416ab91abSJohan Hedberg 199516ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 199616ab91abSJohan Hedberg 199716ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 199816ab91abSJohan Hedberg 1999d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 200016ab91abSJohan Hedberg } 200116ab91abSJohan Hedberg 20022aeb9a1aSJohan Hedberg int hci_uuids_clear(struct hci_dev *hdev) 20032aeb9a1aSJohan Hedberg { 20044821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 20052aeb9a1aSJohan Hedberg 20064821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 20074821002cSJohan Hedberg list_del(&uuid->list); 20082aeb9a1aSJohan Hedberg kfree(uuid); 20092aeb9a1aSJohan Hedberg } 20102aeb9a1aSJohan Hedberg 20112aeb9a1aSJohan Hedberg return 0; 20122aeb9a1aSJohan Hedberg } 20132aeb9a1aSJohan Hedberg 201455ed8ca1SJohan Hedberg int hci_link_keys_clear(struct hci_dev *hdev) 201555ed8ca1SJohan Hedberg { 201655ed8ca1SJohan Hedberg struct list_head *p, *n; 201755ed8ca1SJohan Hedberg 201855ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 201955ed8ca1SJohan Hedberg struct link_key *key; 202055ed8ca1SJohan Hedberg 202155ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 202255ed8ca1SJohan Hedberg 202355ed8ca1SJohan Hedberg list_del(p); 202455ed8ca1SJohan Hedberg kfree(key); 202555ed8ca1SJohan Hedberg } 202655ed8ca1SJohan Hedberg 202755ed8ca1SJohan Hedberg return 0; 202855ed8ca1SJohan Hedberg } 202955ed8ca1SJohan Hedberg 2030b899efafSVinicius Costa Gomes int hci_smp_ltks_clear(struct hci_dev *hdev) 2031b899efafSVinicius Costa Gomes { 2032b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 2033b899efafSVinicius Costa Gomes 2034b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 2035b899efafSVinicius Costa Gomes list_del(&k->list); 2036b899efafSVinicius Costa Gomes kfree(k); 2037b899efafSVinicius Costa Gomes } 2038b899efafSVinicius Costa Gomes 2039b899efafSVinicius Costa Gomes return 0; 2040b899efafSVinicius Costa Gomes } 2041b899efafSVinicius Costa Gomes 204255ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 204355ed8ca1SJohan Hedberg { 204455ed8ca1SJohan Hedberg struct link_key *k; 204555ed8ca1SJohan Hedberg 20468035ded4SLuiz Augusto von Dentz list_for_each_entry(k, &hdev->link_keys, list) 204755ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 204855ed8ca1SJohan Hedberg return k; 204955ed8ca1SJohan Hedberg 205055ed8ca1SJohan Hedberg return NULL; 205155ed8ca1SJohan Hedberg } 205255ed8ca1SJohan Hedberg 2053745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2054d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2055d25e28abSJohan Hedberg { 2056d25e28abSJohan Hedberg /* Legacy key */ 2057d25e28abSJohan Hedberg if (key_type < 0x03) 2058745c0ce3SVishal Agarwal return true; 2059d25e28abSJohan Hedberg 2060d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2061d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2062745c0ce3SVishal Agarwal return false; 2063d25e28abSJohan Hedberg 2064d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2065d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2066745c0ce3SVishal Agarwal return false; 2067d25e28abSJohan Hedberg 2068d25e28abSJohan Hedberg /* Security mode 3 case */ 2069d25e28abSJohan Hedberg if (!conn) 2070745c0ce3SVishal Agarwal return true; 2071d25e28abSJohan Hedberg 2072d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2073d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2074745c0ce3SVishal Agarwal return true; 2075d25e28abSJohan Hedberg 2076d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2077d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2078745c0ce3SVishal Agarwal return true; 2079d25e28abSJohan Hedberg 2080d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2081d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2082745c0ce3SVishal Agarwal return true; 2083d25e28abSJohan Hedberg 2084d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2085d25e28abSJohan Hedberg * persistently */ 2086745c0ce3SVishal Agarwal return false; 2087d25e28abSJohan Hedberg } 2088d25e28abSJohan Hedberg 2089c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8]) 209075d262c2SVinicius Costa Gomes { 2091c9839a11SVinicius Costa Gomes struct smp_ltk *k; 209275d262c2SVinicius Costa Gomes 2093c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) { 2094c9839a11SVinicius Costa Gomes if (k->ediv != ediv || 2095c9839a11SVinicius Costa Gomes memcmp(rand, k->rand, sizeof(k->rand))) 209675d262c2SVinicius Costa Gomes continue; 209775d262c2SVinicius Costa Gomes 209875d262c2SVinicius Costa Gomes return k; 209975d262c2SVinicius Costa Gomes } 210075d262c2SVinicius Costa Gomes 210175d262c2SVinicius Costa Gomes return NULL; 210275d262c2SVinicius Costa Gomes } 210375d262c2SVinicius Costa Gomes 2104c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2105c9839a11SVinicius Costa Gomes u8 addr_type) 210675d262c2SVinicius Costa Gomes { 2107c9839a11SVinicius Costa Gomes struct smp_ltk *k; 210875d262c2SVinicius Costa Gomes 2109c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) 2110c9839a11SVinicius Costa Gomes if (addr_type == k->bdaddr_type && 2111c9839a11SVinicius Costa Gomes bacmp(bdaddr, &k->bdaddr) == 0) 211275d262c2SVinicius Costa Gomes return k; 211375d262c2SVinicius Costa Gomes 211475d262c2SVinicius Costa Gomes return NULL; 211575d262c2SVinicius Costa Gomes } 211675d262c2SVinicius Costa Gomes 2117d25e28abSJohan Hedberg int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key, 2118d25e28abSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len) 211955ed8ca1SJohan Hedberg { 212055ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2121745c0ce3SVishal Agarwal u8 old_key_type; 2122745c0ce3SVishal Agarwal bool persistent; 212355ed8ca1SJohan Hedberg 212455ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 212555ed8ca1SJohan Hedberg if (old_key) { 212655ed8ca1SJohan Hedberg old_key_type = old_key->type; 212755ed8ca1SJohan Hedberg key = old_key; 212855ed8ca1SJohan Hedberg } else { 212912adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 213055ed8ca1SJohan Hedberg key = kzalloc(sizeof(*key), GFP_ATOMIC); 213155ed8ca1SJohan Hedberg if (!key) 213255ed8ca1SJohan Hedberg return -ENOMEM; 213355ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 213455ed8ca1SJohan Hedberg } 213555ed8ca1SJohan Hedberg 21366ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 213755ed8ca1SJohan Hedberg 2138d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2139d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2140d25e28abSJohan Hedberg * previous key */ 2141d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2142a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2143d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2144655fe6ecSJohan Hedberg if (conn) 2145655fe6ecSJohan Hedberg conn->key_type = type; 2146655fe6ecSJohan Hedberg } 2147d25e28abSJohan Hedberg 214855ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 21499b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 215055ed8ca1SJohan Hedberg key->pin_len = pin_len; 215155ed8ca1SJohan Hedberg 2152b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 215355ed8ca1SJohan Hedberg key->type = old_key_type; 21544748fed2SJohan Hedberg else 21554748fed2SJohan Hedberg key->type = type; 21564748fed2SJohan Hedberg 21574df378a1SJohan Hedberg if (!new_key) 21584df378a1SJohan Hedberg return 0; 21594df378a1SJohan Hedberg 21604df378a1SJohan Hedberg persistent = hci_persistent_key(hdev, conn, type, old_key_type); 21614df378a1SJohan Hedberg 2162744cf19eSJohan Hedberg mgmt_new_link_key(hdev, key, persistent); 21634df378a1SJohan Hedberg 21646ec5bcadSVishal Agarwal if (conn) 21656ec5bcadSVishal Agarwal conn->flush_key = !persistent; 216655ed8ca1SJohan Hedberg 216755ed8ca1SJohan Hedberg return 0; 216855ed8ca1SJohan Hedberg } 216955ed8ca1SJohan Hedberg 2170c9839a11SVinicius Costa Gomes int hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type, u8 type, 21719a006657SAndrei Emeltchenko int new_key, u8 authenticated, u8 tk[16], u8 enc_size, __le16 217204124681SGustavo F. Padovan ediv, u8 rand[8]) 217375d262c2SVinicius Costa Gomes { 2174c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 217575d262c2SVinicius Costa Gomes 2176c9839a11SVinicius Costa Gomes if (!(type & HCI_SMP_STK) && !(type & HCI_SMP_LTK)) 2177c9839a11SVinicius Costa Gomes return 0; 217875d262c2SVinicius Costa Gomes 2179c9839a11SVinicius Costa Gomes old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type); 2180c9839a11SVinicius Costa Gomes if (old_key) 218175d262c2SVinicius Costa Gomes key = old_key; 2182c9839a11SVinicius Costa Gomes else { 2183c9839a11SVinicius Costa Gomes key = kzalloc(sizeof(*key), GFP_ATOMIC); 218475d262c2SVinicius Costa Gomes if (!key) 218575d262c2SVinicius Costa Gomes return -ENOMEM; 2186c9839a11SVinicius Costa Gomes list_add(&key->list, &hdev->long_term_keys); 218775d262c2SVinicius Costa Gomes } 218875d262c2SVinicius Costa Gomes 218975d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2190c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2191c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2192c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2193c9839a11SVinicius Costa Gomes key->ediv = ediv; 2194c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2195c9839a11SVinicius Costa Gomes key->type = type; 2196c9839a11SVinicius Costa Gomes memcpy(key->rand, rand, sizeof(key->rand)); 219775d262c2SVinicius Costa Gomes 2198c9839a11SVinicius Costa Gomes if (!new_key) 2199c9839a11SVinicius Costa Gomes return 0; 220075d262c2SVinicius Costa Gomes 2201261cc5aaSVinicius Costa Gomes if (type & HCI_SMP_LTK) 2202261cc5aaSVinicius Costa Gomes mgmt_new_ltk(hdev, key, 1); 2203261cc5aaSVinicius Costa Gomes 220475d262c2SVinicius Costa Gomes return 0; 220575d262c2SVinicius Costa Gomes } 220675d262c2SVinicius Costa Gomes 220755ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 220855ed8ca1SJohan Hedberg { 220955ed8ca1SJohan Hedberg struct link_key *key; 221055ed8ca1SJohan Hedberg 221155ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 221255ed8ca1SJohan Hedberg if (!key) 221355ed8ca1SJohan Hedberg return -ENOENT; 221455ed8ca1SJohan Hedberg 22156ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 221655ed8ca1SJohan Hedberg 221755ed8ca1SJohan Hedberg list_del(&key->list); 221855ed8ca1SJohan Hedberg kfree(key); 221955ed8ca1SJohan Hedberg 222055ed8ca1SJohan Hedberg return 0; 222155ed8ca1SJohan Hedberg } 222255ed8ca1SJohan Hedberg 2223b899efafSVinicius Costa Gomes int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr) 2224b899efafSVinicius Costa Gomes { 2225b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 2226b899efafSVinicius Costa Gomes 2227b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 2228b899efafSVinicius Costa Gomes if (bacmp(bdaddr, &k->bdaddr)) 2229b899efafSVinicius Costa Gomes continue; 2230b899efafSVinicius Costa Gomes 22316ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2232b899efafSVinicius Costa Gomes 2233b899efafSVinicius Costa Gomes list_del(&k->list); 2234b899efafSVinicius Costa Gomes kfree(k); 2235b899efafSVinicius Costa Gomes } 2236b899efafSVinicius Costa Gomes 2237b899efafSVinicius Costa Gomes return 0; 2238b899efafSVinicius Costa Gomes } 2239b899efafSVinicius Costa Gomes 22406bd32326SVille Tervo /* HCI command timer function */ 2241bda4f23aSAndrei Emeltchenko static void hci_cmd_timeout(unsigned long arg) 22426bd32326SVille Tervo { 22436bd32326SVille Tervo struct hci_dev *hdev = (void *) arg; 22446bd32326SVille Tervo 2245bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2246bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2247bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2248bda4f23aSAndrei Emeltchenko 2249bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 2250bda4f23aSAndrei Emeltchenko } else { 22516bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 2252bda4f23aSAndrei Emeltchenko } 2253bda4f23aSAndrei Emeltchenko 22546bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2255c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 22566bd32326SVille Tervo } 22576bd32326SVille Tervo 22582763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 22592763eda6SSzymon Janc bdaddr_t *bdaddr) 22602763eda6SSzymon Janc { 22612763eda6SSzymon Janc struct oob_data *data; 22622763eda6SSzymon Janc 22632763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 22642763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 22652763eda6SSzymon Janc return data; 22662763eda6SSzymon Janc 22672763eda6SSzymon Janc return NULL; 22682763eda6SSzymon Janc } 22692763eda6SSzymon Janc 22702763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 22712763eda6SSzymon Janc { 22722763eda6SSzymon Janc struct oob_data *data; 22732763eda6SSzymon Janc 22742763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 22752763eda6SSzymon Janc if (!data) 22762763eda6SSzymon Janc return -ENOENT; 22772763eda6SSzymon Janc 22786ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 22792763eda6SSzymon Janc 22802763eda6SSzymon Janc list_del(&data->list); 22812763eda6SSzymon Janc kfree(data); 22822763eda6SSzymon Janc 22832763eda6SSzymon Janc return 0; 22842763eda6SSzymon Janc } 22852763eda6SSzymon Janc 22862763eda6SSzymon Janc int hci_remote_oob_data_clear(struct hci_dev *hdev) 22872763eda6SSzymon Janc { 22882763eda6SSzymon Janc struct oob_data *data, *n; 22892763eda6SSzymon Janc 22902763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 22912763eda6SSzymon Janc list_del(&data->list); 22922763eda6SSzymon Janc kfree(data); 22932763eda6SSzymon Janc } 22942763eda6SSzymon Janc 22952763eda6SSzymon Janc return 0; 22962763eda6SSzymon Janc } 22972763eda6SSzymon Janc 22982763eda6SSzymon Janc int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash, 22992763eda6SSzymon Janc u8 *randomizer) 23002763eda6SSzymon Janc { 23012763eda6SSzymon Janc struct oob_data *data; 23022763eda6SSzymon Janc 23032763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 23042763eda6SSzymon Janc 23052763eda6SSzymon Janc if (!data) { 23062763eda6SSzymon Janc data = kmalloc(sizeof(*data), GFP_ATOMIC); 23072763eda6SSzymon Janc if (!data) 23082763eda6SSzymon Janc return -ENOMEM; 23092763eda6SSzymon Janc 23102763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 23112763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 23122763eda6SSzymon Janc } 23132763eda6SSzymon Janc 23142763eda6SSzymon Janc memcpy(data->hash, hash, sizeof(data->hash)); 23152763eda6SSzymon Janc memcpy(data->randomizer, randomizer, sizeof(data->randomizer)); 23162763eda6SSzymon Janc 23176ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 23182763eda6SSzymon Janc 23192763eda6SSzymon Janc return 0; 23202763eda6SSzymon Janc } 23212763eda6SSzymon Janc 2322b9ee0a78SMarcel Holtmann struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev, 2323b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2324b2a66aadSAntti Julku { 2325b2a66aadSAntti Julku struct bdaddr_list *b; 2326b2a66aadSAntti Julku 2327b9ee0a78SMarcel Holtmann list_for_each_entry(b, &hdev->blacklist, list) { 2328b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2329b2a66aadSAntti Julku return b; 2330b9ee0a78SMarcel Holtmann } 2331b2a66aadSAntti Julku 2332b2a66aadSAntti Julku return NULL; 2333b2a66aadSAntti Julku } 2334b2a66aadSAntti Julku 2335b2a66aadSAntti Julku int hci_blacklist_clear(struct hci_dev *hdev) 2336b2a66aadSAntti Julku { 2337b2a66aadSAntti Julku struct list_head *p, *n; 2338b2a66aadSAntti Julku 2339b2a66aadSAntti Julku list_for_each_safe(p, n, &hdev->blacklist) { 2340b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 2341b2a66aadSAntti Julku 2342b2a66aadSAntti Julku list_del(p); 2343b2a66aadSAntti Julku kfree(b); 2344b2a66aadSAntti Julku } 2345b2a66aadSAntti Julku 2346b2a66aadSAntti Julku return 0; 2347b2a66aadSAntti Julku } 2348b2a66aadSAntti Julku 234988c1fe4bSJohan Hedberg int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 2350b2a66aadSAntti Julku { 2351b2a66aadSAntti Julku struct bdaddr_list *entry; 2352b2a66aadSAntti Julku 2353b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2354b2a66aadSAntti Julku return -EBADF; 2355b2a66aadSAntti Julku 2356b9ee0a78SMarcel Holtmann if (hci_blacklist_lookup(hdev, bdaddr, type)) 23575e762444SAntti Julku return -EEXIST; 2358b2a66aadSAntti Julku 2359b2a66aadSAntti Julku entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL); 23605e762444SAntti Julku if (!entry) 23615e762444SAntti Julku return -ENOMEM; 2362b2a66aadSAntti Julku 2363b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2364b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2365b2a66aadSAntti Julku 2366b2a66aadSAntti Julku list_add(&entry->list, &hdev->blacklist); 2367b2a66aadSAntti Julku 236888c1fe4bSJohan Hedberg return mgmt_device_blocked(hdev, bdaddr, type); 2369b2a66aadSAntti Julku } 2370b2a66aadSAntti Julku 237188c1fe4bSJohan Hedberg int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 2372b2a66aadSAntti Julku { 2373b2a66aadSAntti Julku struct bdaddr_list *entry; 2374b2a66aadSAntti Julku 2375b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 23765e762444SAntti Julku return hci_blacklist_clear(hdev); 2377b2a66aadSAntti Julku 2378b9ee0a78SMarcel Holtmann entry = hci_blacklist_lookup(hdev, bdaddr, type); 23791ec918ceSSzymon Janc if (!entry) 23805e762444SAntti Julku return -ENOENT; 2381b2a66aadSAntti Julku 2382b2a66aadSAntti Julku list_del(&entry->list); 2383b2a66aadSAntti Julku kfree(entry); 2384b2a66aadSAntti Julku 238588c1fe4bSJohan Hedberg return mgmt_device_unblocked(hdev, bdaddr, type); 2386b2a66aadSAntti Julku } 2387b2a66aadSAntti Julku 23884c87eaabSAndre Guedes static void inquiry_complete(struct hci_dev *hdev, u8 status) 23897ba8b4beSAndre Guedes { 23904c87eaabSAndre Guedes if (status) { 23914c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 23927ba8b4beSAndre Guedes 23934c87eaabSAndre Guedes hci_dev_lock(hdev); 23944c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 23954c87eaabSAndre Guedes hci_dev_unlock(hdev); 23964c87eaabSAndre Guedes return; 23974c87eaabSAndre Guedes } 23987ba8b4beSAndre Guedes } 23997ba8b4beSAndre Guedes 24004c87eaabSAndre Guedes static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status) 24017ba8b4beSAndre Guedes { 24024c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 24034c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 24044c87eaabSAndre Guedes struct hci_request req; 24054c87eaabSAndre Guedes struct hci_cp_inquiry cp; 24067ba8b4beSAndre Guedes int err; 24077ba8b4beSAndre Guedes 24084c87eaabSAndre Guedes if (status) { 24094c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 24104c87eaabSAndre Guedes return; 24117ba8b4beSAndre Guedes } 24127ba8b4beSAndre Guedes 24134c87eaabSAndre Guedes switch (hdev->discovery.type) { 24144c87eaabSAndre Guedes case DISCOV_TYPE_LE: 24154c87eaabSAndre Guedes hci_dev_lock(hdev); 24164c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 24174c87eaabSAndre Guedes hci_dev_unlock(hdev); 24184c87eaabSAndre Guedes break; 24197dbfac1dSAndre Guedes 24204c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 24214c87eaabSAndre Guedes hci_req_init(&req, hdev); 24227dbfac1dSAndre Guedes 24237dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 24244c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 24254c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 24264c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 24274c87eaabSAndre Guedes 24284c87eaabSAndre Guedes hci_dev_lock(hdev); 24294c87eaabSAndre Guedes 24304c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 24314c87eaabSAndre Guedes 24324c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 24334c87eaabSAndre Guedes if (err) { 24344c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 24354c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 24367dbfac1dSAndre Guedes } 24377dbfac1dSAndre Guedes 24384c87eaabSAndre Guedes hci_dev_unlock(hdev); 24394c87eaabSAndre Guedes break; 24404c87eaabSAndre Guedes } 24417dbfac1dSAndre Guedes } 24427dbfac1dSAndre Guedes 24437ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 24447ba8b4beSAndre Guedes { 24457ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 24467ba8b4beSAndre Guedes le_scan_disable.work); 24477ba8b4beSAndre Guedes struct hci_cp_le_set_scan_enable cp; 24484c87eaabSAndre Guedes struct hci_request req; 24494c87eaabSAndre Guedes int err; 24507ba8b4beSAndre Guedes 24517ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 24527ba8b4beSAndre Guedes 24534c87eaabSAndre Guedes hci_req_init(&req, hdev); 24547ba8b4beSAndre Guedes 24557ba8b4beSAndre Guedes memset(&cp, 0, sizeof(cp)); 24564c87eaabSAndre Guedes cp.enable = LE_SCAN_DISABLE; 24574c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 24587ba8b4beSAndre Guedes 24594c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 24604c87eaabSAndre Guedes if (err) 24614c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 246228b75a89SAndre Guedes } 246328b75a89SAndre Guedes 24649be0dab7SDavid Herrmann /* Alloc HCI device */ 24659be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 24669be0dab7SDavid Herrmann { 24679be0dab7SDavid Herrmann struct hci_dev *hdev; 24689be0dab7SDavid Herrmann 24699be0dab7SDavid Herrmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 24709be0dab7SDavid Herrmann if (!hdev) 24719be0dab7SDavid Herrmann return NULL; 24729be0dab7SDavid Herrmann 2473b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 2474b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 2475b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 2476b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 2477b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 2478bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 2479bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 2480b1b813d4SDavid Herrmann 2481b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 2482b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 2483b1b813d4SDavid Herrmann 2484bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 2485bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 2486bef64738SMarcel Holtmann 2487b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 2488b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 2489b1b813d4SDavid Herrmann 2490b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 2491b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 2492b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 2493b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 2494b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 2495b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 24966b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 2497b1b813d4SDavid Herrmann 2498b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 2499b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 2500b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 2501b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 2502b1b813d4SDavid Herrmann 2503b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 2504b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 2505b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 2506b1b813d4SDavid Herrmann 2507b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 2508b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 2509b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 2510b1b813d4SDavid Herrmann 2511b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 2512b1b813d4SDavid Herrmann 2513bda4f23aSAndrei Emeltchenko setup_timer(&hdev->cmd_timer, hci_cmd_timeout, (unsigned long) hdev); 2514b1b813d4SDavid Herrmann 2515b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 2516b1b813d4SDavid Herrmann discovery_init(hdev); 25179be0dab7SDavid Herrmann 25189be0dab7SDavid Herrmann return hdev; 25199be0dab7SDavid Herrmann } 25209be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 25219be0dab7SDavid Herrmann 25229be0dab7SDavid Herrmann /* Free HCI device */ 25239be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 25249be0dab7SDavid Herrmann { 25259be0dab7SDavid Herrmann /* will free via device release */ 25269be0dab7SDavid Herrmann put_device(&hdev->dev); 25279be0dab7SDavid Herrmann } 25289be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 25299be0dab7SDavid Herrmann 25301da177e4SLinus Torvalds /* Register HCI device */ 25311da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 25321da177e4SLinus Torvalds { 2533b1b813d4SDavid Herrmann int id, error; 25341da177e4SLinus Torvalds 2535010666a1SDavid Herrmann if (!hdev->open || !hdev->close) 25361da177e4SLinus Torvalds return -EINVAL; 25371da177e4SLinus Torvalds 253808add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 253908add513SMat Martineau * so the index can be used as the AMP controller ID. 254008add513SMat Martineau */ 25413df92b31SSasha Levin switch (hdev->dev_type) { 25423df92b31SSasha Levin case HCI_BREDR: 25433df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 25441da177e4SLinus Torvalds break; 25453df92b31SSasha Levin case HCI_AMP: 25463df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 25473df92b31SSasha Levin break; 25483df92b31SSasha Levin default: 25493df92b31SSasha Levin return -EINVAL; 25501da177e4SLinus Torvalds } 25511da177e4SLinus Torvalds 25523df92b31SSasha Levin if (id < 0) 25533df92b31SSasha Levin return id; 25543df92b31SSasha Levin 25551da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 25561da177e4SLinus Torvalds hdev->id = id; 25572d8b3a11SAndrei Emeltchenko 25582d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 25592d8b3a11SAndrei Emeltchenko 2560d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 2561d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 256233ca954dSDavid Herrmann if (!hdev->workqueue) { 256333ca954dSDavid Herrmann error = -ENOMEM; 256433ca954dSDavid Herrmann goto err; 256533ca954dSDavid Herrmann } 2566f48fd9c8SMarcel Holtmann 2567d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 2568d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 25696ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 25706ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 25716ead1bbcSJohan Hedberg error = -ENOMEM; 25726ead1bbcSJohan Hedberg goto err; 25736ead1bbcSJohan Hedberg } 25746ead1bbcSJohan Hedberg 25750153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 25760153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 25770153e2ecSMarcel Holtmann 2578bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 2579bdc3e0f1SMarcel Holtmann 2580bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 258133ca954dSDavid Herrmann if (error < 0) 258233ca954dSDavid Herrmann goto err_wqueue; 25831da177e4SLinus Torvalds 2584611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 2585a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 2586a8c5fb1aSGustavo Padovan hdev); 2587611b30f7SMarcel Holtmann if (hdev->rfkill) { 2588611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 2589611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 2590611b30f7SMarcel Holtmann hdev->rfkill = NULL; 2591611b30f7SMarcel Holtmann } 2592611b30f7SMarcel Holtmann } 2593611b30f7SMarcel Holtmann 25945e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 25955e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 25965e130367SJohan Hedberg 2597a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 2598004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2599ce2be9acSAndrei Emeltchenko 260001cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 260156f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 260256f87901SJohan Hedberg * through reading supported features during init. 260356f87901SJohan Hedberg */ 260456f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 260556f87901SJohan Hedberg } 2606ce2be9acSAndrei Emeltchenko 2607fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 2608fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 2609fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 2610fcee3377SGustavo Padovan 26111da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 2612dc946bd8SDavid Herrmann hci_dev_hold(hdev); 26131da177e4SLinus Torvalds 261419202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 2615fbe96d6fSMarcel Holtmann 26161da177e4SLinus Torvalds return id; 2617f48fd9c8SMarcel Holtmann 261833ca954dSDavid Herrmann err_wqueue: 261933ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 26206ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 262133ca954dSDavid Herrmann err: 26223df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 2623f48fd9c8SMarcel Holtmann 262433ca954dSDavid Herrmann return error; 26251da177e4SLinus Torvalds } 26261da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 26271da177e4SLinus Torvalds 26281da177e4SLinus Torvalds /* Unregister HCI device */ 262959735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 26301da177e4SLinus Torvalds { 26313df92b31SSasha Levin int i, id; 2632ef222013SMarcel Holtmann 2633c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 26341da177e4SLinus Torvalds 263594324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 263694324962SJohan Hovold 26373df92b31SSasha Levin id = hdev->id; 26383df92b31SSasha Levin 2639f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 26401da177e4SLinus Torvalds list_del(&hdev->list); 2641f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 26421da177e4SLinus Torvalds 26431da177e4SLinus Torvalds hci_dev_do_close(hdev); 26441da177e4SLinus Torvalds 2645cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 2646ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 2647ef222013SMarcel Holtmann 2648b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 2649b9b5ef18SGustavo Padovan 2650ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 2651a8b2d5c2SJohan Hedberg !test_bit(HCI_SETUP, &hdev->dev_flags)) { 265209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2653744cf19eSJohan Hedberg mgmt_index_removed(hdev); 265409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 265556e5cb86SJohan Hedberg } 2656ab81cbf9SJohan Hedberg 26572e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 26582e58ef3eSJohan Hedberg * pending list */ 26592e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 26602e58ef3eSJohan Hedberg 26611da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 26621da177e4SLinus Torvalds 2663611b30f7SMarcel Holtmann if (hdev->rfkill) { 2664611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 2665611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 2666611b30f7SMarcel Holtmann } 2667611b30f7SMarcel Holtmann 2668bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 2669147e2d59SDave Young 26700153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 26710153e2ecSMarcel Holtmann 2672f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 26736ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 2674f48fd9c8SMarcel Holtmann 267509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2676e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 26772aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 267855ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 2679b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 26802763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 268109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 2682e2e0cacbSJohan Hedberg 2683dc946bd8SDavid Herrmann hci_dev_put(hdev); 26843df92b31SSasha Levin 26853df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 26861da177e4SLinus Torvalds } 26871da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 26881da177e4SLinus Torvalds 26891da177e4SLinus Torvalds /* Suspend HCI device */ 26901da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 26911da177e4SLinus Torvalds { 26921da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 26931da177e4SLinus Torvalds return 0; 26941da177e4SLinus Torvalds } 26951da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 26961da177e4SLinus Torvalds 26971da177e4SLinus Torvalds /* Resume HCI device */ 26981da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 26991da177e4SLinus Torvalds { 27001da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 27011da177e4SLinus Torvalds return 0; 27021da177e4SLinus Torvalds } 27031da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 27041da177e4SLinus Torvalds 270576bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 2706e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 270776bca880SMarcel Holtmann { 270876bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 270976bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 271076bca880SMarcel Holtmann kfree_skb(skb); 271176bca880SMarcel Holtmann return -ENXIO; 271276bca880SMarcel Holtmann } 271376bca880SMarcel Holtmann 2714d82603c6SJorrit Schippers /* Incoming skb */ 271576bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 271676bca880SMarcel Holtmann 271776bca880SMarcel Holtmann /* Time stamp */ 271876bca880SMarcel Holtmann __net_timestamp(skb); 271976bca880SMarcel Holtmann 272076bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 2721b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 2722c78ae283SMarcel Holtmann 272376bca880SMarcel Holtmann return 0; 272476bca880SMarcel Holtmann } 272576bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 272676bca880SMarcel Holtmann 272733e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 27281e429f38SGustavo F. Padovan int count, __u8 index) 272933e882a5SSuraj Sumangala { 273033e882a5SSuraj Sumangala int len = 0; 273133e882a5SSuraj Sumangala int hlen = 0; 273233e882a5SSuraj Sumangala int remain = count; 273333e882a5SSuraj Sumangala struct sk_buff *skb; 273433e882a5SSuraj Sumangala struct bt_skb_cb *scb; 273533e882a5SSuraj Sumangala 273633e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 273733e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 273833e882a5SSuraj Sumangala return -EILSEQ; 273933e882a5SSuraj Sumangala 274033e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 274133e882a5SSuraj Sumangala 274233e882a5SSuraj Sumangala if (!skb) { 274333e882a5SSuraj Sumangala switch (type) { 274433e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 274533e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 274633e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 274733e882a5SSuraj Sumangala break; 274833e882a5SSuraj Sumangala case HCI_EVENT_PKT: 274933e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 275033e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 275133e882a5SSuraj Sumangala break; 275233e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 275333e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 275433e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 275533e882a5SSuraj Sumangala break; 275633e882a5SSuraj Sumangala } 275733e882a5SSuraj Sumangala 27581e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 275933e882a5SSuraj Sumangala if (!skb) 276033e882a5SSuraj Sumangala return -ENOMEM; 276133e882a5SSuraj Sumangala 276233e882a5SSuraj Sumangala scb = (void *) skb->cb; 276333e882a5SSuraj Sumangala scb->expect = hlen; 276433e882a5SSuraj Sumangala scb->pkt_type = type; 276533e882a5SSuraj Sumangala 276633e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 276733e882a5SSuraj Sumangala } 276833e882a5SSuraj Sumangala 276933e882a5SSuraj Sumangala while (count) { 277033e882a5SSuraj Sumangala scb = (void *) skb->cb; 277189bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 277233e882a5SSuraj Sumangala 277333e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 277433e882a5SSuraj Sumangala 277533e882a5SSuraj Sumangala count -= len; 277633e882a5SSuraj Sumangala data += len; 277733e882a5SSuraj Sumangala scb->expect -= len; 277833e882a5SSuraj Sumangala remain = count; 277933e882a5SSuraj Sumangala 278033e882a5SSuraj Sumangala switch (type) { 278133e882a5SSuraj Sumangala case HCI_EVENT_PKT: 278233e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 278333e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 278433e882a5SSuraj Sumangala scb->expect = h->plen; 278533e882a5SSuraj Sumangala 278633e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 278733e882a5SSuraj Sumangala kfree_skb(skb); 278833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 278933e882a5SSuraj Sumangala return -ENOMEM; 279033e882a5SSuraj Sumangala } 279133e882a5SSuraj Sumangala } 279233e882a5SSuraj Sumangala break; 279333e882a5SSuraj Sumangala 279433e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 279533e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 279633e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 279733e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 279833e882a5SSuraj Sumangala 279933e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 280033e882a5SSuraj Sumangala kfree_skb(skb); 280133e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 280233e882a5SSuraj Sumangala return -ENOMEM; 280333e882a5SSuraj Sumangala } 280433e882a5SSuraj Sumangala } 280533e882a5SSuraj Sumangala break; 280633e882a5SSuraj Sumangala 280733e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 280833e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 280933e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 281033e882a5SSuraj Sumangala scb->expect = h->dlen; 281133e882a5SSuraj Sumangala 281233e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 281333e882a5SSuraj Sumangala kfree_skb(skb); 281433e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 281533e882a5SSuraj Sumangala return -ENOMEM; 281633e882a5SSuraj Sumangala } 281733e882a5SSuraj Sumangala } 281833e882a5SSuraj Sumangala break; 281933e882a5SSuraj Sumangala } 282033e882a5SSuraj Sumangala 282133e882a5SSuraj Sumangala if (scb->expect == 0) { 282233e882a5SSuraj Sumangala /* Complete frame */ 282333e882a5SSuraj Sumangala 282433e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 2825e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 282633e882a5SSuraj Sumangala 282733e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 282833e882a5SSuraj Sumangala return remain; 282933e882a5SSuraj Sumangala } 283033e882a5SSuraj Sumangala } 283133e882a5SSuraj Sumangala 283233e882a5SSuraj Sumangala return remain; 283333e882a5SSuraj Sumangala } 283433e882a5SSuraj Sumangala 2835ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 2836ef222013SMarcel Holtmann { 2837f39a3c06SSuraj Sumangala int rem = 0; 2838f39a3c06SSuraj Sumangala 2839ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 2840ef222013SMarcel Holtmann return -EILSEQ; 2841ef222013SMarcel Holtmann 2842da5f6c37SGustavo F. Padovan while (count) { 28431e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, type - 1); 2844f39a3c06SSuraj Sumangala if (rem < 0) 2845f39a3c06SSuraj Sumangala return rem; 2846ef222013SMarcel Holtmann 2847f39a3c06SSuraj Sumangala data += (count - rem); 2848f39a3c06SSuraj Sumangala count = rem; 2849f81c6224SJoe Perches } 2850ef222013SMarcel Holtmann 2851f39a3c06SSuraj Sumangala return rem; 2852ef222013SMarcel Holtmann } 2853ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 2854ef222013SMarcel Holtmann 285599811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 285699811510SSuraj Sumangala 285799811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 285899811510SSuraj Sumangala { 285999811510SSuraj Sumangala int type; 286099811510SSuraj Sumangala int rem = 0; 286199811510SSuraj Sumangala 2862da5f6c37SGustavo F. Padovan while (count) { 286399811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 286499811510SSuraj Sumangala 286599811510SSuraj Sumangala if (!skb) { 286699811510SSuraj Sumangala struct { char type; } *pkt; 286799811510SSuraj Sumangala 286899811510SSuraj Sumangala /* Start of the frame */ 286999811510SSuraj Sumangala pkt = data; 287099811510SSuraj Sumangala type = pkt->type; 287199811510SSuraj Sumangala 287299811510SSuraj Sumangala data++; 287399811510SSuraj Sumangala count--; 287499811510SSuraj Sumangala } else 287599811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 287699811510SSuraj Sumangala 28771e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 28781e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 287999811510SSuraj Sumangala if (rem < 0) 288099811510SSuraj Sumangala return rem; 288199811510SSuraj Sumangala 288299811510SSuraj Sumangala data += (count - rem); 288399811510SSuraj Sumangala count = rem; 2884f81c6224SJoe Perches } 288599811510SSuraj Sumangala 288699811510SSuraj Sumangala return rem; 288799811510SSuraj Sumangala } 288899811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 288999811510SSuraj Sumangala 28901da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 28911da177e4SLinus Torvalds 28921da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 28931da177e4SLinus Torvalds { 28941da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 28951da177e4SLinus Torvalds 2896f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 28971da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 2898f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 28991da177e4SLinus Torvalds 29001da177e4SLinus Torvalds return 0; 29011da177e4SLinus Torvalds } 29021da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 29031da177e4SLinus Torvalds 29041da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 29051da177e4SLinus Torvalds { 29061da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 29071da177e4SLinus Torvalds 2908f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 29091da177e4SLinus Torvalds list_del(&cb->list); 2910f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 29111da177e4SLinus Torvalds 29121da177e4SLinus Torvalds return 0; 29131da177e4SLinus Torvalds } 29141da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 29151da177e4SLinus Torvalds 291651086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 29171da177e4SLinus Torvalds { 29180d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 29191da177e4SLinus Torvalds 29201da177e4SLinus Torvalds /* Time stamp */ 2921a61bbcf2SPatrick McHardy __net_timestamp(skb); 29221da177e4SLinus Torvalds 2923cd82e61cSMarcel Holtmann /* Send copy to monitor */ 2924cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 2925cd82e61cSMarcel Holtmann 2926cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 2927cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 2928470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 29291da177e4SLinus Torvalds } 29301da177e4SLinus Torvalds 29311da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 29321da177e4SLinus Torvalds skb_orphan(skb); 29331da177e4SLinus Torvalds 29347bd8f09fSMarcel Holtmann if (hdev->send(hdev, skb) < 0) 293551086991SMarcel Holtmann BT_ERR("%s sending frame failed", hdev->name); 29361da177e4SLinus Torvalds } 29371da177e4SLinus Torvalds 29383119ae95SJohan Hedberg void hci_req_init(struct hci_request *req, struct hci_dev *hdev) 29393119ae95SJohan Hedberg { 29403119ae95SJohan Hedberg skb_queue_head_init(&req->cmd_q); 29413119ae95SJohan Hedberg req->hdev = hdev; 29425d73e034SAndre Guedes req->err = 0; 29433119ae95SJohan Hedberg } 29443119ae95SJohan Hedberg 29453119ae95SJohan Hedberg int hci_req_run(struct hci_request *req, hci_req_complete_t complete) 29463119ae95SJohan Hedberg { 29473119ae95SJohan Hedberg struct hci_dev *hdev = req->hdev; 29483119ae95SJohan Hedberg struct sk_buff *skb; 29493119ae95SJohan Hedberg unsigned long flags; 29503119ae95SJohan Hedberg 29513119ae95SJohan Hedberg BT_DBG("length %u", skb_queue_len(&req->cmd_q)); 29523119ae95SJohan Hedberg 29535d73e034SAndre Guedes /* If an error occured during request building, remove all HCI 29545d73e034SAndre Guedes * commands queued on the HCI request queue. 29555d73e034SAndre Guedes */ 29565d73e034SAndre Guedes if (req->err) { 29575d73e034SAndre Guedes skb_queue_purge(&req->cmd_q); 29585d73e034SAndre Guedes return req->err; 29595d73e034SAndre Guedes } 29605d73e034SAndre Guedes 29613119ae95SJohan Hedberg /* Do not allow empty requests */ 29623119ae95SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 2963382b0c39SAndre Guedes return -ENODATA; 29643119ae95SJohan Hedberg 29653119ae95SJohan Hedberg skb = skb_peek_tail(&req->cmd_q); 29663119ae95SJohan Hedberg bt_cb(skb)->req.complete = complete; 29673119ae95SJohan Hedberg 29683119ae95SJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 29693119ae95SJohan Hedberg skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q); 29703119ae95SJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 29713119ae95SJohan Hedberg 29723119ae95SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 29733119ae95SJohan Hedberg 29743119ae95SJohan Hedberg return 0; 29753119ae95SJohan Hedberg } 29763119ae95SJohan Hedberg 29771ca3a9d0SJohan Hedberg static struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, 297807dc93ddSJohan Hedberg u32 plen, const void *param) 29791da177e4SLinus Torvalds { 29801da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 29811da177e4SLinus Torvalds struct hci_command_hdr *hdr; 29821da177e4SLinus Torvalds struct sk_buff *skb; 29831da177e4SLinus Torvalds 29841da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 29851ca3a9d0SJohan Hedberg if (!skb) 29861ca3a9d0SJohan Hedberg return NULL; 29871da177e4SLinus Torvalds 29881da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 2989a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 29901da177e4SLinus Torvalds hdr->plen = plen; 29911da177e4SLinus Torvalds 29921da177e4SLinus Torvalds if (plen) 29931da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 29941da177e4SLinus Torvalds 29951da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 29961da177e4SLinus Torvalds 29970d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 2998c78ae283SMarcel Holtmann 29991ca3a9d0SJohan Hedberg return skb; 30001ca3a9d0SJohan Hedberg } 30011ca3a9d0SJohan Hedberg 30021ca3a9d0SJohan Hedberg /* Send HCI command */ 300307dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 300407dc93ddSJohan Hedberg const void *param) 30051ca3a9d0SJohan Hedberg { 30061ca3a9d0SJohan Hedberg struct sk_buff *skb; 30071ca3a9d0SJohan Hedberg 30081ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 30091ca3a9d0SJohan Hedberg 30101ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 30111ca3a9d0SJohan Hedberg if (!skb) { 30121ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 30131ca3a9d0SJohan Hedberg return -ENOMEM; 30141ca3a9d0SJohan Hedberg } 30151ca3a9d0SJohan Hedberg 301611714b3dSJohan Hedberg /* Stand-alone HCI commands must be flaged as 301711714b3dSJohan Hedberg * single-command requests. 301811714b3dSJohan Hedberg */ 301911714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 302011714b3dSJohan Hedberg 30211da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3022c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 30231da177e4SLinus Torvalds 30241da177e4SLinus Torvalds return 0; 30251da177e4SLinus Torvalds } 30261da177e4SLinus Torvalds 302771c76a17SJohan Hedberg /* Queue a command to an asynchronous HCI request */ 302807dc93ddSJohan Hedberg void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen, 302907dc93ddSJohan Hedberg const void *param, u8 event) 303071c76a17SJohan Hedberg { 303171c76a17SJohan Hedberg struct hci_dev *hdev = req->hdev; 303271c76a17SJohan Hedberg struct sk_buff *skb; 303371c76a17SJohan Hedberg 303471c76a17SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 303571c76a17SJohan Hedberg 303634739c1eSAndre Guedes /* If an error occured during request building, there is no point in 303734739c1eSAndre Guedes * queueing the HCI command. We can simply return. 303834739c1eSAndre Guedes */ 303934739c1eSAndre Guedes if (req->err) 304034739c1eSAndre Guedes return; 304134739c1eSAndre Guedes 304271c76a17SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 304371c76a17SJohan Hedberg if (!skb) { 30445d73e034SAndre Guedes BT_ERR("%s no memory for command (opcode 0x%4.4x)", 30455d73e034SAndre Guedes hdev->name, opcode); 30465d73e034SAndre Guedes req->err = -ENOMEM; 3047e348fe6bSAndre Guedes return; 304871c76a17SJohan Hedberg } 304971c76a17SJohan Hedberg 305071c76a17SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 305171c76a17SJohan Hedberg bt_cb(skb)->req.start = true; 305271c76a17SJohan Hedberg 305302350a72SJohan Hedberg bt_cb(skb)->req.event = event; 305402350a72SJohan Hedberg 305571c76a17SJohan Hedberg skb_queue_tail(&req->cmd_q, skb); 305671c76a17SJohan Hedberg } 305771c76a17SJohan Hedberg 305807dc93ddSJohan Hedberg void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, 305907dc93ddSJohan Hedberg const void *param) 306002350a72SJohan Hedberg { 306102350a72SJohan Hedberg hci_req_add_ev(req, opcode, plen, param, 0); 306202350a72SJohan Hedberg } 306302350a72SJohan Hedberg 30641da177e4SLinus Torvalds /* Get data from the previously sent command */ 3065a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 30661da177e4SLinus Torvalds { 30671da177e4SLinus Torvalds struct hci_command_hdr *hdr; 30681da177e4SLinus Torvalds 30691da177e4SLinus Torvalds if (!hdev->sent_cmd) 30701da177e4SLinus Torvalds return NULL; 30711da177e4SLinus Torvalds 30721da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 30731da177e4SLinus Torvalds 3074a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 30751da177e4SLinus Torvalds return NULL; 30761da177e4SLinus Torvalds 3077f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 30781da177e4SLinus Torvalds 30791da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 30801da177e4SLinus Torvalds } 30811da177e4SLinus Torvalds 30821da177e4SLinus Torvalds /* Send ACL data */ 30831da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 30841da177e4SLinus Torvalds { 30851da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 30861da177e4SLinus Torvalds int len = skb->len; 30871da177e4SLinus Torvalds 3088badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3089badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 30909c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3091aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3092aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 30931da177e4SLinus Torvalds } 30941da177e4SLinus Torvalds 3095ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 309673d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 30971da177e4SLinus Torvalds { 3098ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 30991da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 31001da177e4SLinus Torvalds struct sk_buff *list; 31011da177e4SLinus Torvalds 3102087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3103087bfd99SGustavo Padovan skb->data_len = 0; 3104087bfd99SGustavo Padovan 3105087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3106204a6e54SAndrei Emeltchenko 3107204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3108204a6e54SAndrei Emeltchenko case HCI_BREDR: 3109087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3110204a6e54SAndrei Emeltchenko break; 3111204a6e54SAndrei Emeltchenko case HCI_AMP: 3112204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3113204a6e54SAndrei Emeltchenko break; 3114204a6e54SAndrei Emeltchenko default: 3115204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 3116204a6e54SAndrei Emeltchenko return; 3117204a6e54SAndrei Emeltchenko } 3118087bfd99SGustavo Padovan 311970f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 312070f23020SAndrei Emeltchenko if (!list) { 31211da177e4SLinus Torvalds /* Non fragmented */ 31221da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 31231da177e4SLinus Torvalds 312473d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 31251da177e4SLinus Torvalds } else { 31261da177e4SLinus Torvalds /* Fragmented */ 31271da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 31281da177e4SLinus Torvalds 31291da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 31301da177e4SLinus Torvalds 31311da177e4SLinus Torvalds /* Queue all fragments atomically */ 3132af3e6359SGustavo F. Padovan spin_lock(&queue->lock); 31331da177e4SLinus Torvalds 313473d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3135e702112fSAndrei Emeltchenko 3136e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3137e702112fSAndrei Emeltchenko flags |= ACL_CONT; 31381da177e4SLinus Torvalds do { 31391da177e4SLinus Torvalds skb = list; list = list->next; 31401da177e4SLinus Torvalds 31410d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3142e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 31431da177e4SLinus Torvalds 31441da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 31451da177e4SLinus Torvalds 314673d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 31471da177e4SLinus Torvalds } while (list); 31481da177e4SLinus Torvalds 3149af3e6359SGustavo F. Padovan spin_unlock(&queue->lock); 31501da177e4SLinus Torvalds } 315173d80debSLuiz Augusto von Dentz } 315273d80debSLuiz Augusto von Dentz 315373d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 315473d80debSLuiz Augusto von Dentz { 3155ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 315673d80debSLuiz Augusto von Dentz 3157f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 315873d80debSLuiz Augusto von Dentz 3159ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 31601da177e4SLinus Torvalds 31613eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 31621da177e4SLinus Torvalds } 31631da177e4SLinus Torvalds 31641da177e4SLinus Torvalds /* Send SCO data */ 31650d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 31661da177e4SLinus Torvalds { 31671da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 31681da177e4SLinus Torvalds struct hci_sco_hdr hdr; 31691da177e4SLinus Torvalds 31701da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 31711da177e4SLinus Torvalds 3172aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 31731da177e4SLinus Torvalds hdr.dlen = skb->len; 31741da177e4SLinus Torvalds 3175badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3176badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 31779c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 31781da177e4SLinus Torvalds 31790d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 3180c78ae283SMarcel Holtmann 31811da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 31823eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 31831da177e4SLinus Torvalds } 31841da177e4SLinus Torvalds 31851da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 31861da177e4SLinus Torvalds 31871da177e4SLinus Torvalds /* HCI Connection scheduler */ 31886039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3189a8c5fb1aSGustavo Padovan int *quote) 31901da177e4SLinus Torvalds { 31911da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 31928035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3193abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 31941da177e4SLinus Torvalds 31951da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 31961da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3197bf4c6325SGustavo F. Padovan 3198bf4c6325SGustavo F. Padovan rcu_read_lock(); 3199bf4c6325SGustavo F. Padovan 3200bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3201769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 32021da177e4SLinus Torvalds continue; 3203769be974SMarcel Holtmann 3204769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3205769be974SMarcel Holtmann continue; 3206769be974SMarcel Holtmann 32071da177e4SLinus Torvalds num++; 32081da177e4SLinus Torvalds 32091da177e4SLinus Torvalds if (c->sent < min) { 32101da177e4SLinus Torvalds min = c->sent; 32111da177e4SLinus Torvalds conn = c; 32121da177e4SLinus Torvalds } 321352087a79SLuiz Augusto von Dentz 321452087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 321552087a79SLuiz Augusto von Dentz break; 32161da177e4SLinus Torvalds } 32171da177e4SLinus Torvalds 3218bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3219bf4c6325SGustavo F. Padovan 32201da177e4SLinus Torvalds if (conn) { 32216ed58ec5SVille Tervo int cnt, q; 32226ed58ec5SVille Tervo 32236ed58ec5SVille Tervo switch (conn->type) { 32246ed58ec5SVille Tervo case ACL_LINK: 32256ed58ec5SVille Tervo cnt = hdev->acl_cnt; 32266ed58ec5SVille Tervo break; 32276ed58ec5SVille Tervo case SCO_LINK: 32286ed58ec5SVille Tervo case ESCO_LINK: 32296ed58ec5SVille Tervo cnt = hdev->sco_cnt; 32306ed58ec5SVille Tervo break; 32316ed58ec5SVille Tervo case LE_LINK: 32326ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 32336ed58ec5SVille Tervo break; 32346ed58ec5SVille Tervo default: 32356ed58ec5SVille Tervo cnt = 0; 32366ed58ec5SVille Tervo BT_ERR("Unknown link type"); 32376ed58ec5SVille Tervo } 32386ed58ec5SVille Tervo 32396ed58ec5SVille Tervo q = cnt / num; 32401da177e4SLinus Torvalds *quote = q ? q : 1; 32411da177e4SLinus Torvalds } else 32421da177e4SLinus Torvalds *quote = 0; 32431da177e4SLinus Torvalds 32441da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 32451da177e4SLinus Torvalds return conn; 32461da177e4SLinus Torvalds } 32471da177e4SLinus Torvalds 32486039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 32491da177e4SLinus Torvalds { 32501da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 32511da177e4SLinus Torvalds struct hci_conn *c; 32521da177e4SLinus Torvalds 3253bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 32541da177e4SLinus Torvalds 3255bf4c6325SGustavo F. Padovan rcu_read_lock(); 3256bf4c6325SGustavo F. Padovan 32571da177e4SLinus Torvalds /* Kill stalled connections */ 3258bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3259bae1f5d9SVille Tervo if (c->type == type && c->sent) { 32606ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 32616ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 3262bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 32631da177e4SLinus Torvalds } 32641da177e4SLinus Torvalds } 3265bf4c6325SGustavo F. Padovan 3266bf4c6325SGustavo F. Padovan rcu_read_unlock(); 32671da177e4SLinus Torvalds } 32681da177e4SLinus Torvalds 32696039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 327073d80debSLuiz Augusto von Dentz int *quote) 327173d80debSLuiz Augusto von Dentz { 327273d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 327373d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3274abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 327573d80debSLuiz Augusto von Dentz struct hci_conn *conn; 327673d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 327773d80debSLuiz Augusto von Dentz 327873d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 327973d80debSLuiz Augusto von Dentz 3280bf4c6325SGustavo F. Padovan rcu_read_lock(); 3281bf4c6325SGustavo F. Padovan 3282bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 328373d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 328473d80debSLuiz Augusto von Dentz 328573d80debSLuiz Augusto von Dentz if (conn->type != type) 328673d80debSLuiz Augusto von Dentz continue; 328773d80debSLuiz Augusto von Dentz 328873d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 328973d80debSLuiz Augusto von Dentz continue; 329073d80debSLuiz Augusto von Dentz 329173d80debSLuiz Augusto von Dentz conn_num++; 329273d80debSLuiz Augusto von Dentz 32938192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 329473d80debSLuiz Augusto von Dentz struct sk_buff *skb; 329573d80debSLuiz Augusto von Dentz 329673d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 329773d80debSLuiz Augusto von Dentz continue; 329873d80debSLuiz Augusto von Dentz 329973d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 330073d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 330173d80debSLuiz Augusto von Dentz continue; 330273d80debSLuiz Augusto von Dentz 330373d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 330473d80debSLuiz Augusto von Dentz num = 0; 330573d80debSLuiz Augusto von Dentz min = ~0; 330673d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 330773d80debSLuiz Augusto von Dentz } 330873d80debSLuiz Augusto von Dentz 330973d80debSLuiz Augusto von Dentz num++; 331073d80debSLuiz Augusto von Dentz 331173d80debSLuiz Augusto von Dentz if (conn->sent < min) { 331273d80debSLuiz Augusto von Dentz min = conn->sent; 331373d80debSLuiz Augusto von Dentz chan = tmp; 331473d80debSLuiz Augusto von Dentz } 331573d80debSLuiz Augusto von Dentz } 331673d80debSLuiz Augusto von Dentz 331773d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 331873d80debSLuiz Augusto von Dentz break; 331973d80debSLuiz Augusto von Dentz } 332073d80debSLuiz Augusto von Dentz 3321bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3322bf4c6325SGustavo F. Padovan 332373d80debSLuiz Augusto von Dentz if (!chan) 332473d80debSLuiz Augusto von Dentz return NULL; 332573d80debSLuiz Augusto von Dentz 332673d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 332773d80debSLuiz Augusto von Dentz case ACL_LINK: 332873d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 332973d80debSLuiz Augusto von Dentz break; 3330bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3331bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3332bd1eb66bSAndrei Emeltchenko break; 333373d80debSLuiz Augusto von Dentz case SCO_LINK: 333473d80debSLuiz Augusto von Dentz case ESCO_LINK: 333573d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 333673d80debSLuiz Augusto von Dentz break; 333773d80debSLuiz Augusto von Dentz case LE_LINK: 333873d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 333973d80debSLuiz Augusto von Dentz break; 334073d80debSLuiz Augusto von Dentz default: 334173d80debSLuiz Augusto von Dentz cnt = 0; 334273d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 334373d80debSLuiz Augusto von Dentz } 334473d80debSLuiz Augusto von Dentz 334573d80debSLuiz Augusto von Dentz q = cnt / num; 334673d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 334773d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 334873d80debSLuiz Augusto von Dentz return chan; 334973d80debSLuiz Augusto von Dentz } 335073d80debSLuiz Augusto von Dentz 335102b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 335202b20f0bSLuiz Augusto von Dentz { 335302b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 335402b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 335502b20f0bSLuiz Augusto von Dentz int num = 0; 335602b20f0bSLuiz Augusto von Dentz 335702b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 335802b20f0bSLuiz Augusto von Dentz 3359bf4c6325SGustavo F. Padovan rcu_read_lock(); 3360bf4c6325SGustavo F. Padovan 3361bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 336202b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 336302b20f0bSLuiz Augusto von Dentz 336402b20f0bSLuiz Augusto von Dentz if (conn->type != type) 336502b20f0bSLuiz Augusto von Dentz continue; 336602b20f0bSLuiz Augusto von Dentz 336702b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 336802b20f0bSLuiz Augusto von Dentz continue; 336902b20f0bSLuiz Augusto von Dentz 337002b20f0bSLuiz Augusto von Dentz num++; 337102b20f0bSLuiz Augusto von Dentz 33728192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 337302b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 337402b20f0bSLuiz Augusto von Dentz 337502b20f0bSLuiz Augusto von Dentz if (chan->sent) { 337602b20f0bSLuiz Augusto von Dentz chan->sent = 0; 337702b20f0bSLuiz Augusto von Dentz continue; 337802b20f0bSLuiz Augusto von Dentz } 337902b20f0bSLuiz Augusto von Dentz 338002b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 338102b20f0bSLuiz Augusto von Dentz continue; 338202b20f0bSLuiz Augusto von Dentz 338302b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 338402b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 338502b20f0bSLuiz Augusto von Dentz continue; 338602b20f0bSLuiz Augusto von Dentz 338702b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 338802b20f0bSLuiz Augusto von Dentz 338902b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 339002b20f0bSLuiz Augusto von Dentz skb->priority); 339102b20f0bSLuiz Augusto von Dentz } 339202b20f0bSLuiz Augusto von Dentz 339302b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 339402b20f0bSLuiz Augusto von Dentz break; 339502b20f0bSLuiz Augusto von Dentz } 3396bf4c6325SGustavo F. Padovan 3397bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3398bf4c6325SGustavo F. Padovan 339902b20f0bSLuiz Augusto von Dentz } 340002b20f0bSLuiz Augusto von Dentz 3401b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 3402b71d385aSAndrei Emeltchenko { 3403b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 3404b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 3405b71d385aSAndrei Emeltchenko } 3406b71d385aSAndrei Emeltchenko 34076039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 34081da177e4SLinus Torvalds { 34091da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 34101da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 34111da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 341263d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 34135f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 3414bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 34151da177e4SLinus Torvalds } 341663d2bc1bSAndrei Emeltchenko } 34171da177e4SLinus Torvalds 34186039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 341963d2bc1bSAndrei Emeltchenko { 342063d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 342163d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 342263d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 342363d2bc1bSAndrei Emeltchenko int quote; 342463d2bc1bSAndrei Emeltchenko 342563d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 342604837f64SMarcel Holtmann 342773d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 342873d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 3429ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3430ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 343173d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 343273d80debSLuiz Augusto von Dentz skb->len, skb->priority); 343373d80debSLuiz Augusto von Dentz 3434ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3435ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3436ec1cce24SLuiz Augusto von Dentz break; 3437ec1cce24SLuiz Augusto von Dentz 3438ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3439ec1cce24SLuiz Augusto von Dentz 344073d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 344173d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 344204837f64SMarcel Holtmann 344357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 34441da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 34451da177e4SLinus Torvalds 34461da177e4SLinus Torvalds hdev->acl_cnt--; 344773d80debSLuiz Augusto von Dentz chan->sent++; 344873d80debSLuiz Augusto von Dentz chan->conn->sent++; 34491da177e4SLinus Torvalds } 34501da177e4SLinus Torvalds } 345102b20f0bSLuiz Augusto von Dentz 345202b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 345302b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 34541da177e4SLinus Torvalds } 34551da177e4SLinus Torvalds 34566039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 3457b71d385aSAndrei Emeltchenko { 345863d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 3459b71d385aSAndrei Emeltchenko struct hci_chan *chan; 3460b71d385aSAndrei Emeltchenko struct sk_buff *skb; 3461b71d385aSAndrei Emeltchenko int quote; 3462bd1eb66bSAndrei Emeltchenko u8 type; 3463b71d385aSAndrei Emeltchenko 346463d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 3465b71d385aSAndrei Emeltchenko 3466bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3467bd1eb66bSAndrei Emeltchenko 3468bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 3469bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 3470bd1eb66bSAndrei Emeltchenko else 3471bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 3472bd1eb66bSAndrei Emeltchenko 3473b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 3474bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 3475b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 3476b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 3477b71d385aSAndrei Emeltchenko int blocks; 3478b71d385aSAndrei Emeltchenko 3479b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 3480b71d385aSAndrei Emeltchenko skb->len, skb->priority); 3481b71d385aSAndrei Emeltchenko 3482b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 3483b71d385aSAndrei Emeltchenko if (skb->priority < priority) 3484b71d385aSAndrei Emeltchenko break; 3485b71d385aSAndrei Emeltchenko 3486b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 3487b71d385aSAndrei Emeltchenko 3488b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 3489b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 3490b71d385aSAndrei Emeltchenko return; 3491b71d385aSAndrei Emeltchenko 3492b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 3493b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 3494b71d385aSAndrei Emeltchenko 349557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3496b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 3497b71d385aSAndrei Emeltchenko 3498b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 3499b71d385aSAndrei Emeltchenko quote -= blocks; 3500b71d385aSAndrei Emeltchenko 3501b71d385aSAndrei Emeltchenko chan->sent += blocks; 3502b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 3503b71d385aSAndrei Emeltchenko } 3504b71d385aSAndrei Emeltchenko } 3505b71d385aSAndrei Emeltchenko 3506b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 3507bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 3508b71d385aSAndrei Emeltchenko } 3509b71d385aSAndrei Emeltchenko 35106039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 3511b71d385aSAndrei Emeltchenko { 3512b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3513b71d385aSAndrei Emeltchenko 3514bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 3515bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 3516bd1eb66bSAndrei Emeltchenko return; 3517bd1eb66bSAndrei Emeltchenko 3518bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 3519bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 3520b71d385aSAndrei Emeltchenko return; 3521b71d385aSAndrei Emeltchenko 3522b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 3523b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 3524b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 3525b71d385aSAndrei Emeltchenko break; 3526b71d385aSAndrei Emeltchenko 3527b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 3528b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 3529b71d385aSAndrei Emeltchenko break; 3530b71d385aSAndrei Emeltchenko } 3531b71d385aSAndrei Emeltchenko } 3532b71d385aSAndrei Emeltchenko 35331da177e4SLinus Torvalds /* Schedule SCO */ 35346039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 35351da177e4SLinus Torvalds { 35361da177e4SLinus Torvalds struct hci_conn *conn; 35371da177e4SLinus Torvalds struct sk_buff *skb; 35381da177e4SLinus Torvalds int quote; 35391da177e4SLinus Torvalds 35401da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 35411da177e4SLinus Torvalds 354252087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 354352087a79SLuiz Augusto von Dentz return; 354452087a79SLuiz Augusto von Dentz 35451da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 35461da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 35471da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 354857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 35491da177e4SLinus Torvalds 35501da177e4SLinus Torvalds conn->sent++; 35511da177e4SLinus Torvalds if (conn->sent == ~0) 35521da177e4SLinus Torvalds conn->sent = 0; 35531da177e4SLinus Torvalds } 35541da177e4SLinus Torvalds } 35551da177e4SLinus Torvalds } 35561da177e4SLinus Torvalds 35576039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 3558b6a0dc82SMarcel Holtmann { 3559b6a0dc82SMarcel Holtmann struct hci_conn *conn; 3560b6a0dc82SMarcel Holtmann struct sk_buff *skb; 3561b6a0dc82SMarcel Holtmann int quote; 3562b6a0dc82SMarcel Holtmann 3563b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 3564b6a0dc82SMarcel Holtmann 356552087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 356652087a79SLuiz Augusto von Dentz return; 356752087a79SLuiz Augusto von Dentz 35688fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 35698fc9ced3SGustavo Padovan "e))) { 3570b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 3571b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 357257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3573b6a0dc82SMarcel Holtmann 3574b6a0dc82SMarcel Holtmann conn->sent++; 3575b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 3576b6a0dc82SMarcel Holtmann conn->sent = 0; 3577b6a0dc82SMarcel Holtmann } 3578b6a0dc82SMarcel Holtmann } 3579b6a0dc82SMarcel Holtmann } 3580b6a0dc82SMarcel Holtmann 35816039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 35826ed58ec5SVille Tervo { 358373d80debSLuiz Augusto von Dentz struct hci_chan *chan; 35846ed58ec5SVille Tervo struct sk_buff *skb; 358502b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 35866ed58ec5SVille Tervo 35876ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 35886ed58ec5SVille Tervo 358952087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 359052087a79SLuiz Augusto von Dentz return; 359152087a79SLuiz Augusto von Dentz 35926ed58ec5SVille Tervo if (!test_bit(HCI_RAW, &hdev->flags)) { 35936ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 35946ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 3595bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 35966ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 3597bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 35986ed58ec5SVille Tervo } 35996ed58ec5SVille Tervo 36006ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 360102b20f0bSLuiz Augusto von Dentz tmp = cnt; 360273d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 3603ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3604ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 360573d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 360673d80debSLuiz Augusto von Dentz skb->len, skb->priority); 36076ed58ec5SVille Tervo 3608ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3609ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3610ec1cce24SLuiz Augusto von Dentz break; 3611ec1cce24SLuiz Augusto von Dentz 3612ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3613ec1cce24SLuiz Augusto von Dentz 361457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 36156ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 36166ed58ec5SVille Tervo 36176ed58ec5SVille Tervo cnt--; 361873d80debSLuiz Augusto von Dentz chan->sent++; 361973d80debSLuiz Augusto von Dentz chan->conn->sent++; 36206ed58ec5SVille Tervo } 36216ed58ec5SVille Tervo } 362273d80debSLuiz Augusto von Dentz 36236ed58ec5SVille Tervo if (hdev->le_pkts) 36246ed58ec5SVille Tervo hdev->le_cnt = cnt; 36256ed58ec5SVille Tervo else 36266ed58ec5SVille Tervo hdev->acl_cnt = cnt; 362702b20f0bSLuiz Augusto von Dentz 362802b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 362902b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 36306ed58ec5SVille Tervo } 36316ed58ec5SVille Tervo 36323eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 36331da177e4SLinus Torvalds { 36343eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 36351da177e4SLinus Torvalds struct sk_buff *skb; 36361da177e4SLinus Torvalds 36376ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 36386ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 36391da177e4SLinus Torvalds 364052de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 36411da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 36421da177e4SLinus Torvalds hci_sched_acl(hdev); 36431da177e4SLinus Torvalds hci_sched_sco(hdev); 3644b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 36456ed58ec5SVille Tervo hci_sched_le(hdev); 364652de599eSMarcel Holtmann } 36476ed58ec5SVille Tervo 36481da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 36491da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 365057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 36511da177e4SLinus Torvalds } 36521da177e4SLinus Torvalds 365325985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 36541da177e4SLinus Torvalds 36551da177e4SLinus Torvalds /* ACL data packet */ 36566039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 36571da177e4SLinus Torvalds { 36581da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 36591da177e4SLinus Torvalds struct hci_conn *conn; 36601da177e4SLinus Torvalds __u16 handle, flags; 36611da177e4SLinus Torvalds 36621da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 36631da177e4SLinus Torvalds 36641da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 36651da177e4SLinus Torvalds flags = hci_flags(handle); 36661da177e4SLinus Torvalds handle = hci_handle(handle); 36671da177e4SLinus Torvalds 3668f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 3669a8c5fb1aSGustavo Padovan handle, flags); 36701da177e4SLinus Torvalds 36711da177e4SLinus Torvalds hdev->stat.acl_rx++; 36721da177e4SLinus Torvalds 36731da177e4SLinus Torvalds hci_dev_lock(hdev); 36741da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 36751da177e4SLinus Torvalds hci_dev_unlock(hdev); 36761da177e4SLinus Torvalds 36771da177e4SLinus Torvalds if (conn) { 367865983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 367904837f64SMarcel Holtmann 36801da177e4SLinus Torvalds /* Send to upper protocol */ 3681686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 36821da177e4SLinus Torvalds return; 36831da177e4SLinus Torvalds } else { 36841da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 36851da177e4SLinus Torvalds hdev->name, handle); 36861da177e4SLinus Torvalds } 36871da177e4SLinus Torvalds 36881da177e4SLinus Torvalds kfree_skb(skb); 36891da177e4SLinus Torvalds } 36901da177e4SLinus Torvalds 36911da177e4SLinus Torvalds /* SCO data packet */ 36926039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 36931da177e4SLinus Torvalds { 36941da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 36951da177e4SLinus Torvalds struct hci_conn *conn; 36961da177e4SLinus Torvalds __u16 handle; 36971da177e4SLinus Torvalds 36981da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 36991da177e4SLinus Torvalds 37001da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 37011da177e4SLinus Torvalds 3702f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 37031da177e4SLinus Torvalds 37041da177e4SLinus Torvalds hdev->stat.sco_rx++; 37051da177e4SLinus Torvalds 37061da177e4SLinus Torvalds hci_dev_lock(hdev); 37071da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 37081da177e4SLinus Torvalds hci_dev_unlock(hdev); 37091da177e4SLinus Torvalds 37101da177e4SLinus Torvalds if (conn) { 37111da177e4SLinus Torvalds /* Send to upper protocol */ 3712686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 37131da177e4SLinus Torvalds return; 37141da177e4SLinus Torvalds } else { 37151da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 37161da177e4SLinus Torvalds hdev->name, handle); 37171da177e4SLinus Torvalds } 37181da177e4SLinus Torvalds 37191da177e4SLinus Torvalds kfree_skb(skb); 37201da177e4SLinus Torvalds } 37211da177e4SLinus Torvalds 37229238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 37239238f36aSJohan Hedberg { 37249238f36aSJohan Hedberg struct sk_buff *skb; 37259238f36aSJohan Hedberg 37269238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 37279238f36aSJohan Hedberg if (!skb) 37289238f36aSJohan Hedberg return true; 37299238f36aSJohan Hedberg 37309238f36aSJohan Hedberg return bt_cb(skb)->req.start; 37319238f36aSJohan Hedberg } 37329238f36aSJohan Hedberg 373342c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 373442c6b129SJohan Hedberg { 373542c6b129SJohan Hedberg struct hci_command_hdr *sent; 373642c6b129SJohan Hedberg struct sk_buff *skb; 373742c6b129SJohan Hedberg u16 opcode; 373842c6b129SJohan Hedberg 373942c6b129SJohan Hedberg if (!hdev->sent_cmd) 374042c6b129SJohan Hedberg return; 374142c6b129SJohan Hedberg 374242c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 374342c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 374442c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 374542c6b129SJohan Hedberg return; 374642c6b129SJohan Hedberg 374742c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 374842c6b129SJohan Hedberg if (!skb) 374942c6b129SJohan Hedberg return; 375042c6b129SJohan Hedberg 375142c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 375242c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 375342c6b129SJohan Hedberg } 375442c6b129SJohan Hedberg 37559238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 37569238f36aSJohan Hedberg { 37579238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 37589238f36aSJohan Hedberg struct sk_buff *skb; 37599238f36aSJohan Hedberg unsigned long flags; 37609238f36aSJohan Hedberg 37619238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 37629238f36aSJohan Hedberg 376342c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 376442c6b129SJohan Hedberg * sent we need to do special handling of it. 37659238f36aSJohan Hedberg */ 376642c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 376742c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 376842c6b129SJohan Hedberg * reset complete event during init and any pending 376942c6b129SJohan Hedberg * command will never be completed. In such a case we 377042c6b129SJohan Hedberg * need to resend whatever was the last sent 377142c6b129SJohan Hedberg * command. 377242c6b129SJohan Hedberg */ 377342c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 377442c6b129SJohan Hedberg hci_resend_last(hdev); 377542c6b129SJohan Hedberg 37769238f36aSJohan Hedberg return; 377742c6b129SJohan Hedberg } 37789238f36aSJohan Hedberg 37799238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 37809238f36aSJohan Hedberg * this request the request is not yet complete. 37819238f36aSJohan Hedberg */ 37829238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 37839238f36aSJohan Hedberg return; 37849238f36aSJohan Hedberg 37859238f36aSJohan Hedberg /* If this was the last command in a request the complete 37869238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 37879238f36aSJohan Hedberg * command queue (hdev->cmd_q). 37889238f36aSJohan Hedberg */ 37899238f36aSJohan Hedberg if (hdev->sent_cmd) { 37909238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 379153e21fbcSJohan Hedberg 379253e21fbcSJohan Hedberg if (req_complete) { 379353e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 379453e21fbcSJohan Hedberg * avoid calling the callback more than once if 379553e21fbcSJohan Hedberg * this function gets called again. 379653e21fbcSJohan Hedberg */ 379753e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 379853e21fbcSJohan Hedberg 37999238f36aSJohan Hedberg goto call_complete; 38009238f36aSJohan Hedberg } 380153e21fbcSJohan Hedberg } 38029238f36aSJohan Hedberg 38039238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 38049238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 38059238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 38069238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 38079238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 38089238f36aSJohan Hedberg break; 38099238f36aSJohan Hedberg } 38109238f36aSJohan Hedberg 38119238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 38129238f36aSJohan Hedberg kfree_skb(skb); 38139238f36aSJohan Hedberg } 38149238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 38159238f36aSJohan Hedberg 38169238f36aSJohan Hedberg call_complete: 38179238f36aSJohan Hedberg if (req_complete) 38189238f36aSJohan Hedberg req_complete(hdev, status); 38199238f36aSJohan Hedberg } 38209238f36aSJohan Hedberg 3821b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 38221da177e4SLinus Torvalds { 3823b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 38241da177e4SLinus Torvalds struct sk_buff *skb; 38251da177e4SLinus Torvalds 38261da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 38271da177e4SLinus Torvalds 38281da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 3829cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3830cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3831cd82e61cSMarcel Holtmann 38321da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 38331da177e4SLinus Torvalds /* Send copy to the sockets */ 3834470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 38351da177e4SLinus Torvalds } 38361da177e4SLinus Torvalds 38370736cfa8SMarcel Holtmann if (test_bit(HCI_RAW, &hdev->flags) || 38380736cfa8SMarcel Holtmann test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 38391da177e4SLinus Torvalds kfree_skb(skb); 38401da177e4SLinus Torvalds continue; 38411da177e4SLinus Torvalds } 38421da177e4SLinus Torvalds 38431da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 38441da177e4SLinus Torvalds /* Don't process data packets in this states. */ 38450d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 38461da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 38471da177e4SLinus Torvalds case HCI_SCODATA_PKT: 38481da177e4SLinus Torvalds kfree_skb(skb); 38491da177e4SLinus Torvalds continue; 38503ff50b79SStephen Hemminger } 38511da177e4SLinus Torvalds } 38521da177e4SLinus Torvalds 38531da177e4SLinus Torvalds /* Process frame */ 38540d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 38551da177e4SLinus Torvalds case HCI_EVENT_PKT: 3856b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 38571da177e4SLinus Torvalds hci_event_packet(hdev, skb); 38581da177e4SLinus Torvalds break; 38591da177e4SLinus Torvalds 38601da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 38611da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 38621da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 38631da177e4SLinus Torvalds break; 38641da177e4SLinus Torvalds 38651da177e4SLinus Torvalds case HCI_SCODATA_PKT: 38661da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 38671da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 38681da177e4SLinus Torvalds break; 38691da177e4SLinus Torvalds 38701da177e4SLinus Torvalds default: 38711da177e4SLinus Torvalds kfree_skb(skb); 38721da177e4SLinus Torvalds break; 38731da177e4SLinus Torvalds } 38741da177e4SLinus Torvalds } 38751da177e4SLinus Torvalds } 38761da177e4SLinus Torvalds 3877c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 38781da177e4SLinus Torvalds { 3879c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 38801da177e4SLinus Torvalds struct sk_buff *skb; 38811da177e4SLinus Torvalds 38822104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 38832104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 38841da177e4SLinus Torvalds 38851da177e4SLinus Torvalds /* Send queued commands */ 38865a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 38875a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 38885a08ecceSAndrei Emeltchenko if (!skb) 38895a08ecceSAndrei Emeltchenko return; 38905a08ecceSAndrei Emeltchenko 38911da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 38921da177e4SLinus Torvalds 3893a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 389470f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 38951da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 389657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 38977bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 38987bdb8a5cSSzymon Janc del_timer(&hdev->cmd_timer); 38997bdb8a5cSSzymon Janc else 39006bd32326SVille Tervo mod_timer(&hdev->cmd_timer, 39015f246e89SAndrei Emeltchenko jiffies + HCI_CMD_TIMEOUT); 39021da177e4SLinus Torvalds } else { 39031da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 3904c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 39051da177e4SLinus Torvalds } 39061da177e4SLinus Torvalds } 39071da177e4SLinus Torvalds } 3908