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) 6870afe0b8SMarcel Holtmann seq_printf(f, "%pMR\n", &b->bdaddr); 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 198e7b8fc92SMarcel Holtmann static int static_address_show(struct seq_file *f, void *p) 199e7b8fc92SMarcel Holtmann { 200e7b8fc92SMarcel Holtmann struct hci_dev *hdev = f->private; 201e7b8fc92SMarcel Holtmann 202e7b8fc92SMarcel Holtmann hci_dev_lock(hdev); 203e7b8fc92SMarcel Holtmann seq_printf(f, "%pMR\n", &hdev->static_addr); 204e7b8fc92SMarcel Holtmann hci_dev_unlock(hdev); 205e7b8fc92SMarcel Holtmann 206e7b8fc92SMarcel Holtmann return 0; 207e7b8fc92SMarcel Holtmann } 208e7b8fc92SMarcel Holtmann 209e7b8fc92SMarcel Holtmann static int static_address_open(struct inode *inode, struct file *file) 210e7b8fc92SMarcel Holtmann { 211e7b8fc92SMarcel Holtmann return single_open(file, static_address_show, inode->i_private); 212e7b8fc92SMarcel Holtmann } 213e7b8fc92SMarcel Holtmann 214e7b8fc92SMarcel Holtmann static const struct file_operations static_address_fops = { 215e7b8fc92SMarcel Holtmann .open = static_address_open, 216e7b8fc92SMarcel Holtmann .read = seq_read, 217e7b8fc92SMarcel Holtmann .llseek = seq_lseek, 218e7b8fc92SMarcel Holtmann .release = single_release, 219e7b8fc92SMarcel Holtmann }; 220e7b8fc92SMarcel Holtmann 2211da177e4SLinus Torvalds /* ---- HCI requests ---- */ 2221da177e4SLinus Torvalds 22342c6b129SJohan Hedberg static void hci_req_sync_complete(struct hci_dev *hdev, u8 result) 2241da177e4SLinus Torvalds { 22542c6b129SJohan Hedberg BT_DBG("%s result 0x%2.2x", hdev->name, result); 22675fb0e32SJohan Hedberg 2271da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 2281da177e4SLinus Torvalds hdev->req_result = result; 2291da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 2301da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 2311da177e4SLinus Torvalds } 2321da177e4SLinus Torvalds } 2331da177e4SLinus Torvalds 2341da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 2351da177e4SLinus Torvalds { 2361da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 2371da177e4SLinus Torvalds 2381da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 2391da177e4SLinus Torvalds hdev->req_result = err; 2401da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 2411da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 2421da177e4SLinus Torvalds } 2431da177e4SLinus Torvalds } 2441da177e4SLinus Torvalds 24577a63e0aSFengguang Wu static struct sk_buff *hci_get_cmd_complete(struct hci_dev *hdev, u16 opcode, 24677a63e0aSFengguang Wu u8 event) 24775e84b7cSJohan Hedberg { 24875e84b7cSJohan Hedberg struct hci_ev_cmd_complete *ev; 24975e84b7cSJohan Hedberg struct hci_event_hdr *hdr; 25075e84b7cSJohan Hedberg struct sk_buff *skb; 25175e84b7cSJohan Hedberg 25275e84b7cSJohan Hedberg hci_dev_lock(hdev); 25375e84b7cSJohan Hedberg 25475e84b7cSJohan Hedberg skb = hdev->recv_evt; 25575e84b7cSJohan Hedberg hdev->recv_evt = NULL; 25675e84b7cSJohan Hedberg 25775e84b7cSJohan Hedberg hci_dev_unlock(hdev); 25875e84b7cSJohan Hedberg 25975e84b7cSJohan Hedberg if (!skb) 26075e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 26175e84b7cSJohan Hedberg 26275e84b7cSJohan Hedberg if (skb->len < sizeof(*hdr)) { 26375e84b7cSJohan Hedberg BT_ERR("Too short HCI event"); 26475e84b7cSJohan Hedberg goto failed; 26575e84b7cSJohan Hedberg } 26675e84b7cSJohan Hedberg 26775e84b7cSJohan Hedberg hdr = (void *) skb->data; 26875e84b7cSJohan Hedberg skb_pull(skb, HCI_EVENT_HDR_SIZE); 26975e84b7cSJohan Hedberg 2707b1abbbeSJohan Hedberg if (event) { 2717b1abbbeSJohan Hedberg if (hdr->evt != event) 2727b1abbbeSJohan Hedberg goto failed; 2737b1abbbeSJohan Hedberg return skb; 2747b1abbbeSJohan Hedberg } 2757b1abbbeSJohan Hedberg 27675e84b7cSJohan Hedberg if (hdr->evt != HCI_EV_CMD_COMPLETE) { 27775e84b7cSJohan Hedberg BT_DBG("Last event is not cmd complete (0x%2.2x)", hdr->evt); 27875e84b7cSJohan Hedberg goto failed; 27975e84b7cSJohan Hedberg } 28075e84b7cSJohan Hedberg 28175e84b7cSJohan Hedberg if (skb->len < sizeof(*ev)) { 28275e84b7cSJohan Hedberg BT_ERR("Too short cmd_complete event"); 28375e84b7cSJohan Hedberg goto failed; 28475e84b7cSJohan Hedberg } 28575e84b7cSJohan Hedberg 28675e84b7cSJohan Hedberg ev = (void *) skb->data; 28775e84b7cSJohan Hedberg skb_pull(skb, sizeof(*ev)); 28875e84b7cSJohan Hedberg 28975e84b7cSJohan Hedberg if (opcode == __le16_to_cpu(ev->opcode)) 29075e84b7cSJohan Hedberg return skb; 29175e84b7cSJohan Hedberg 29275e84b7cSJohan Hedberg BT_DBG("opcode doesn't match (0x%2.2x != 0x%2.2x)", opcode, 29375e84b7cSJohan Hedberg __le16_to_cpu(ev->opcode)); 29475e84b7cSJohan Hedberg 29575e84b7cSJohan Hedberg failed: 29675e84b7cSJohan Hedberg kfree_skb(skb); 29775e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 29875e84b7cSJohan Hedberg } 29975e84b7cSJohan Hedberg 3007b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, 30107dc93ddSJohan Hedberg const void *param, u8 event, u32 timeout) 30275e84b7cSJohan Hedberg { 30375e84b7cSJohan Hedberg DECLARE_WAITQUEUE(wait, current); 30475e84b7cSJohan Hedberg struct hci_request req; 30575e84b7cSJohan Hedberg int err = 0; 30675e84b7cSJohan Hedberg 30775e84b7cSJohan Hedberg BT_DBG("%s", hdev->name); 30875e84b7cSJohan Hedberg 30975e84b7cSJohan Hedberg hci_req_init(&req, hdev); 31075e84b7cSJohan Hedberg 3117b1abbbeSJohan Hedberg hci_req_add_ev(&req, opcode, plen, param, event); 31275e84b7cSJohan Hedberg 31375e84b7cSJohan Hedberg hdev->req_status = HCI_REQ_PEND; 31475e84b7cSJohan Hedberg 31575e84b7cSJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 31675e84b7cSJohan Hedberg if (err < 0) 31775e84b7cSJohan Hedberg return ERR_PTR(err); 31875e84b7cSJohan Hedberg 31975e84b7cSJohan Hedberg add_wait_queue(&hdev->req_wait_q, &wait); 32075e84b7cSJohan Hedberg set_current_state(TASK_INTERRUPTIBLE); 32175e84b7cSJohan Hedberg 32275e84b7cSJohan Hedberg schedule_timeout(timeout); 32375e84b7cSJohan Hedberg 32475e84b7cSJohan Hedberg remove_wait_queue(&hdev->req_wait_q, &wait); 32575e84b7cSJohan Hedberg 32675e84b7cSJohan Hedberg if (signal_pending(current)) 32775e84b7cSJohan Hedberg return ERR_PTR(-EINTR); 32875e84b7cSJohan Hedberg 32975e84b7cSJohan Hedberg switch (hdev->req_status) { 33075e84b7cSJohan Hedberg case HCI_REQ_DONE: 33175e84b7cSJohan Hedberg err = -bt_to_errno(hdev->req_result); 33275e84b7cSJohan Hedberg break; 33375e84b7cSJohan Hedberg 33475e84b7cSJohan Hedberg case HCI_REQ_CANCELED: 33575e84b7cSJohan Hedberg err = -hdev->req_result; 33675e84b7cSJohan Hedberg break; 33775e84b7cSJohan Hedberg 33875e84b7cSJohan Hedberg default: 33975e84b7cSJohan Hedberg err = -ETIMEDOUT; 34075e84b7cSJohan Hedberg break; 34175e84b7cSJohan Hedberg } 34275e84b7cSJohan Hedberg 34375e84b7cSJohan Hedberg hdev->req_status = hdev->req_result = 0; 34475e84b7cSJohan Hedberg 34575e84b7cSJohan Hedberg BT_DBG("%s end: err %d", hdev->name, err); 34675e84b7cSJohan Hedberg 34775e84b7cSJohan Hedberg if (err < 0) 34875e84b7cSJohan Hedberg return ERR_PTR(err); 34975e84b7cSJohan Hedberg 3507b1abbbeSJohan Hedberg return hci_get_cmd_complete(hdev, opcode, event); 3517b1abbbeSJohan Hedberg } 3527b1abbbeSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync_ev); 3537b1abbbeSJohan Hedberg 3547b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 35507dc93ddSJohan Hedberg const void *param, u32 timeout) 3567b1abbbeSJohan Hedberg { 3577b1abbbeSJohan Hedberg return __hci_cmd_sync_ev(hdev, opcode, plen, param, 0, timeout); 35875e84b7cSJohan Hedberg } 35975e84b7cSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync); 36075e84b7cSJohan Hedberg 3611da177e4SLinus Torvalds /* Execute request and wait for completion. */ 36201178cd4SJohan Hedberg static int __hci_req_sync(struct hci_dev *hdev, 36342c6b129SJohan Hedberg void (*func)(struct hci_request *req, 36442c6b129SJohan Hedberg unsigned long opt), 3651da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 3661da177e4SLinus Torvalds { 36742c6b129SJohan Hedberg struct hci_request req; 3681da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 3691da177e4SLinus Torvalds int err = 0; 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 3721da177e4SLinus Torvalds 37342c6b129SJohan Hedberg hci_req_init(&req, hdev); 37442c6b129SJohan Hedberg 3751da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 3761da177e4SLinus Torvalds 37742c6b129SJohan Hedberg func(&req, opt); 37853cce22dSJohan Hedberg 37942c6b129SJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 38042c6b129SJohan Hedberg if (err < 0) { 38153cce22dSJohan Hedberg hdev->req_status = 0; 382920c8300SAndre Guedes 383920c8300SAndre Guedes /* ENODATA means the HCI request command queue is empty. 384920c8300SAndre Guedes * This can happen when a request with conditionals doesn't 385920c8300SAndre Guedes * trigger any commands to be sent. This is normal behavior 386920c8300SAndre Guedes * and should not trigger an error return. 38742c6b129SJohan Hedberg */ 388920c8300SAndre Guedes if (err == -ENODATA) 38942c6b129SJohan Hedberg return 0; 390920c8300SAndre Guedes 391920c8300SAndre Guedes return err; 39253cce22dSJohan Hedberg } 39353cce22dSJohan Hedberg 394bc4445c7SAndre Guedes add_wait_queue(&hdev->req_wait_q, &wait); 395bc4445c7SAndre Guedes set_current_state(TASK_INTERRUPTIBLE); 396bc4445c7SAndre Guedes 3971da177e4SLinus Torvalds schedule_timeout(timeout); 3981da177e4SLinus Torvalds 3991da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 4001da177e4SLinus Torvalds 4011da177e4SLinus Torvalds if (signal_pending(current)) 4021da177e4SLinus Torvalds return -EINTR; 4031da177e4SLinus Torvalds 4041da177e4SLinus Torvalds switch (hdev->req_status) { 4051da177e4SLinus Torvalds case HCI_REQ_DONE: 406e175072fSJoe Perches err = -bt_to_errno(hdev->req_result); 4071da177e4SLinus Torvalds break; 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds case HCI_REQ_CANCELED: 4101da177e4SLinus Torvalds err = -hdev->req_result; 4111da177e4SLinus Torvalds break; 4121da177e4SLinus Torvalds 4131da177e4SLinus Torvalds default: 4141da177e4SLinus Torvalds err = -ETIMEDOUT; 4151da177e4SLinus Torvalds break; 4163ff50b79SStephen Hemminger } 4171da177e4SLinus Torvalds 418a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 4191da177e4SLinus Torvalds 4201da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 4211da177e4SLinus Torvalds 4221da177e4SLinus Torvalds return err; 4231da177e4SLinus Torvalds } 4241da177e4SLinus Torvalds 42501178cd4SJohan Hedberg static int hci_req_sync(struct hci_dev *hdev, 42642c6b129SJohan Hedberg void (*req)(struct hci_request *req, 42742c6b129SJohan Hedberg unsigned long opt), 4281da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 4291da177e4SLinus Torvalds { 4301da177e4SLinus Torvalds int ret; 4311da177e4SLinus Torvalds 4327c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 4337c6a329eSMarcel Holtmann return -ENETDOWN; 4347c6a329eSMarcel Holtmann 4351da177e4SLinus Torvalds /* Serialize all requests */ 4361da177e4SLinus Torvalds hci_req_lock(hdev); 43701178cd4SJohan Hedberg ret = __hci_req_sync(hdev, req, opt, timeout); 4381da177e4SLinus Torvalds hci_req_unlock(hdev); 4391da177e4SLinus Torvalds 4401da177e4SLinus Torvalds return ret; 4411da177e4SLinus Torvalds } 4421da177e4SLinus Torvalds 44342c6b129SJohan Hedberg static void hci_reset_req(struct hci_request *req, unsigned long opt) 4441da177e4SLinus Torvalds { 44542c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 4461da177e4SLinus Torvalds 4471da177e4SLinus Torvalds /* Reset device */ 44842c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 44942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 4501da177e4SLinus Torvalds } 4511da177e4SLinus Torvalds 45242c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 4531da177e4SLinus Torvalds { 45442c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 4552455a3eaSAndrei Emeltchenko 4561da177e4SLinus Torvalds /* Read Local Supported Features */ 45742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 4581da177e4SLinus Torvalds 4591143e5a6SMarcel Holtmann /* Read Local Version */ 46042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 4612177bab5SJohan Hedberg 4622177bab5SJohan Hedberg /* Read BD Address */ 46342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 4641da177e4SLinus Torvalds } 4651da177e4SLinus Torvalds 46642c6b129SJohan Hedberg static void amp_init(struct hci_request *req) 467e61ef499SAndrei Emeltchenko { 46842c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 4692455a3eaSAndrei Emeltchenko 470e61ef499SAndrei Emeltchenko /* Read Local Version */ 47142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 4726bcbc489SAndrei Emeltchenko 473f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 474f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 475f6996cfeSMarcel Holtmann 476f6996cfeSMarcel Holtmann /* Read Local Supported Features */ 477f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 478f6996cfeSMarcel Holtmann 4796bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 48042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 481e71dfabaSAndrei Emeltchenko 482e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 48342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 4847528ca1cSMarcel Holtmann 485f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 486f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 487f38ba941SMarcel Holtmann 4887528ca1cSMarcel Holtmann /* Read Location Data */ 4897528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 490e61ef499SAndrei Emeltchenko } 491e61ef499SAndrei Emeltchenko 49242c6b129SJohan Hedberg static void hci_init1_req(struct hci_request *req, unsigned long opt) 493e61ef499SAndrei Emeltchenko { 49442c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 495e61ef499SAndrei Emeltchenko 496e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 497e61ef499SAndrei Emeltchenko 49811778716SAndrei Emeltchenko /* Reset */ 49911778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 50042c6b129SJohan Hedberg hci_reset_req(req, 0); 50111778716SAndrei Emeltchenko 502e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 503e61ef499SAndrei Emeltchenko case HCI_BREDR: 50442c6b129SJohan Hedberg bredr_init(req); 505e61ef499SAndrei Emeltchenko break; 506e61ef499SAndrei Emeltchenko 507e61ef499SAndrei Emeltchenko case HCI_AMP: 50842c6b129SJohan Hedberg amp_init(req); 509e61ef499SAndrei Emeltchenko break; 510e61ef499SAndrei Emeltchenko 511e61ef499SAndrei Emeltchenko default: 512e61ef499SAndrei Emeltchenko BT_ERR("Unknown device type %d", hdev->dev_type); 513e61ef499SAndrei Emeltchenko break; 514e61ef499SAndrei Emeltchenko } 515e61ef499SAndrei Emeltchenko } 516e61ef499SAndrei Emeltchenko 51742c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 5182177bab5SJohan Hedberg { 5194ca048e3SMarcel Holtmann struct hci_dev *hdev = req->hdev; 5204ca048e3SMarcel Holtmann 5212177bab5SJohan Hedberg __le16 param; 5222177bab5SJohan Hedberg __u8 flt_type; 5232177bab5SJohan Hedberg 5242177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 52542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 5262177bab5SJohan Hedberg 5272177bab5SJohan Hedberg /* Read Class of Device */ 52842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 5292177bab5SJohan Hedberg 5302177bab5SJohan Hedberg /* Read Local Name */ 53142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 5322177bab5SJohan Hedberg 5332177bab5SJohan Hedberg /* Read Voice Setting */ 53442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 5352177bab5SJohan Hedberg 536b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 537b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 538b4cb9fb2SMarcel Holtmann 5394b836f39SMarcel Holtmann /* Read Current IAC LAP */ 5404b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 5414b836f39SMarcel Holtmann 5422177bab5SJohan Hedberg /* Clear Event Filters */ 5432177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 54442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 5452177bab5SJohan Hedberg 5462177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 5472177bab5SJohan Hedberg param = __constant_cpu_to_le16(0x7d00); 54842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 5492177bab5SJohan Hedberg 5504ca048e3SMarcel Holtmann /* AVM Berlin (31), aka "BlueFRITZ!", reports version 1.2, 5514ca048e3SMarcel Holtmann * but it does not support page scan related HCI commands. 5524ca048e3SMarcel Holtmann */ 5534ca048e3SMarcel Holtmann if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) { 554f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 555f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 556f332ec66SJohan Hedberg } 5572177bab5SJohan Hedberg } 5582177bab5SJohan Hedberg 55942c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 5602177bab5SJohan Hedberg { 561c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 562c73eee91SJohan Hedberg 5632177bab5SJohan Hedberg /* Read LE Buffer Size */ 56442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 5652177bab5SJohan Hedberg 5662177bab5SJohan Hedberg /* Read LE Local Supported Features */ 56742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 5682177bab5SJohan Hedberg 5692177bab5SJohan Hedberg /* Read LE Advertising Channel TX Power */ 57042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 5712177bab5SJohan Hedberg 5722177bab5SJohan Hedberg /* Read LE White List Size */ 57342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 0, NULL); 5742177bab5SJohan Hedberg 5752177bab5SJohan Hedberg /* Read LE Supported States */ 57642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 577c73eee91SJohan Hedberg 578c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 579c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 580c73eee91SJohan Hedberg set_bit(HCI_LE_ENABLED, &hdev->dev_flags); 5812177bab5SJohan Hedberg } 5822177bab5SJohan Hedberg 5832177bab5SJohan Hedberg static u8 hci_get_inquiry_mode(struct hci_dev *hdev) 5842177bab5SJohan Hedberg { 5852177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 5862177bab5SJohan Hedberg return 0x02; 5872177bab5SJohan Hedberg 5882177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 5892177bab5SJohan Hedberg return 0x01; 5902177bab5SJohan Hedberg 5912177bab5SJohan Hedberg if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 && 5922177bab5SJohan Hedberg hdev->lmp_subver == 0x0757) 5932177bab5SJohan Hedberg return 0x01; 5942177bab5SJohan Hedberg 5952177bab5SJohan Hedberg if (hdev->manufacturer == 15) { 5962177bab5SJohan Hedberg if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963) 5972177bab5SJohan Hedberg return 0x01; 5982177bab5SJohan Hedberg if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963) 5992177bab5SJohan Hedberg return 0x01; 6002177bab5SJohan Hedberg if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965) 6012177bab5SJohan Hedberg return 0x01; 6022177bab5SJohan Hedberg } 6032177bab5SJohan Hedberg 6042177bab5SJohan Hedberg if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 && 6052177bab5SJohan Hedberg hdev->lmp_subver == 0x1805) 6062177bab5SJohan Hedberg return 0x01; 6072177bab5SJohan Hedberg 6082177bab5SJohan Hedberg return 0x00; 6092177bab5SJohan Hedberg } 6102177bab5SJohan Hedberg 61142c6b129SJohan Hedberg static void hci_setup_inquiry_mode(struct hci_request *req) 6122177bab5SJohan Hedberg { 6132177bab5SJohan Hedberg u8 mode; 6142177bab5SJohan Hedberg 61542c6b129SJohan Hedberg mode = hci_get_inquiry_mode(req->hdev); 6162177bab5SJohan Hedberg 61742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 6182177bab5SJohan Hedberg } 6192177bab5SJohan Hedberg 62042c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 6212177bab5SJohan Hedberg { 62242c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 62342c6b129SJohan Hedberg 6242177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 6252177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 6262177bab5SJohan Hedberg * command otherwise. 6272177bab5SJohan Hedberg */ 6282177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 6292177bab5SJohan Hedberg 6302177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 6312177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 6322177bab5SJohan Hedberg */ 6332177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 6342177bab5SJohan Hedberg return; 6352177bab5SJohan Hedberg 6362177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 6372177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 6382177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 6392177bab5SJohan Hedberg events[4] |= 0x04; /* Read Remote Extended Features Complete */ 6402177bab5SJohan Hedberg events[5] |= 0x08; /* Synchronous Connection Complete */ 6412177bab5SJohan Hedberg events[5] |= 0x10; /* Synchronous Connection Changed */ 642c7882cbdSMarcel Holtmann } else { 643c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 644c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 645c7882cbdSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 646c7882cbdSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 647c7882cbdSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information Complete */ 648c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 649c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 650c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 651c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 652c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 653c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 6542177bab5SJohan Hedberg } 6552177bab5SJohan Hedberg 6562177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 6572177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 6582177bab5SJohan Hedberg 6592177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 6602177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 6612177bab5SJohan Hedberg 6622177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 6632177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 6642177bab5SJohan Hedberg 6652177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 6662177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 6672177bab5SJohan Hedberg 6682177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 6692177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 6702177bab5SJohan Hedberg 6712177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 6722177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 6732177bab5SJohan Hedberg 6742177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 6752177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 6762177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 6772177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 6782177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 6792177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 6802177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 6812177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 6822177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 6832177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 6842177bab5SJohan Hedberg * Features Notification 6852177bab5SJohan Hedberg */ 6862177bab5SJohan Hedberg } 6872177bab5SJohan Hedberg 6882177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 6892177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 6902177bab5SJohan Hedberg 69142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 6922177bab5SJohan Hedberg 6932177bab5SJohan Hedberg if (lmp_le_capable(hdev)) { 6942177bab5SJohan Hedberg memset(events, 0, sizeof(events)); 6952177bab5SJohan Hedberg events[0] = 0x1f; 69642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, 6972177bab5SJohan Hedberg sizeof(events), events); 6982177bab5SJohan Hedberg } 6992177bab5SJohan Hedberg } 7002177bab5SJohan Hedberg 70142c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 7022177bab5SJohan Hedberg { 70342c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 70442c6b129SJohan Hedberg 7052177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 70642c6b129SJohan Hedberg bredr_setup(req); 70756f87901SJohan Hedberg else 70856f87901SJohan Hedberg clear_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 7092177bab5SJohan Hedberg 7102177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 71142c6b129SJohan Hedberg le_setup(req); 7122177bab5SJohan Hedberg 71342c6b129SJohan Hedberg hci_setup_event_mask(req); 7142177bab5SJohan Hedberg 7153f8e2d75SJohan Hedberg /* AVM Berlin (31), aka "BlueFRITZ!", doesn't support the read 7163f8e2d75SJohan Hedberg * local supported commands HCI command. 7173f8e2d75SJohan Hedberg */ 7183f8e2d75SJohan Hedberg if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) 71942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 7202177bab5SJohan Hedberg 7212177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 7222177bab5SJohan Hedberg if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) { 7232177bab5SJohan Hedberg u8 mode = 0x01; 72442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 7252177bab5SJohan Hedberg sizeof(mode), &mode); 7262177bab5SJohan Hedberg } else { 7272177bab5SJohan Hedberg struct hci_cp_write_eir cp; 7282177bab5SJohan Hedberg 7292177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 7302177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 7312177bab5SJohan Hedberg 73242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 7332177bab5SJohan Hedberg } 7342177bab5SJohan Hedberg } 7352177bab5SJohan Hedberg 7362177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 73742c6b129SJohan Hedberg hci_setup_inquiry_mode(req); 7382177bab5SJohan Hedberg 7392177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 74042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 7412177bab5SJohan Hedberg 7422177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 7432177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 7442177bab5SJohan Hedberg 7452177bab5SJohan Hedberg cp.page = 0x01; 74642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 74742c6b129SJohan Hedberg sizeof(cp), &cp); 7482177bab5SJohan Hedberg } 7492177bab5SJohan Hedberg 7502177bab5SJohan Hedberg if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) { 7512177bab5SJohan Hedberg u8 enable = 1; 75242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 7532177bab5SJohan Hedberg &enable); 7542177bab5SJohan Hedberg } 7552177bab5SJohan Hedberg } 7562177bab5SJohan Hedberg 75742c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 7582177bab5SJohan Hedberg { 75942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 7602177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 7612177bab5SJohan Hedberg u16 link_policy = 0; 7622177bab5SJohan Hedberg 7632177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 7642177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 7652177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 7662177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 7672177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 7682177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 7692177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 7702177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 7712177bab5SJohan Hedberg 7722177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 77342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 7742177bab5SJohan Hedberg } 7752177bab5SJohan Hedberg 77642c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 7772177bab5SJohan Hedberg { 77842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 7792177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 7802177bab5SJohan Hedberg 781c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 782c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 783c73eee91SJohan Hedberg return; 784c73eee91SJohan Hedberg 7852177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 7862177bab5SJohan Hedberg 7872177bab5SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) { 7882177bab5SJohan Hedberg cp.le = 0x01; 7892177bab5SJohan Hedberg cp.simul = lmp_le_br_capable(hdev); 7902177bab5SJohan Hedberg } 7912177bab5SJohan Hedberg 7922177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 79342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 7942177bab5SJohan Hedberg &cp); 7952177bab5SJohan Hedberg } 7962177bab5SJohan Hedberg 797d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 798d62e6d67SJohan Hedberg { 799d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 800d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 801d62e6d67SJohan Hedberg 802d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 803d62e6d67SJohan Hedberg * enable all necessary events for it. 804d62e6d67SJohan Hedberg */ 805d62e6d67SJohan Hedberg if (hdev->features[2][0] & 0x01) { 806d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 807d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 808d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 809d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 810d62e6d67SJohan Hedberg } 811d62e6d67SJohan Hedberg 812d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 813d62e6d67SJohan Hedberg * enable all necessary events for it. 814d62e6d67SJohan Hedberg */ 815d62e6d67SJohan Hedberg if (hdev->features[2][0] & 0x02) { 816d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 817d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 818d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 819d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 820d62e6d67SJohan Hedberg } 821d62e6d67SJohan Hedberg 822d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 823d62e6d67SJohan Hedberg } 824d62e6d67SJohan Hedberg 82542c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 8262177bab5SJohan Hedberg { 82742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 828d2c5d77fSJohan Hedberg u8 p; 82942c6b129SJohan Hedberg 830b8f4e068SGustavo Padovan /* Some Broadcom based Bluetooth controllers do not support the 831b8f4e068SGustavo Padovan * Delete Stored Link Key command. They are clearly indicating its 832b8f4e068SGustavo Padovan * absence in the bit mask of supported commands. 833b8f4e068SGustavo Padovan * 834b8f4e068SGustavo Padovan * Check the supported commands and only if the the command is marked 835b8f4e068SGustavo Padovan * as supported send it. If not supported assume that the controller 836b8f4e068SGustavo Padovan * does not have actual support for stored link keys which makes this 837b8f4e068SGustavo Padovan * command redundant anyway. 838b8f4e068SGustavo Padovan */ 83959f45d57SJohan Hedberg if (hdev->commands[6] & 0x80) { 84059f45d57SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 84159f45d57SJohan Hedberg 84259f45d57SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 84359f45d57SJohan Hedberg cp.delete_all = 0x01; 84459f45d57SJohan Hedberg hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 84559f45d57SJohan Hedberg sizeof(cp), &cp); 84659f45d57SJohan Hedberg } 84759f45d57SJohan Hedberg 8482177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 84942c6b129SJohan Hedberg hci_setup_link_policy(req); 8502177bab5SJohan Hedberg 851441ad2d0SMarcel Holtmann if (lmp_le_capable(hdev)) 85242c6b129SJohan Hedberg hci_set_le_support(req); 853d2c5d77fSJohan Hedberg 854d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 855d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 856d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 857d2c5d77fSJohan Hedberg 858d2c5d77fSJohan Hedberg cp.page = p; 859d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 860d2c5d77fSJohan Hedberg sizeof(cp), &cp); 861d2c5d77fSJohan Hedberg } 8622177bab5SJohan Hedberg } 8632177bab5SJohan Hedberg 8645d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 8655d4e7e8dSJohan Hedberg { 8665d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 8675d4e7e8dSJohan Hedberg 868d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 869d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 870d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 871d62e6d67SJohan Hedberg 8725d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 8735d4e7e8dSJohan Hedberg if (hdev->features[2][0] & 0x04) 8745d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 8755d4e7e8dSJohan Hedberg } 8765d4e7e8dSJohan Hedberg 8772177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 8782177bab5SJohan Hedberg { 8792177bab5SJohan Hedberg int err; 8802177bab5SJohan Hedberg 8812177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 8822177bab5SJohan Hedberg if (err < 0) 8832177bab5SJohan Hedberg return err; 8842177bab5SJohan Hedberg 8852177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 8862177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 8872177bab5SJohan Hedberg * first stage init. 8882177bab5SJohan Hedberg */ 8892177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 8902177bab5SJohan Hedberg return 0; 8912177bab5SJohan Hedberg 8922177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 8932177bab5SJohan Hedberg if (err < 0) 8942177bab5SJohan Hedberg return err; 8952177bab5SJohan Hedberg 8965d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 8975d4e7e8dSJohan Hedberg if (err < 0) 8985d4e7e8dSJohan Hedberg return err; 8995d4e7e8dSJohan Hedberg 900baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 901baf27f6eSMarcel Holtmann if (err < 0) 902baf27f6eSMarcel Holtmann return err; 903baf27f6eSMarcel Holtmann 904baf27f6eSMarcel Holtmann /* Only create debugfs entries during the initial setup 905baf27f6eSMarcel Holtmann * phase and not every time the controller gets powered on. 906baf27f6eSMarcel Holtmann */ 907baf27f6eSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 908baf27f6eSMarcel Holtmann return 0; 909baf27f6eSMarcel Holtmann 91070afe0b8SMarcel Holtmann debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev, 91170afe0b8SMarcel Holtmann &blacklist_fops); 91270afe0b8SMarcel Holtmann 91347219839SMarcel Holtmann debugfs_create_file("uuids", 0444, hdev->debugfs, hdev, &uuids_fops); 91447219839SMarcel Holtmann 915baf27f6eSMarcel Holtmann if (lmp_bredr_capable(hdev)) { 916baf27f6eSMarcel Holtmann debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, 917baf27f6eSMarcel Holtmann hdev, &inquiry_cache_fops); 918041000b9SMarcel Holtmann debugfs_create_file("voice_setting", 0444, hdev->debugfs, 919041000b9SMarcel Holtmann hdev, &voice_setting_fops); 920baf27f6eSMarcel Holtmann } 921baf27f6eSMarcel Holtmann 922ebd1e33bSMarcel Holtmann if (lmp_ssp_capable(hdev)) 923ebd1e33bSMarcel Holtmann debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 924ebd1e33bSMarcel Holtmann hdev, &auto_accept_delay_fops); 925ebd1e33bSMarcel Holtmann 926e7b8fc92SMarcel Holtmann if (lmp_le_capable(hdev)) 927e7b8fc92SMarcel Holtmann debugfs_create_file("static_address", 0444, hdev->debugfs, 928e7b8fc92SMarcel Holtmann hdev, &static_address_fops); 929e7b8fc92SMarcel Holtmann 930baf27f6eSMarcel Holtmann return 0; 9312177bab5SJohan Hedberg } 9322177bab5SJohan Hedberg 93342c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 9341da177e4SLinus Torvalds { 9351da177e4SLinus Torvalds __u8 scan = opt; 9361da177e4SLinus Torvalds 93742c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 9381da177e4SLinus Torvalds 9391da177e4SLinus Torvalds /* Inquiry and Page scans */ 94042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 9411da177e4SLinus Torvalds } 9421da177e4SLinus Torvalds 94342c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 9441da177e4SLinus Torvalds { 9451da177e4SLinus Torvalds __u8 auth = opt; 9461da177e4SLinus Torvalds 94742c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 9481da177e4SLinus Torvalds 9491da177e4SLinus Torvalds /* Authentication */ 95042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 9511da177e4SLinus Torvalds } 9521da177e4SLinus Torvalds 95342c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 9541da177e4SLinus Torvalds { 9551da177e4SLinus Torvalds __u8 encrypt = opt; 9561da177e4SLinus Torvalds 95742c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 9581da177e4SLinus Torvalds 959e4e8e37cSMarcel Holtmann /* Encryption */ 96042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 9611da177e4SLinus Torvalds } 9621da177e4SLinus Torvalds 96342c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 964e4e8e37cSMarcel Holtmann { 965e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 966e4e8e37cSMarcel Holtmann 96742c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 968e4e8e37cSMarcel Holtmann 969e4e8e37cSMarcel Holtmann /* Default link policy */ 97042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 971e4e8e37cSMarcel Holtmann } 972e4e8e37cSMarcel Holtmann 9731da177e4SLinus Torvalds /* Get HCI device by index. 9741da177e4SLinus Torvalds * Device is held on return. */ 9751da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 9761da177e4SLinus Torvalds { 9778035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 9781da177e4SLinus Torvalds 9791da177e4SLinus Torvalds BT_DBG("%d", index); 9801da177e4SLinus Torvalds 9811da177e4SLinus Torvalds if (index < 0) 9821da177e4SLinus Torvalds return NULL; 9831da177e4SLinus Torvalds 9841da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 9858035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 9861da177e4SLinus Torvalds if (d->id == index) { 9871da177e4SLinus Torvalds hdev = hci_dev_hold(d); 9881da177e4SLinus Torvalds break; 9891da177e4SLinus Torvalds } 9901da177e4SLinus Torvalds } 9911da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 9921da177e4SLinus Torvalds return hdev; 9931da177e4SLinus Torvalds } 9941da177e4SLinus Torvalds 9951da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 996ff9ef578SJohan Hedberg 99730dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 99830dc78e1SJohan Hedberg { 99930dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 100030dc78e1SJohan Hedberg 10016fbe195dSAndre Guedes switch (discov->state) { 1002343f935bSAndre Guedes case DISCOVERY_FINDING: 10036fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 100430dc78e1SJohan Hedberg return true; 100530dc78e1SJohan Hedberg 10066fbe195dSAndre Guedes default: 100730dc78e1SJohan Hedberg return false; 100830dc78e1SJohan Hedberg } 10096fbe195dSAndre Guedes } 101030dc78e1SJohan Hedberg 1011ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1012ff9ef578SJohan Hedberg { 1013ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1014ff9ef578SJohan Hedberg 1015ff9ef578SJohan Hedberg if (hdev->discovery.state == state) 1016ff9ef578SJohan Hedberg return; 1017ff9ef578SJohan Hedberg 1018ff9ef578SJohan Hedberg switch (state) { 1019ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 10207b99b659SAndre Guedes if (hdev->discovery.state != DISCOVERY_STARTING) 1021ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1022ff9ef578SJohan Hedberg break; 1023ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1024ff9ef578SJohan Hedberg break; 1025343f935bSAndre Guedes case DISCOVERY_FINDING: 1026ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1027ff9ef578SJohan Hedberg break; 102830dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 102930dc78e1SJohan Hedberg break; 1030ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1031ff9ef578SJohan Hedberg break; 1032ff9ef578SJohan Hedberg } 1033ff9ef578SJohan Hedberg 1034ff9ef578SJohan Hedberg hdev->discovery.state = state; 1035ff9ef578SJohan Hedberg } 1036ff9ef578SJohan Hedberg 10371f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 10381da177e4SLinus Torvalds { 103930883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1040b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 10411da177e4SLinus Torvalds 1042561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1043561aafbcSJohan Hedberg list_del(&p->all); 1044b57c1a56SJohan Hedberg kfree(p); 10451da177e4SLinus Torvalds } 1046561aafbcSJohan Hedberg 1047561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1048561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 10491da177e4SLinus Torvalds } 10501da177e4SLinus Torvalds 1051a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1052a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 10531da177e4SLinus Torvalds { 105430883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 10551da177e4SLinus Torvalds struct inquiry_entry *e; 10561da177e4SLinus Torvalds 10576ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 10581da177e4SLinus Torvalds 1059561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 10601da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 10611da177e4SLinus Torvalds return e; 10621da177e4SLinus Torvalds } 10631da177e4SLinus Torvalds 1064b57c1a56SJohan Hedberg return NULL; 1065b57c1a56SJohan Hedberg } 1066b57c1a56SJohan Hedberg 1067561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1068561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1069561aafbcSJohan Hedberg { 107030883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1071561aafbcSJohan Hedberg struct inquiry_entry *e; 1072561aafbcSJohan Hedberg 10736ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1074561aafbcSJohan Hedberg 1075561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1076561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1077561aafbcSJohan Hedberg return e; 1078561aafbcSJohan Hedberg } 1079561aafbcSJohan Hedberg 1080561aafbcSJohan Hedberg return NULL; 1081561aafbcSJohan Hedberg } 1082561aafbcSJohan Hedberg 108330dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 108430dc78e1SJohan Hedberg bdaddr_t *bdaddr, 108530dc78e1SJohan Hedberg int state) 108630dc78e1SJohan Hedberg { 108730dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 108830dc78e1SJohan Hedberg struct inquiry_entry *e; 108930dc78e1SJohan Hedberg 10906ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 109130dc78e1SJohan Hedberg 109230dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 109330dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 109430dc78e1SJohan Hedberg return e; 109530dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 109630dc78e1SJohan Hedberg return e; 109730dc78e1SJohan Hedberg } 109830dc78e1SJohan Hedberg 109930dc78e1SJohan Hedberg return NULL; 110030dc78e1SJohan Hedberg } 110130dc78e1SJohan Hedberg 1102a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1103a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1104a3d4e20aSJohan Hedberg { 1105a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1106a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1107a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1108a3d4e20aSJohan Hedberg 1109a3d4e20aSJohan Hedberg list_del(&ie->list); 1110a3d4e20aSJohan Hedberg 1111a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1112a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1113a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1114a3d4e20aSJohan Hedberg break; 1115a3d4e20aSJohan Hedberg pos = &p->list; 1116a3d4e20aSJohan Hedberg } 1117a3d4e20aSJohan Hedberg 1118a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1119a3d4e20aSJohan Hedberg } 1120a3d4e20aSJohan Hedberg 11213175405bSJohan Hedberg bool hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1122388fc8faSJohan Hedberg bool name_known, bool *ssp) 11231da177e4SLinus Torvalds { 112430883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 112570f23020SAndrei Emeltchenko struct inquiry_entry *ie; 11261da177e4SLinus Torvalds 11276ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 11281da177e4SLinus Torvalds 11292b2fec4dSSzymon Janc hci_remove_remote_oob_data(hdev, &data->bdaddr); 11302b2fec4dSSzymon Janc 1131388fc8faSJohan Hedberg if (ssp) 1132388fc8faSJohan Hedberg *ssp = data->ssp_mode; 1133388fc8faSJohan Hedberg 113470f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1135a3d4e20aSJohan Hedberg if (ie) { 1136388fc8faSJohan Hedberg if (ie->data.ssp_mode && ssp) 1137388fc8faSJohan Hedberg *ssp = true; 1138388fc8faSJohan Hedberg 1139a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1140a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1141a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1142a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1143a3d4e20aSJohan Hedberg } 1144a3d4e20aSJohan Hedberg 1145561aafbcSJohan Hedberg goto update; 1146a3d4e20aSJohan Hedberg } 1147561aafbcSJohan Hedberg 11481da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 114970f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 115070f23020SAndrei Emeltchenko if (!ie) 11513175405bSJohan Hedberg return false; 115270f23020SAndrei Emeltchenko 1153561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1154561aafbcSJohan Hedberg 1155561aafbcSJohan Hedberg if (name_known) { 1156561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1157561aafbcSJohan Hedberg } else { 1158561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1159561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1160561aafbcSJohan Hedberg } 1161561aafbcSJohan Hedberg 1162561aafbcSJohan Hedberg update: 1163561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1164561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1165561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1166561aafbcSJohan Hedberg list_del(&ie->list); 11671da177e4SLinus Torvalds } 11681da177e4SLinus Torvalds 116970f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 117070f23020SAndrei Emeltchenko ie->timestamp = jiffies; 11711da177e4SLinus Torvalds cache->timestamp = jiffies; 11723175405bSJohan Hedberg 11733175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 11743175405bSJohan Hedberg return false; 11753175405bSJohan Hedberg 11763175405bSJohan Hedberg return true; 11771da177e4SLinus Torvalds } 11781da177e4SLinus Torvalds 11791da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 11801da177e4SLinus Torvalds { 118130883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 11821da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 11831da177e4SLinus Torvalds struct inquiry_entry *e; 11841da177e4SLinus Torvalds int copied = 0; 11851da177e4SLinus Torvalds 1186561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 11871da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1188b57c1a56SJohan Hedberg 1189b57c1a56SJohan Hedberg if (copied >= num) 1190b57c1a56SJohan Hedberg break; 1191b57c1a56SJohan Hedberg 11921da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 11931da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 11941da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 11951da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 11961da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 11971da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1198b57c1a56SJohan Hedberg 11991da177e4SLinus Torvalds info++; 1200b57c1a56SJohan Hedberg copied++; 12011da177e4SLinus Torvalds } 12021da177e4SLinus Torvalds 12031da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 12041da177e4SLinus Torvalds return copied; 12051da177e4SLinus Torvalds } 12061da177e4SLinus Torvalds 120742c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 12081da177e4SLinus Torvalds { 12091da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 121042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 12111da177e4SLinus Torvalds struct hci_cp_inquiry cp; 12121da177e4SLinus Torvalds 12131da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 12141da177e4SLinus Torvalds 12151da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 12161da177e4SLinus Torvalds return; 12171da177e4SLinus Torvalds 12181da177e4SLinus Torvalds /* Start Inquiry */ 12191da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 12201da177e4SLinus Torvalds cp.length = ir->length; 12211da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 122242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 12231da177e4SLinus Torvalds } 12241da177e4SLinus Torvalds 12253e13fa1eSAndre Guedes static int wait_inquiry(void *word) 12263e13fa1eSAndre Guedes { 12273e13fa1eSAndre Guedes schedule(); 12283e13fa1eSAndre Guedes return signal_pending(current); 12293e13fa1eSAndre Guedes } 12303e13fa1eSAndre Guedes 12311da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 12321da177e4SLinus Torvalds { 12331da177e4SLinus Torvalds __u8 __user *ptr = arg; 12341da177e4SLinus Torvalds struct hci_inquiry_req ir; 12351da177e4SLinus Torvalds struct hci_dev *hdev; 12361da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 12371da177e4SLinus Torvalds long timeo; 12381da177e4SLinus Torvalds __u8 *buf; 12391da177e4SLinus Torvalds 12401da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 12411da177e4SLinus Torvalds return -EFAULT; 12421da177e4SLinus Torvalds 12435a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 12445a08ecceSAndrei Emeltchenko if (!hdev) 12451da177e4SLinus Torvalds return -ENODEV; 12461da177e4SLinus Torvalds 12470736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 12480736cfa8SMarcel Holtmann err = -EBUSY; 12490736cfa8SMarcel Holtmann goto done; 12500736cfa8SMarcel Holtmann } 12510736cfa8SMarcel Holtmann 12525b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 12535b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 12545b69bef5SMarcel Holtmann goto done; 12555b69bef5SMarcel Holtmann } 12565b69bef5SMarcel Holtmann 125756f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 125856f87901SJohan Hedberg err = -EOPNOTSUPP; 125956f87901SJohan Hedberg goto done; 126056f87901SJohan Hedberg } 126156f87901SJohan Hedberg 126209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 12631da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1264a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 12651f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 12661da177e4SLinus Torvalds do_inquiry = 1; 12671da177e4SLinus Torvalds } 126809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 12691da177e4SLinus Torvalds 127004837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 127170f23020SAndrei Emeltchenko 127270f23020SAndrei Emeltchenko if (do_inquiry) { 127301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 127401178cd4SJohan Hedberg timeo); 127570f23020SAndrei Emeltchenko if (err < 0) 12761da177e4SLinus Torvalds goto done; 12773e13fa1eSAndre Guedes 12783e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 12793e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 12803e13fa1eSAndre Guedes */ 12813e13fa1eSAndre Guedes if (wait_on_bit(&hdev->flags, HCI_INQUIRY, wait_inquiry, 12823e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 12833e13fa1eSAndre Guedes return -EINTR; 128470f23020SAndrei Emeltchenko } 12851da177e4SLinus Torvalds 12868fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 12878fc9ced3SGustavo Padovan * 255 entries 12888fc9ced3SGustavo Padovan */ 12891da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 12901da177e4SLinus Torvalds 12911da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 12921da177e4SLinus Torvalds * copy it to the user space. 12931da177e4SLinus Torvalds */ 129470f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 129570f23020SAndrei Emeltchenko if (!buf) { 12961da177e4SLinus Torvalds err = -ENOMEM; 12971da177e4SLinus Torvalds goto done; 12981da177e4SLinus Torvalds } 12991da177e4SLinus Torvalds 130009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13011da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 130209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13031da177e4SLinus Torvalds 13041da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 13051da177e4SLinus Torvalds 13061da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 13071da177e4SLinus Torvalds ptr += sizeof(ir); 13081da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 13091da177e4SLinus Torvalds ir.num_rsp)) 13101da177e4SLinus Torvalds err = -EFAULT; 13111da177e4SLinus Torvalds } else 13121da177e4SLinus Torvalds err = -EFAULT; 13131da177e4SLinus Torvalds 13141da177e4SLinus Torvalds kfree(buf); 13151da177e4SLinus Torvalds 13161da177e4SLinus Torvalds done: 13171da177e4SLinus Torvalds hci_dev_put(hdev); 13181da177e4SLinus Torvalds return err; 13191da177e4SLinus Torvalds } 13201da177e4SLinus Torvalds 1321cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 13221da177e4SLinus Torvalds { 13231da177e4SLinus Torvalds int ret = 0; 13241da177e4SLinus Torvalds 13251da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 13261da177e4SLinus Torvalds 13271da177e4SLinus Torvalds hci_req_lock(hdev); 13281da177e4SLinus Torvalds 132994324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 133094324962SJohan Hovold ret = -ENODEV; 133194324962SJohan Hovold goto done; 133294324962SJohan Hovold } 133394324962SJohan Hovold 1334a5c8f270SMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) { 1335a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1336a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1337bf543036SJohan Hedberg */ 1338a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 1339611b30f7SMarcel Holtmann ret = -ERFKILL; 1340611b30f7SMarcel Holtmann goto done; 1341611b30f7SMarcel Holtmann } 1342611b30f7SMarcel Holtmann 1343a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1344a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1345a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1346a5c8f270SMarcel Holtmann * or not. 1347a5c8f270SMarcel Holtmann * 1348a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1349a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1350a5c8f270SMarcel Holtmann */ 1351a5c8f270SMarcel Holtmann if (hdev->dev_type == HCI_BREDR && 1352a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1353a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1354a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1355a5c8f270SMarcel Holtmann goto done; 1356a5c8f270SMarcel Holtmann } 1357a5c8f270SMarcel Holtmann } 1358a5c8f270SMarcel Holtmann 13591da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 13601da177e4SLinus Torvalds ret = -EALREADY; 13611da177e4SLinus Torvalds goto done; 13621da177e4SLinus Torvalds } 13631da177e4SLinus Torvalds 13641da177e4SLinus Torvalds if (hdev->open(hdev)) { 13651da177e4SLinus Torvalds ret = -EIO; 13661da177e4SLinus Torvalds goto done; 13671da177e4SLinus Torvalds } 13681da177e4SLinus Torvalds 13691da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 13701da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1371f41c70c4SMarcel Holtmann 1372f41c70c4SMarcel Holtmann if (hdev->setup && test_bit(HCI_SETUP, &hdev->dev_flags)) 1373f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1374f41c70c4SMarcel Holtmann 1375f41c70c4SMarcel Holtmann if (!ret) { 1376f41c70c4SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 1377f41c70c4SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 1378f41c70c4SMarcel Holtmann 13790736cfa8SMarcel Holtmann if (!test_bit(HCI_RAW, &hdev->flags) && 13800736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 13812177bab5SJohan Hedberg ret = __hci_init(hdev); 13821da177e4SLinus Torvalds } 13831da177e4SLinus Torvalds 1384f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1385f41c70c4SMarcel Holtmann 13861da177e4SLinus Torvalds if (!ret) { 13871da177e4SLinus Torvalds hci_dev_hold(hdev); 13881da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 13891da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 1390bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 13910736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 13921514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 139309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1394744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 139509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 139656e5cb86SJohan Hedberg } 13971da177e4SLinus Torvalds } else { 13981da177e4SLinus Torvalds /* Init failed, cleanup */ 13993eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1400c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1401b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 14021da177e4SLinus Torvalds 14031da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 14041da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 14051da177e4SLinus Torvalds 14061da177e4SLinus Torvalds if (hdev->flush) 14071da177e4SLinus Torvalds hdev->flush(hdev); 14081da177e4SLinus Torvalds 14091da177e4SLinus Torvalds if (hdev->sent_cmd) { 14101da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 14111da177e4SLinus Torvalds hdev->sent_cmd = NULL; 14121da177e4SLinus Torvalds } 14131da177e4SLinus Torvalds 14141da177e4SLinus Torvalds hdev->close(hdev); 14151da177e4SLinus Torvalds hdev->flags = 0; 14161da177e4SLinus Torvalds } 14171da177e4SLinus Torvalds 14181da177e4SLinus Torvalds done: 14191da177e4SLinus Torvalds hci_req_unlock(hdev); 14201da177e4SLinus Torvalds return ret; 14211da177e4SLinus Torvalds } 14221da177e4SLinus Torvalds 1423cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1424cbed0ca1SJohan Hedberg 1425cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1426cbed0ca1SJohan Hedberg { 1427cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1428cbed0ca1SJohan Hedberg int err; 1429cbed0ca1SJohan Hedberg 1430cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1431cbed0ca1SJohan Hedberg if (!hdev) 1432cbed0ca1SJohan Hedberg return -ENODEV; 1433cbed0ca1SJohan Hedberg 1434e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1435e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1436e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1437e1d08f40SJohan Hedberg * completed. 1438e1d08f40SJohan Hedberg */ 1439e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 1440e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1441e1d08f40SJohan Hedberg 1442a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1443a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1444a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1445a5c8f270SMarcel Holtmann */ 1446e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1447e1d08f40SJohan Hedberg 1448cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1449cbed0ca1SJohan Hedberg 1450cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1451cbed0ca1SJohan Hedberg 1452cbed0ca1SJohan Hedberg return err; 1453cbed0ca1SJohan Hedberg } 1454cbed0ca1SJohan Hedberg 14551da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 14561da177e4SLinus Torvalds { 14571da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 14581da177e4SLinus Torvalds 145978c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 146078c04c0bSVinicius Costa Gomes 14611da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 14621da177e4SLinus Torvalds hci_req_lock(hdev); 14631da177e4SLinus Torvalds 14641da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 1465b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 14661da177e4SLinus Torvalds hci_req_unlock(hdev); 14671da177e4SLinus Torvalds return 0; 14681da177e4SLinus Torvalds } 14691da177e4SLinus Torvalds 14703eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 14713eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1472b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 14731da177e4SLinus Torvalds 147416ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 1475e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 147616ab91abSJohan Hedberg hdev->discov_timeout = 0; 14775e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 1478310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 147916ab91abSJohan Hedberg } 148016ab91abSJohan Hedberg 1481a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 14827d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 14837d78525dSJohan Hedberg 14847ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 14857ba8b4beSAndre Guedes 148609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 14871f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 14881da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 148909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 14901da177e4SLinus Torvalds 14911da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 14921da177e4SLinus Torvalds 14931da177e4SLinus Torvalds if (hdev->flush) 14941da177e4SLinus Torvalds hdev->flush(hdev); 14951da177e4SLinus Torvalds 14961da177e4SLinus Torvalds /* Reset device */ 14971da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 14981da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 14998af59467SJohan Hedberg if (!test_bit(HCI_RAW, &hdev->flags) && 15003a6afbd2SMarcel Holtmann !test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 1501a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 15021da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 150301178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 15041da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 15051da177e4SLinus Torvalds } 15061da177e4SLinus Torvalds 1507c347b765SGustavo F. Padovan /* flush cmd work */ 1508c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 15091da177e4SLinus Torvalds 15101da177e4SLinus Torvalds /* Drop queues */ 15111da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 15121da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 15131da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 15141da177e4SLinus Torvalds 15151da177e4SLinus Torvalds /* Drop last sent command */ 15161da177e4SLinus Torvalds if (hdev->sent_cmd) { 1517b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 15181da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 15191da177e4SLinus Torvalds hdev->sent_cmd = NULL; 15201da177e4SLinus Torvalds } 15211da177e4SLinus Torvalds 1522b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 1523b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 1524b6ddb638SJohan Hedberg 15251da177e4SLinus Torvalds /* After this point our queues are empty 15261da177e4SLinus Torvalds * and no tasks are scheduled. */ 15271da177e4SLinus Torvalds hdev->close(hdev); 15281da177e4SLinus Torvalds 152935b973c9SJohan Hedberg /* Clear flags */ 153035b973c9SJohan Hedberg hdev->flags = 0; 153135b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 153235b973c9SJohan Hedberg 153393c311a0SMarcel Holtmann if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 153493c311a0SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 153509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1536744cf19eSJohan Hedberg mgmt_powered(hdev, 0); 153709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 15388ee56540SMarcel Holtmann } 153993c311a0SMarcel Holtmann } 15405add6af8SJohan Hedberg 1541ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1542536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1543ced5c338SAndrei Emeltchenko 1544e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 154509b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 1546e59fda8dSJohan Hedberg 15471da177e4SLinus Torvalds hci_req_unlock(hdev); 15481da177e4SLinus Torvalds 15491da177e4SLinus Torvalds hci_dev_put(hdev); 15501da177e4SLinus Torvalds return 0; 15511da177e4SLinus Torvalds } 15521da177e4SLinus Torvalds 15531da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 15541da177e4SLinus Torvalds { 15551da177e4SLinus Torvalds struct hci_dev *hdev; 15561da177e4SLinus Torvalds int err; 15571da177e4SLinus Torvalds 155870f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 155970f23020SAndrei Emeltchenko if (!hdev) 15601da177e4SLinus Torvalds return -ENODEV; 15618ee56540SMarcel Holtmann 15620736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 15630736cfa8SMarcel Holtmann err = -EBUSY; 15640736cfa8SMarcel Holtmann goto done; 15650736cfa8SMarcel Holtmann } 15660736cfa8SMarcel Holtmann 15678ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 15688ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 15698ee56540SMarcel Holtmann 15701da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 15718ee56540SMarcel Holtmann 15720736cfa8SMarcel Holtmann done: 15731da177e4SLinus Torvalds hci_dev_put(hdev); 15741da177e4SLinus Torvalds return err; 15751da177e4SLinus Torvalds } 15761da177e4SLinus Torvalds 15771da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 15781da177e4SLinus Torvalds { 15791da177e4SLinus Torvalds struct hci_dev *hdev; 15801da177e4SLinus Torvalds int ret = 0; 15811da177e4SLinus Torvalds 158270f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 158370f23020SAndrei Emeltchenko if (!hdev) 15841da177e4SLinus Torvalds return -ENODEV; 15851da177e4SLinus Torvalds 15861da177e4SLinus Torvalds hci_req_lock(hdev); 15871da177e4SLinus Torvalds 1588808a049eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 1589808a049eSMarcel Holtmann ret = -ENETDOWN; 15901da177e4SLinus Torvalds goto done; 1591808a049eSMarcel Holtmann } 15921da177e4SLinus Torvalds 15930736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 15940736cfa8SMarcel Holtmann ret = -EBUSY; 15950736cfa8SMarcel Holtmann goto done; 15960736cfa8SMarcel Holtmann } 15970736cfa8SMarcel Holtmann 15981da177e4SLinus Torvalds /* Drop queues */ 15991da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 16001da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16011da177e4SLinus Torvalds 160209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 16031f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 16041da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 160509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 16061da177e4SLinus Torvalds 16071da177e4SLinus Torvalds if (hdev->flush) 16081da177e4SLinus Torvalds hdev->flush(hdev); 16091da177e4SLinus Torvalds 16101da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 16116ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 16121da177e4SLinus Torvalds 16131da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 161401178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 16151da177e4SLinus Torvalds 16161da177e4SLinus Torvalds done: 16171da177e4SLinus Torvalds hci_req_unlock(hdev); 16181da177e4SLinus Torvalds hci_dev_put(hdev); 16191da177e4SLinus Torvalds return ret; 16201da177e4SLinus Torvalds } 16211da177e4SLinus Torvalds 16221da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 16231da177e4SLinus Torvalds { 16241da177e4SLinus Torvalds struct hci_dev *hdev; 16251da177e4SLinus Torvalds int ret = 0; 16261da177e4SLinus Torvalds 162770f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 162870f23020SAndrei Emeltchenko if (!hdev) 16291da177e4SLinus Torvalds return -ENODEV; 16301da177e4SLinus Torvalds 16310736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 16320736cfa8SMarcel Holtmann ret = -EBUSY; 16330736cfa8SMarcel Holtmann goto done; 16340736cfa8SMarcel Holtmann } 16350736cfa8SMarcel Holtmann 16361da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 16371da177e4SLinus Torvalds 16380736cfa8SMarcel Holtmann done: 16391da177e4SLinus Torvalds hci_dev_put(hdev); 16401da177e4SLinus Torvalds return ret; 16411da177e4SLinus Torvalds } 16421da177e4SLinus Torvalds 16431da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 16441da177e4SLinus Torvalds { 16451da177e4SLinus Torvalds struct hci_dev *hdev; 16461da177e4SLinus Torvalds struct hci_dev_req dr; 16471da177e4SLinus Torvalds int err = 0; 16481da177e4SLinus Torvalds 16491da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 16501da177e4SLinus Torvalds return -EFAULT; 16511da177e4SLinus Torvalds 165270f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 165370f23020SAndrei Emeltchenko if (!hdev) 16541da177e4SLinus Torvalds return -ENODEV; 16551da177e4SLinus Torvalds 16560736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 16570736cfa8SMarcel Holtmann err = -EBUSY; 16580736cfa8SMarcel Holtmann goto done; 16590736cfa8SMarcel Holtmann } 16600736cfa8SMarcel Holtmann 16615b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 16625b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 16635b69bef5SMarcel Holtmann goto done; 16645b69bef5SMarcel Holtmann } 16655b69bef5SMarcel Holtmann 166656f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 166756f87901SJohan Hedberg err = -EOPNOTSUPP; 166856f87901SJohan Hedberg goto done; 166956f87901SJohan Hedberg } 167056f87901SJohan Hedberg 16711da177e4SLinus Torvalds switch (cmd) { 16721da177e4SLinus Torvalds case HCISETAUTH: 167301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 16745f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 16751da177e4SLinus Torvalds break; 16761da177e4SLinus Torvalds 16771da177e4SLinus Torvalds case HCISETENCRYPT: 16781da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 16791da177e4SLinus Torvalds err = -EOPNOTSUPP; 16801da177e4SLinus Torvalds break; 16811da177e4SLinus Torvalds } 16821da177e4SLinus Torvalds 16831da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 16841da177e4SLinus Torvalds /* Auth must be enabled first */ 168501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 16865f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 16871da177e4SLinus Torvalds if (err) 16881da177e4SLinus Torvalds break; 16891da177e4SLinus Torvalds } 16901da177e4SLinus Torvalds 169101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 16925f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 16931da177e4SLinus Torvalds break; 16941da177e4SLinus Torvalds 16951da177e4SLinus Torvalds case HCISETSCAN: 169601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 16975f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 16981da177e4SLinus Torvalds break; 16991da177e4SLinus Torvalds 17001da177e4SLinus Torvalds case HCISETLINKPOL: 170101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 17025f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 17031da177e4SLinus Torvalds break; 17041da177e4SLinus Torvalds 17051da177e4SLinus Torvalds case HCISETLINKMODE: 1706e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 1707e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 1708e4e8e37cSMarcel Holtmann break; 1709e4e8e37cSMarcel Holtmann 1710e4e8e37cSMarcel Holtmann case HCISETPTYPE: 1711e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 17121da177e4SLinus Torvalds break; 17131da177e4SLinus Torvalds 17141da177e4SLinus Torvalds case HCISETACLMTU: 17151da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 17161da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 17171da177e4SLinus Torvalds break; 17181da177e4SLinus Torvalds 17191da177e4SLinus Torvalds case HCISETSCOMTU: 17201da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 17211da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 17221da177e4SLinus Torvalds break; 17231da177e4SLinus Torvalds 17241da177e4SLinus Torvalds default: 17251da177e4SLinus Torvalds err = -EINVAL; 17261da177e4SLinus Torvalds break; 17271da177e4SLinus Torvalds } 1728e4e8e37cSMarcel Holtmann 17290736cfa8SMarcel Holtmann done: 17301da177e4SLinus Torvalds hci_dev_put(hdev); 17311da177e4SLinus Torvalds return err; 17321da177e4SLinus Torvalds } 17331da177e4SLinus Torvalds 17341da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 17351da177e4SLinus Torvalds { 17368035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 17371da177e4SLinus Torvalds struct hci_dev_list_req *dl; 17381da177e4SLinus Torvalds struct hci_dev_req *dr; 17391da177e4SLinus Torvalds int n = 0, size, err; 17401da177e4SLinus Torvalds __u16 dev_num; 17411da177e4SLinus Torvalds 17421da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 17431da177e4SLinus Torvalds return -EFAULT; 17441da177e4SLinus Torvalds 17451da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 17461da177e4SLinus Torvalds return -EINVAL; 17471da177e4SLinus Torvalds 17481da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 17491da177e4SLinus Torvalds 175070f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 175170f23020SAndrei Emeltchenko if (!dl) 17521da177e4SLinus Torvalds return -ENOMEM; 17531da177e4SLinus Torvalds 17541da177e4SLinus Torvalds dr = dl->dev_req; 17551da177e4SLinus Torvalds 1756f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 17578035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 1758a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 1759e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->power_off); 1760c542a06cSJohan Hedberg 1761a8b2d5c2SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 1762a8b2d5c2SJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->dev_flags); 1763c542a06cSJohan Hedberg 17641da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 17651da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 1766c542a06cSJohan Hedberg 17671da177e4SLinus Torvalds if (++n >= dev_num) 17681da177e4SLinus Torvalds break; 17691da177e4SLinus Torvalds } 1770f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 17711da177e4SLinus Torvalds 17721da177e4SLinus Torvalds dl->dev_num = n; 17731da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 17741da177e4SLinus Torvalds 17751da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 17761da177e4SLinus Torvalds kfree(dl); 17771da177e4SLinus Torvalds 17781da177e4SLinus Torvalds return err ? -EFAULT : 0; 17791da177e4SLinus Torvalds } 17801da177e4SLinus Torvalds 17811da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 17821da177e4SLinus Torvalds { 17831da177e4SLinus Torvalds struct hci_dev *hdev; 17841da177e4SLinus Torvalds struct hci_dev_info di; 17851da177e4SLinus Torvalds int err = 0; 17861da177e4SLinus Torvalds 17871da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 17881da177e4SLinus Torvalds return -EFAULT; 17891da177e4SLinus Torvalds 179070f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 179170f23020SAndrei Emeltchenko if (!hdev) 17921da177e4SLinus Torvalds return -ENODEV; 17931da177e4SLinus Torvalds 1794a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 17953243553fSJohan Hedberg cancel_delayed_work_sync(&hdev->power_off); 1796ab81cbf9SJohan Hedberg 1797a8b2d5c2SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 1798a8b2d5c2SJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->dev_flags); 1799c542a06cSJohan Hedberg 18001da177e4SLinus Torvalds strcpy(di.name, hdev->name); 18011da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 180260f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 18031da177e4SLinus Torvalds di.flags = hdev->flags; 18041da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 1805572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 18061da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 18071da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 18081da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 18091da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 1810572c7f84SJohan Hedberg } else { 1811572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 1812572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 1813572c7f84SJohan Hedberg di.sco_mtu = 0; 1814572c7f84SJohan Hedberg di.sco_pkts = 0; 1815572c7f84SJohan Hedberg } 18161da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 18171da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 18181da177e4SLinus Torvalds 18191da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 18201da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 18211da177e4SLinus Torvalds 18221da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 18231da177e4SLinus Torvalds err = -EFAULT; 18241da177e4SLinus Torvalds 18251da177e4SLinus Torvalds hci_dev_put(hdev); 18261da177e4SLinus Torvalds 18271da177e4SLinus Torvalds return err; 18281da177e4SLinus Torvalds } 18291da177e4SLinus Torvalds 18301da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 18311da177e4SLinus Torvalds 1832611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 1833611b30f7SMarcel Holtmann { 1834611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 1835611b30f7SMarcel Holtmann 1836611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 1837611b30f7SMarcel Holtmann 18380736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 18390736cfa8SMarcel Holtmann return -EBUSY; 18400736cfa8SMarcel Holtmann 18415e130367SJohan Hedberg if (blocked) { 18425e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 1843bf543036SJohan Hedberg if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 1844611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 18455e130367SJohan Hedberg } else { 18465e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 18475e130367SJohan Hedberg } 1848611b30f7SMarcel Holtmann 1849611b30f7SMarcel Holtmann return 0; 1850611b30f7SMarcel Holtmann } 1851611b30f7SMarcel Holtmann 1852611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 1853611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 1854611b30f7SMarcel Holtmann }; 1855611b30f7SMarcel Holtmann 1856ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 1857ab81cbf9SJohan Hedberg { 1858ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 185996570ffcSJohan Hedberg int err; 1860ab81cbf9SJohan Hedberg 1861ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 1862ab81cbf9SJohan Hedberg 1863cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 186496570ffcSJohan Hedberg if (err < 0) { 186596570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 1866ab81cbf9SJohan Hedberg return; 186796570ffcSJohan Hedberg } 1868ab81cbf9SJohan Hedberg 1869a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 1870a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 1871a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 1872a5c8f270SMarcel Holtmann */ 1873a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 1874a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 1875a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1876a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 1877bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 1878bf543036SJohan Hedberg hci_dev_do_close(hdev); 1879bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 188019202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 188119202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 1882bf543036SJohan Hedberg } 1883ab81cbf9SJohan Hedberg 1884a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) 1885744cf19eSJohan Hedberg mgmt_index_added(hdev); 1886ab81cbf9SJohan Hedberg } 1887ab81cbf9SJohan Hedberg 1888ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 1889ab81cbf9SJohan Hedberg { 18903243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 18913243553fSJohan Hedberg power_off.work); 1892ab81cbf9SJohan Hedberg 1893ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 1894ab81cbf9SJohan Hedberg 18958ee56540SMarcel Holtmann hci_dev_do_close(hdev); 1896ab81cbf9SJohan Hedberg } 1897ab81cbf9SJohan Hedberg 189816ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 189916ab91abSJohan Hedberg { 190016ab91abSJohan Hedberg struct hci_dev *hdev; 190116ab91abSJohan Hedberg 190216ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 190316ab91abSJohan Hedberg 190416ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 190516ab91abSJohan Hedberg 1906d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 190716ab91abSJohan Hedberg } 190816ab91abSJohan Hedberg 19092aeb9a1aSJohan Hedberg int hci_uuids_clear(struct hci_dev *hdev) 19102aeb9a1aSJohan Hedberg { 19114821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 19122aeb9a1aSJohan Hedberg 19134821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 19144821002cSJohan Hedberg list_del(&uuid->list); 19152aeb9a1aSJohan Hedberg kfree(uuid); 19162aeb9a1aSJohan Hedberg } 19172aeb9a1aSJohan Hedberg 19182aeb9a1aSJohan Hedberg return 0; 19192aeb9a1aSJohan Hedberg } 19202aeb9a1aSJohan Hedberg 192155ed8ca1SJohan Hedberg int hci_link_keys_clear(struct hci_dev *hdev) 192255ed8ca1SJohan Hedberg { 192355ed8ca1SJohan Hedberg struct list_head *p, *n; 192455ed8ca1SJohan Hedberg 192555ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 192655ed8ca1SJohan Hedberg struct link_key *key; 192755ed8ca1SJohan Hedberg 192855ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 192955ed8ca1SJohan Hedberg 193055ed8ca1SJohan Hedberg list_del(p); 193155ed8ca1SJohan Hedberg kfree(key); 193255ed8ca1SJohan Hedberg } 193355ed8ca1SJohan Hedberg 193455ed8ca1SJohan Hedberg return 0; 193555ed8ca1SJohan Hedberg } 193655ed8ca1SJohan Hedberg 1937b899efafSVinicius Costa Gomes int hci_smp_ltks_clear(struct hci_dev *hdev) 1938b899efafSVinicius Costa Gomes { 1939b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 1940b899efafSVinicius Costa Gomes 1941b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 1942b899efafSVinicius Costa Gomes list_del(&k->list); 1943b899efafSVinicius Costa Gomes kfree(k); 1944b899efafSVinicius Costa Gomes } 1945b899efafSVinicius Costa Gomes 1946b899efafSVinicius Costa Gomes return 0; 1947b899efafSVinicius Costa Gomes } 1948b899efafSVinicius Costa Gomes 194955ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 195055ed8ca1SJohan Hedberg { 195155ed8ca1SJohan Hedberg struct link_key *k; 195255ed8ca1SJohan Hedberg 19538035ded4SLuiz Augusto von Dentz list_for_each_entry(k, &hdev->link_keys, list) 195455ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 195555ed8ca1SJohan Hedberg return k; 195655ed8ca1SJohan Hedberg 195755ed8ca1SJohan Hedberg return NULL; 195855ed8ca1SJohan Hedberg } 195955ed8ca1SJohan Hedberg 1960745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 1961d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 1962d25e28abSJohan Hedberg { 1963d25e28abSJohan Hedberg /* Legacy key */ 1964d25e28abSJohan Hedberg if (key_type < 0x03) 1965745c0ce3SVishal Agarwal return true; 1966d25e28abSJohan Hedberg 1967d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 1968d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 1969745c0ce3SVishal Agarwal return false; 1970d25e28abSJohan Hedberg 1971d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 1972d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 1973745c0ce3SVishal Agarwal return false; 1974d25e28abSJohan Hedberg 1975d25e28abSJohan Hedberg /* Security mode 3 case */ 1976d25e28abSJohan Hedberg if (!conn) 1977745c0ce3SVishal Agarwal return true; 1978d25e28abSJohan Hedberg 1979d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 1980d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 1981745c0ce3SVishal Agarwal return true; 1982d25e28abSJohan Hedberg 1983d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 1984d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 1985745c0ce3SVishal Agarwal return true; 1986d25e28abSJohan Hedberg 1987d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 1988d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 1989745c0ce3SVishal Agarwal return true; 1990d25e28abSJohan Hedberg 1991d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 1992d25e28abSJohan Hedberg * persistently */ 1993745c0ce3SVishal Agarwal return false; 1994d25e28abSJohan Hedberg } 1995d25e28abSJohan Hedberg 1996c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8]) 199775d262c2SVinicius Costa Gomes { 1998c9839a11SVinicius Costa Gomes struct smp_ltk *k; 199975d262c2SVinicius Costa Gomes 2000c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) { 2001c9839a11SVinicius Costa Gomes if (k->ediv != ediv || 2002c9839a11SVinicius Costa Gomes memcmp(rand, k->rand, sizeof(k->rand))) 200375d262c2SVinicius Costa Gomes continue; 200475d262c2SVinicius Costa Gomes 200575d262c2SVinicius Costa Gomes return k; 200675d262c2SVinicius Costa Gomes } 200775d262c2SVinicius Costa Gomes 200875d262c2SVinicius Costa Gomes return NULL; 200975d262c2SVinicius Costa Gomes } 201075d262c2SVinicius Costa Gomes 2011c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2012c9839a11SVinicius Costa Gomes u8 addr_type) 201375d262c2SVinicius Costa Gomes { 2014c9839a11SVinicius Costa Gomes struct smp_ltk *k; 201575d262c2SVinicius Costa Gomes 2016c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) 2017c9839a11SVinicius Costa Gomes if (addr_type == k->bdaddr_type && 2018c9839a11SVinicius Costa Gomes bacmp(bdaddr, &k->bdaddr) == 0) 201975d262c2SVinicius Costa Gomes return k; 202075d262c2SVinicius Costa Gomes 202175d262c2SVinicius Costa Gomes return NULL; 202275d262c2SVinicius Costa Gomes } 202375d262c2SVinicius Costa Gomes 2024d25e28abSJohan Hedberg int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key, 2025d25e28abSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len) 202655ed8ca1SJohan Hedberg { 202755ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2028745c0ce3SVishal Agarwal u8 old_key_type; 2029745c0ce3SVishal Agarwal bool persistent; 203055ed8ca1SJohan Hedberg 203155ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 203255ed8ca1SJohan Hedberg if (old_key) { 203355ed8ca1SJohan Hedberg old_key_type = old_key->type; 203455ed8ca1SJohan Hedberg key = old_key; 203555ed8ca1SJohan Hedberg } else { 203612adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 203755ed8ca1SJohan Hedberg key = kzalloc(sizeof(*key), GFP_ATOMIC); 203855ed8ca1SJohan Hedberg if (!key) 203955ed8ca1SJohan Hedberg return -ENOMEM; 204055ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 204155ed8ca1SJohan Hedberg } 204255ed8ca1SJohan Hedberg 20436ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 204455ed8ca1SJohan Hedberg 2045d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2046d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2047d25e28abSJohan Hedberg * previous key */ 2048d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2049a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2050d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2051655fe6ecSJohan Hedberg if (conn) 2052655fe6ecSJohan Hedberg conn->key_type = type; 2053655fe6ecSJohan Hedberg } 2054d25e28abSJohan Hedberg 205555ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 20569b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 205755ed8ca1SJohan Hedberg key->pin_len = pin_len; 205855ed8ca1SJohan Hedberg 2059b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 206055ed8ca1SJohan Hedberg key->type = old_key_type; 20614748fed2SJohan Hedberg else 20624748fed2SJohan Hedberg key->type = type; 20634748fed2SJohan Hedberg 20644df378a1SJohan Hedberg if (!new_key) 20654df378a1SJohan Hedberg return 0; 20664df378a1SJohan Hedberg 20674df378a1SJohan Hedberg persistent = hci_persistent_key(hdev, conn, type, old_key_type); 20684df378a1SJohan Hedberg 2069744cf19eSJohan Hedberg mgmt_new_link_key(hdev, key, persistent); 20704df378a1SJohan Hedberg 20716ec5bcadSVishal Agarwal if (conn) 20726ec5bcadSVishal Agarwal conn->flush_key = !persistent; 207355ed8ca1SJohan Hedberg 207455ed8ca1SJohan Hedberg return 0; 207555ed8ca1SJohan Hedberg } 207655ed8ca1SJohan Hedberg 2077c9839a11SVinicius Costa Gomes int hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type, u8 type, 20789a006657SAndrei Emeltchenko int new_key, u8 authenticated, u8 tk[16], u8 enc_size, __le16 207904124681SGustavo F. Padovan ediv, u8 rand[8]) 208075d262c2SVinicius Costa Gomes { 2081c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 208275d262c2SVinicius Costa Gomes 2083c9839a11SVinicius Costa Gomes if (!(type & HCI_SMP_STK) && !(type & HCI_SMP_LTK)) 2084c9839a11SVinicius Costa Gomes return 0; 208575d262c2SVinicius Costa Gomes 2086c9839a11SVinicius Costa Gomes old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type); 2087c9839a11SVinicius Costa Gomes if (old_key) 208875d262c2SVinicius Costa Gomes key = old_key; 2089c9839a11SVinicius Costa Gomes else { 2090c9839a11SVinicius Costa Gomes key = kzalloc(sizeof(*key), GFP_ATOMIC); 209175d262c2SVinicius Costa Gomes if (!key) 209275d262c2SVinicius Costa Gomes return -ENOMEM; 2093c9839a11SVinicius Costa Gomes list_add(&key->list, &hdev->long_term_keys); 209475d262c2SVinicius Costa Gomes } 209575d262c2SVinicius Costa Gomes 209675d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2097c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2098c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2099c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2100c9839a11SVinicius Costa Gomes key->ediv = ediv; 2101c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2102c9839a11SVinicius Costa Gomes key->type = type; 2103c9839a11SVinicius Costa Gomes memcpy(key->rand, rand, sizeof(key->rand)); 210475d262c2SVinicius Costa Gomes 2105c9839a11SVinicius Costa Gomes if (!new_key) 2106c9839a11SVinicius Costa Gomes return 0; 210775d262c2SVinicius Costa Gomes 2108261cc5aaSVinicius Costa Gomes if (type & HCI_SMP_LTK) 2109261cc5aaSVinicius Costa Gomes mgmt_new_ltk(hdev, key, 1); 2110261cc5aaSVinicius Costa Gomes 211175d262c2SVinicius Costa Gomes return 0; 211275d262c2SVinicius Costa Gomes } 211375d262c2SVinicius Costa Gomes 211455ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 211555ed8ca1SJohan Hedberg { 211655ed8ca1SJohan Hedberg struct link_key *key; 211755ed8ca1SJohan Hedberg 211855ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 211955ed8ca1SJohan Hedberg if (!key) 212055ed8ca1SJohan Hedberg return -ENOENT; 212155ed8ca1SJohan Hedberg 21226ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 212355ed8ca1SJohan Hedberg 212455ed8ca1SJohan Hedberg list_del(&key->list); 212555ed8ca1SJohan Hedberg kfree(key); 212655ed8ca1SJohan Hedberg 212755ed8ca1SJohan Hedberg return 0; 212855ed8ca1SJohan Hedberg } 212955ed8ca1SJohan Hedberg 2130b899efafSVinicius Costa Gomes int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr) 2131b899efafSVinicius Costa Gomes { 2132b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 2133b899efafSVinicius Costa Gomes 2134b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 2135b899efafSVinicius Costa Gomes if (bacmp(bdaddr, &k->bdaddr)) 2136b899efafSVinicius Costa Gomes continue; 2137b899efafSVinicius Costa Gomes 21386ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2139b899efafSVinicius Costa Gomes 2140b899efafSVinicius Costa Gomes list_del(&k->list); 2141b899efafSVinicius Costa Gomes kfree(k); 2142b899efafSVinicius Costa Gomes } 2143b899efafSVinicius Costa Gomes 2144b899efafSVinicius Costa Gomes return 0; 2145b899efafSVinicius Costa Gomes } 2146b899efafSVinicius Costa Gomes 21476bd32326SVille Tervo /* HCI command timer function */ 2148bda4f23aSAndrei Emeltchenko static void hci_cmd_timeout(unsigned long arg) 21496bd32326SVille Tervo { 21506bd32326SVille Tervo struct hci_dev *hdev = (void *) arg; 21516bd32326SVille Tervo 2152bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2153bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2154bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2155bda4f23aSAndrei Emeltchenko 2156bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 2157bda4f23aSAndrei Emeltchenko } else { 21586bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 2159bda4f23aSAndrei Emeltchenko } 2160bda4f23aSAndrei Emeltchenko 21616bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2162c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 21636bd32326SVille Tervo } 21646bd32326SVille Tervo 21652763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 21662763eda6SSzymon Janc bdaddr_t *bdaddr) 21672763eda6SSzymon Janc { 21682763eda6SSzymon Janc struct oob_data *data; 21692763eda6SSzymon Janc 21702763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 21712763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 21722763eda6SSzymon Janc return data; 21732763eda6SSzymon Janc 21742763eda6SSzymon Janc return NULL; 21752763eda6SSzymon Janc } 21762763eda6SSzymon Janc 21772763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 21782763eda6SSzymon Janc { 21792763eda6SSzymon Janc struct oob_data *data; 21802763eda6SSzymon Janc 21812763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 21822763eda6SSzymon Janc if (!data) 21832763eda6SSzymon Janc return -ENOENT; 21842763eda6SSzymon Janc 21856ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 21862763eda6SSzymon Janc 21872763eda6SSzymon Janc list_del(&data->list); 21882763eda6SSzymon Janc kfree(data); 21892763eda6SSzymon Janc 21902763eda6SSzymon Janc return 0; 21912763eda6SSzymon Janc } 21922763eda6SSzymon Janc 21932763eda6SSzymon Janc int hci_remote_oob_data_clear(struct hci_dev *hdev) 21942763eda6SSzymon Janc { 21952763eda6SSzymon Janc struct oob_data *data, *n; 21962763eda6SSzymon Janc 21972763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 21982763eda6SSzymon Janc list_del(&data->list); 21992763eda6SSzymon Janc kfree(data); 22002763eda6SSzymon Janc } 22012763eda6SSzymon Janc 22022763eda6SSzymon Janc return 0; 22032763eda6SSzymon Janc } 22042763eda6SSzymon Janc 22052763eda6SSzymon Janc int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash, 22062763eda6SSzymon Janc u8 *randomizer) 22072763eda6SSzymon Janc { 22082763eda6SSzymon Janc struct oob_data *data; 22092763eda6SSzymon Janc 22102763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 22112763eda6SSzymon Janc 22122763eda6SSzymon Janc if (!data) { 22132763eda6SSzymon Janc data = kmalloc(sizeof(*data), GFP_ATOMIC); 22142763eda6SSzymon Janc if (!data) 22152763eda6SSzymon Janc return -ENOMEM; 22162763eda6SSzymon Janc 22172763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 22182763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 22192763eda6SSzymon Janc } 22202763eda6SSzymon Janc 22212763eda6SSzymon Janc memcpy(data->hash, hash, sizeof(data->hash)); 22222763eda6SSzymon Janc memcpy(data->randomizer, randomizer, sizeof(data->randomizer)); 22232763eda6SSzymon Janc 22246ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 22252763eda6SSzymon Janc 22262763eda6SSzymon Janc return 0; 22272763eda6SSzymon Janc } 22282763eda6SSzymon Janc 2229b9ee0a78SMarcel Holtmann struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev, 2230b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2231b2a66aadSAntti Julku { 2232b2a66aadSAntti Julku struct bdaddr_list *b; 2233b2a66aadSAntti Julku 2234b9ee0a78SMarcel Holtmann list_for_each_entry(b, &hdev->blacklist, list) { 2235b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2236b2a66aadSAntti Julku return b; 2237b9ee0a78SMarcel Holtmann } 2238b2a66aadSAntti Julku 2239b2a66aadSAntti Julku return NULL; 2240b2a66aadSAntti Julku } 2241b2a66aadSAntti Julku 2242b2a66aadSAntti Julku int hci_blacklist_clear(struct hci_dev *hdev) 2243b2a66aadSAntti Julku { 2244b2a66aadSAntti Julku struct list_head *p, *n; 2245b2a66aadSAntti Julku 2246b2a66aadSAntti Julku list_for_each_safe(p, n, &hdev->blacklist) { 2247b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 2248b2a66aadSAntti Julku 2249b2a66aadSAntti Julku list_del(p); 2250b2a66aadSAntti Julku kfree(b); 2251b2a66aadSAntti Julku } 2252b2a66aadSAntti Julku 2253b2a66aadSAntti Julku return 0; 2254b2a66aadSAntti Julku } 2255b2a66aadSAntti Julku 225688c1fe4bSJohan Hedberg int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 2257b2a66aadSAntti Julku { 2258b2a66aadSAntti Julku struct bdaddr_list *entry; 2259b2a66aadSAntti Julku 2260b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2261b2a66aadSAntti Julku return -EBADF; 2262b2a66aadSAntti Julku 2263b9ee0a78SMarcel Holtmann if (hci_blacklist_lookup(hdev, bdaddr, type)) 22645e762444SAntti Julku return -EEXIST; 2265b2a66aadSAntti Julku 2266b2a66aadSAntti Julku entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL); 22675e762444SAntti Julku if (!entry) 22685e762444SAntti Julku return -ENOMEM; 2269b2a66aadSAntti Julku 2270b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2271b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2272b2a66aadSAntti Julku 2273b2a66aadSAntti Julku list_add(&entry->list, &hdev->blacklist); 2274b2a66aadSAntti Julku 227588c1fe4bSJohan Hedberg return mgmt_device_blocked(hdev, bdaddr, type); 2276b2a66aadSAntti Julku } 2277b2a66aadSAntti Julku 227888c1fe4bSJohan Hedberg int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 2279b2a66aadSAntti Julku { 2280b2a66aadSAntti Julku struct bdaddr_list *entry; 2281b2a66aadSAntti Julku 2282b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 22835e762444SAntti Julku return hci_blacklist_clear(hdev); 2284b2a66aadSAntti Julku 2285b9ee0a78SMarcel Holtmann entry = hci_blacklist_lookup(hdev, bdaddr, type); 22861ec918ceSSzymon Janc if (!entry) 22875e762444SAntti Julku return -ENOENT; 2288b2a66aadSAntti Julku 2289b2a66aadSAntti Julku list_del(&entry->list); 2290b2a66aadSAntti Julku kfree(entry); 2291b2a66aadSAntti Julku 229288c1fe4bSJohan Hedberg return mgmt_device_unblocked(hdev, bdaddr, type); 2293b2a66aadSAntti Julku } 2294b2a66aadSAntti Julku 22954c87eaabSAndre Guedes static void inquiry_complete(struct hci_dev *hdev, u8 status) 22967ba8b4beSAndre Guedes { 22974c87eaabSAndre Guedes if (status) { 22984c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 22997ba8b4beSAndre Guedes 23004c87eaabSAndre Guedes hci_dev_lock(hdev); 23014c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 23024c87eaabSAndre Guedes hci_dev_unlock(hdev); 23034c87eaabSAndre Guedes return; 23044c87eaabSAndre Guedes } 23057ba8b4beSAndre Guedes } 23067ba8b4beSAndre Guedes 23074c87eaabSAndre Guedes static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status) 23087ba8b4beSAndre Guedes { 23094c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 23104c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 23114c87eaabSAndre Guedes struct hci_request req; 23124c87eaabSAndre Guedes struct hci_cp_inquiry cp; 23137ba8b4beSAndre Guedes int err; 23147ba8b4beSAndre Guedes 23154c87eaabSAndre Guedes if (status) { 23164c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 23174c87eaabSAndre Guedes return; 23187ba8b4beSAndre Guedes } 23197ba8b4beSAndre Guedes 23204c87eaabSAndre Guedes switch (hdev->discovery.type) { 23214c87eaabSAndre Guedes case DISCOV_TYPE_LE: 23224c87eaabSAndre Guedes hci_dev_lock(hdev); 23234c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 23244c87eaabSAndre Guedes hci_dev_unlock(hdev); 23254c87eaabSAndre Guedes break; 23267dbfac1dSAndre Guedes 23274c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 23284c87eaabSAndre Guedes hci_req_init(&req, hdev); 23297dbfac1dSAndre Guedes 23307dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 23314c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 23324c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 23334c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 23344c87eaabSAndre Guedes 23354c87eaabSAndre Guedes hci_dev_lock(hdev); 23364c87eaabSAndre Guedes 23374c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 23384c87eaabSAndre Guedes 23394c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 23404c87eaabSAndre Guedes if (err) { 23414c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 23424c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 23437dbfac1dSAndre Guedes } 23447dbfac1dSAndre Guedes 23454c87eaabSAndre Guedes hci_dev_unlock(hdev); 23464c87eaabSAndre Guedes break; 23474c87eaabSAndre Guedes } 23487dbfac1dSAndre Guedes } 23497dbfac1dSAndre Guedes 23507ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 23517ba8b4beSAndre Guedes { 23527ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 23537ba8b4beSAndre Guedes le_scan_disable.work); 23547ba8b4beSAndre Guedes struct hci_cp_le_set_scan_enable cp; 23554c87eaabSAndre Guedes struct hci_request req; 23564c87eaabSAndre Guedes int err; 23577ba8b4beSAndre Guedes 23587ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 23597ba8b4beSAndre Guedes 23604c87eaabSAndre Guedes hci_req_init(&req, hdev); 23617ba8b4beSAndre Guedes 23627ba8b4beSAndre Guedes memset(&cp, 0, sizeof(cp)); 23634c87eaabSAndre Guedes cp.enable = LE_SCAN_DISABLE; 23644c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 23657ba8b4beSAndre Guedes 23664c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 23674c87eaabSAndre Guedes if (err) 23684c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 236928b75a89SAndre Guedes } 237028b75a89SAndre Guedes 23719be0dab7SDavid Herrmann /* Alloc HCI device */ 23729be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 23739be0dab7SDavid Herrmann { 23749be0dab7SDavid Herrmann struct hci_dev *hdev; 23759be0dab7SDavid Herrmann 23769be0dab7SDavid Herrmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 23779be0dab7SDavid Herrmann if (!hdev) 23789be0dab7SDavid Herrmann return NULL; 23799be0dab7SDavid Herrmann 2380b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 2381b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 2382b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 2383b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 2384b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 2385bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 2386bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 2387b1b813d4SDavid Herrmann 2388b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 2389b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 2390b1b813d4SDavid Herrmann 2391bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 2392bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 2393bef64738SMarcel Holtmann 2394b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 2395b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 2396b1b813d4SDavid Herrmann 2397b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 2398b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 2399b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 2400b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 2401b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 2402b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 24036b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 2404b1b813d4SDavid Herrmann 2405b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 2406b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 2407b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 2408b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 2409b1b813d4SDavid Herrmann 2410b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 2411b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 2412b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 2413b1b813d4SDavid Herrmann 2414b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 2415b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 2416b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 2417b1b813d4SDavid Herrmann 2418b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 2419b1b813d4SDavid Herrmann 2420bda4f23aSAndrei Emeltchenko setup_timer(&hdev->cmd_timer, hci_cmd_timeout, (unsigned long) hdev); 2421b1b813d4SDavid Herrmann 2422b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 2423b1b813d4SDavid Herrmann discovery_init(hdev); 24249be0dab7SDavid Herrmann 24259be0dab7SDavid Herrmann return hdev; 24269be0dab7SDavid Herrmann } 24279be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 24289be0dab7SDavid Herrmann 24299be0dab7SDavid Herrmann /* Free HCI device */ 24309be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 24319be0dab7SDavid Herrmann { 24329be0dab7SDavid Herrmann /* will free via device release */ 24339be0dab7SDavid Herrmann put_device(&hdev->dev); 24349be0dab7SDavid Herrmann } 24359be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 24369be0dab7SDavid Herrmann 24371da177e4SLinus Torvalds /* Register HCI device */ 24381da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 24391da177e4SLinus Torvalds { 2440b1b813d4SDavid Herrmann int id, error; 24411da177e4SLinus Torvalds 2442010666a1SDavid Herrmann if (!hdev->open || !hdev->close) 24431da177e4SLinus Torvalds return -EINVAL; 24441da177e4SLinus Torvalds 244508add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 244608add513SMat Martineau * so the index can be used as the AMP controller ID. 244708add513SMat Martineau */ 24483df92b31SSasha Levin switch (hdev->dev_type) { 24493df92b31SSasha Levin case HCI_BREDR: 24503df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 24511da177e4SLinus Torvalds break; 24523df92b31SSasha Levin case HCI_AMP: 24533df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 24543df92b31SSasha Levin break; 24553df92b31SSasha Levin default: 24563df92b31SSasha Levin return -EINVAL; 24571da177e4SLinus Torvalds } 24581da177e4SLinus Torvalds 24593df92b31SSasha Levin if (id < 0) 24603df92b31SSasha Levin return id; 24613df92b31SSasha Levin 24621da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 24631da177e4SLinus Torvalds hdev->id = id; 24642d8b3a11SAndrei Emeltchenko 24652d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 24662d8b3a11SAndrei Emeltchenko 2467d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 2468d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 246933ca954dSDavid Herrmann if (!hdev->workqueue) { 247033ca954dSDavid Herrmann error = -ENOMEM; 247133ca954dSDavid Herrmann goto err; 247233ca954dSDavid Herrmann } 2473f48fd9c8SMarcel Holtmann 2474d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 2475d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 24766ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 24776ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 24786ead1bbcSJohan Hedberg error = -ENOMEM; 24796ead1bbcSJohan Hedberg goto err; 24806ead1bbcSJohan Hedberg } 24816ead1bbcSJohan Hedberg 24820153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 24830153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 24840153e2ecSMarcel Holtmann 2485*bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 2486*bdc3e0f1SMarcel Holtmann 2487*bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 248833ca954dSDavid Herrmann if (error < 0) 248933ca954dSDavid Herrmann goto err_wqueue; 24901da177e4SLinus Torvalds 2491611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 2492a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 2493a8c5fb1aSGustavo Padovan hdev); 2494611b30f7SMarcel Holtmann if (hdev->rfkill) { 2495611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 2496611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 2497611b30f7SMarcel Holtmann hdev->rfkill = NULL; 2498611b30f7SMarcel Holtmann } 2499611b30f7SMarcel Holtmann } 2500611b30f7SMarcel Holtmann 25015e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 25025e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 25035e130367SJohan Hedberg 2504a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 2505004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2506ce2be9acSAndrei Emeltchenko 250701cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 250856f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 250956f87901SJohan Hedberg * through reading supported features during init. 251056f87901SJohan Hedberg */ 251156f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 251256f87901SJohan Hedberg } 2513ce2be9acSAndrei Emeltchenko 2514fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 2515fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 2516fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 2517fcee3377SGustavo Padovan 25181da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 2519dc946bd8SDavid Herrmann hci_dev_hold(hdev); 25201da177e4SLinus Torvalds 252119202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 2522fbe96d6fSMarcel Holtmann 25231da177e4SLinus Torvalds return id; 2524f48fd9c8SMarcel Holtmann 252533ca954dSDavid Herrmann err_wqueue: 252633ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 25276ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 252833ca954dSDavid Herrmann err: 25293df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 2530f48fd9c8SMarcel Holtmann 253133ca954dSDavid Herrmann return error; 25321da177e4SLinus Torvalds } 25331da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 25341da177e4SLinus Torvalds 25351da177e4SLinus Torvalds /* Unregister HCI device */ 253659735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 25371da177e4SLinus Torvalds { 25383df92b31SSasha Levin int i, id; 2539ef222013SMarcel Holtmann 2540c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 25411da177e4SLinus Torvalds 254294324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 254394324962SJohan Hovold 25443df92b31SSasha Levin id = hdev->id; 25453df92b31SSasha Levin 2546f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 25471da177e4SLinus Torvalds list_del(&hdev->list); 2548f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 25491da177e4SLinus Torvalds 25501da177e4SLinus Torvalds hci_dev_do_close(hdev); 25511da177e4SLinus Torvalds 2552cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 2553ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 2554ef222013SMarcel Holtmann 2555b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 2556b9b5ef18SGustavo Padovan 2557ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 2558a8b2d5c2SJohan Hedberg !test_bit(HCI_SETUP, &hdev->dev_flags)) { 255909fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2560744cf19eSJohan Hedberg mgmt_index_removed(hdev); 256109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 256256e5cb86SJohan Hedberg } 2563ab81cbf9SJohan Hedberg 25642e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 25652e58ef3eSJohan Hedberg * pending list */ 25662e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 25672e58ef3eSJohan Hedberg 25681da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 25691da177e4SLinus Torvalds 2570611b30f7SMarcel Holtmann if (hdev->rfkill) { 2571611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 2572611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 2573611b30f7SMarcel Holtmann } 2574611b30f7SMarcel Holtmann 2575*bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 2576147e2d59SDave Young 25770153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 25780153e2ecSMarcel Holtmann 2579f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 25806ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 2581f48fd9c8SMarcel Holtmann 258209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2583e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 25842aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 258555ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 2586b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 25872763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 258809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 2589e2e0cacbSJohan Hedberg 2590dc946bd8SDavid Herrmann hci_dev_put(hdev); 25913df92b31SSasha Levin 25923df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 25931da177e4SLinus Torvalds } 25941da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 25951da177e4SLinus Torvalds 25961da177e4SLinus Torvalds /* Suspend HCI device */ 25971da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 25981da177e4SLinus Torvalds { 25991da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 26001da177e4SLinus Torvalds return 0; 26011da177e4SLinus Torvalds } 26021da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 26031da177e4SLinus Torvalds 26041da177e4SLinus Torvalds /* Resume HCI device */ 26051da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 26061da177e4SLinus Torvalds { 26071da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 26081da177e4SLinus Torvalds return 0; 26091da177e4SLinus Torvalds } 26101da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 26111da177e4SLinus Torvalds 261276bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 2613e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 261476bca880SMarcel Holtmann { 261576bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 261676bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 261776bca880SMarcel Holtmann kfree_skb(skb); 261876bca880SMarcel Holtmann return -ENXIO; 261976bca880SMarcel Holtmann } 262076bca880SMarcel Holtmann 2621d82603c6SJorrit Schippers /* Incoming skb */ 262276bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 262376bca880SMarcel Holtmann 262476bca880SMarcel Holtmann /* Time stamp */ 262576bca880SMarcel Holtmann __net_timestamp(skb); 262676bca880SMarcel Holtmann 262776bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 2628b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 2629c78ae283SMarcel Holtmann 263076bca880SMarcel Holtmann return 0; 263176bca880SMarcel Holtmann } 263276bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 263376bca880SMarcel Holtmann 263433e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 26351e429f38SGustavo F. Padovan int count, __u8 index) 263633e882a5SSuraj Sumangala { 263733e882a5SSuraj Sumangala int len = 0; 263833e882a5SSuraj Sumangala int hlen = 0; 263933e882a5SSuraj Sumangala int remain = count; 264033e882a5SSuraj Sumangala struct sk_buff *skb; 264133e882a5SSuraj Sumangala struct bt_skb_cb *scb; 264233e882a5SSuraj Sumangala 264333e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 264433e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 264533e882a5SSuraj Sumangala return -EILSEQ; 264633e882a5SSuraj Sumangala 264733e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 264833e882a5SSuraj Sumangala 264933e882a5SSuraj Sumangala if (!skb) { 265033e882a5SSuraj Sumangala switch (type) { 265133e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 265233e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 265333e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 265433e882a5SSuraj Sumangala break; 265533e882a5SSuraj Sumangala case HCI_EVENT_PKT: 265633e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 265733e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 265833e882a5SSuraj Sumangala break; 265933e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 266033e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 266133e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 266233e882a5SSuraj Sumangala break; 266333e882a5SSuraj Sumangala } 266433e882a5SSuraj Sumangala 26651e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 266633e882a5SSuraj Sumangala if (!skb) 266733e882a5SSuraj Sumangala return -ENOMEM; 266833e882a5SSuraj Sumangala 266933e882a5SSuraj Sumangala scb = (void *) skb->cb; 267033e882a5SSuraj Sumangala scb->expect = hlen; 267133e882a5SSuraj Sumangala scb->pkt_type = type; 267233e882a5SSuraj Sumangala 267333e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 267433e882a5SSuraj Sumangala } 267533e882a5SSuraj Sumangala 267633e882a5SSuraj Sumangala while (count) { 267733e882a5SSuraj Sumangala scb = (void *) skb->cb; 267889bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 267933e882a5SSuraj Sumangala 268033e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 268133e882a5SSuraj Sumangala 268233e882a5SSuraj Sumangala count -= len; 268333e882a5SSuraj Sumangala data += len; 268433e882a5SSuraj Sumangala scb->expect -= len; 268533e882a5SSuraj Sumangala remain = count; 268633e882a5SSuraj Sumangala 268733e882a5SSuraj Sumangala switch (type) { 268833e882a5SSuraj Sumangala case HCI_EVENT_PKT: 268933e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 269033e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 269133e882a5SSuraj Sumangala scb->expect = h->plen; 269233e882a5SSuraj Sumangala 269333e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 269433e882a5SSuraj Sumangala kfree_skb(skb); 269533e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 269633e882a5SSuraj Sumangala return -ENOMEM; 269733e882a5SSuraj Sumangala } 269833e882a5SSuraj Sumangala } 269933e882a5SSuraj Sumangala break; 270033e882a5SSuraj Sumangala 270133e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 270233e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 270333e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 270433e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 270533e882a5SSuraj Sumangala 270633e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 270733e882a5SSuraj Sumangala kfree_skb(skb); 270833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 270933e882a5SSuraj Sumangala return -ENOMEM; 271033e882a5SSuraj Sumangala } 271133e882a5SSuraj Sumangala } 271233e882a5SSuraj Sumangala break; 271333e882a5SSuraj Sumangala 271433e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 271533e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 271633e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 271733e882a5SSuraj Sumangala scb->expect = h->dlen; 271833e882a5SSuraj Sumangala 271933e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 272033e882a5SSuraj Sumangala kfree_skb(skb); 272133e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 272233e882a5SSuraj Sumangala return -ENOMEM; 272333e882a5SSuraj Sumangala } 272433e882a5SSuraj Sumangala } 272533e882a5SSuraj Sumangala break; 272633e882a5SSuraj Sumangala } 272733e882a5SSuraj Sumangala 272833e882a5SSuraj Sumangala if (scb->expect == 0) { 272933e882a5SSuraj Sumangala /* Complete frame */ 273033e882a5SSuraj Sumangala 273133e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 2732e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 273333e882a5SSuraj Sumangala 273433e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 273533e882a5SSuraj Sumangala return remain; 273633e882a5SSuraj Sumangala } 273733e882a5SSuraj Sumangala } 273833e882a5SSuraj Sumangala 273933e882a5SSuraj Sumangala return remain; 274033e882a5SSuraj Sumangala } 274133e882a5SSuraj Sumangala 2742ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 2743ef222013SMarcel Holtmann { 2744f39a3c06SSuraj Sumangala int rem = 0; 2745f39a3c06SSuraj Sumangala 2746ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 2747ef222013SMarcel Holtmann return -EILSEQ; 2748ef222013SMarcel Holtmann 2749da5f6c37SGustavo F. Padovan while (count) { 27501e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, type - 1); 2751f39a3c06SSuraj Sumangala if (rem < 0) 2752f39a3c06SSuraj Sumangala return rem; 2753ef222013SMarcel Holtmann 2754f39a3c06SSuraj Sumangala data += (count - rem); 2755f39a3c06SSuraj Sumangala count = rem; 2756f81c6224SJoe Perches } 2757ef222013SMarcel Holtmann 2758f39a3c06SSuraj Sumangala return rem; 2759ef222013SMarcel Holtmann } 2760ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 2761ef222013SMarcel Holtmann 276299811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 276399811510SSuraj Sumangala 276499811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 276599811510SSuraj Sumangala { 276699811510SSuraj Sumangala int type; 276799811510SSuraj Sumangala int rem = 0; 276899811510SSuraj Sumangala 2769da5f6c37SGustavo F. Padovan while (count) { 277099811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 277199811510SSuraj Sumangala 277299811510SSuraj Sumangala if (!skb) { 277399811510SSuraj Sumangala struct { char type; } *pkt; 277499811510SSuraj Sumangala 277599811510SSuraj Sumangala /* Start of the frame */ 277699811510SSuraj Sumangala pkt = data; 277799811510SSuraj Sumangala type = pkt->type; 277899811510SSuraj Sumangala 277999811510SSuraj Sumangala data++; 278099811510SSuraj Sumangala count--; 278199811510SSuraj Sumangala } else 278299811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 278399811510SSuraj Sumangala 27841e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 27851e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 278699811510SSuraj Sumangala if (rem < 0) 278799811510SSuraj Sumangala return rem; 278899811510SSuraj Sumangala 278999811510SSuraj Sumangala data += (count - rem); 279099811510SSuraj Sumangala count = rem; 2791f81c6224SJoe Perches } 279299811510SSuraj Sumangala 279399811510SSuraj Sumangala return rem; 279499811510SSuraj Sumangala } 279599811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 279699811510SSuraj Sumangala 27971da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 27981da177e4SLinus Torvalds 27991da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 28001da177e4SLinus Torvalds { 28011da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 28021da177e4SLinus Torvalds 2803f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 28041da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 2805f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 28061da177e4SLinus Torvalds 28071da177e4SLinus Torvalds return 0; 28081da177e4SLinus Torvalds } 28091da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 28101da177e4SLinus Torvalds 28111da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 28121da177e4SLinus Torvalds { 28131da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 28141da177e4SLinus Torvalds 2815f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 28161da177e4SLinus Torvalds list_del(&cb->list); 2817f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 28181da177e4SLinus Torvalds 28191da177e4SLinus Torvalds return 0; 28201da177e4SLinus Torvalds } 28211da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 28221da177e4SLinus Torvalds 282351086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 28241da177e4SLinus Torvalds { 28250d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 28261da177e4SLinus Torvalds 28271da177e4SLinus Torvalds /* Time stamp */ 2828a61bbcf2SPatrick McHardy __net_timestamp(skb); 28291da177e4SLinus Torvalds 2830cd82e61cSMarcel Holtmann /* Send copy to monitor */ 2831cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 2832cd82e61cSMarcel Holtmann 2833cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 2834cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 2835470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 28361da177e4SLinus Torvalds } 28371da177e4SLinus Torvalds 28381da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 28391da177e4SLinus Torvalds skb_orphan(skb); 28401da177e4SLinus Torvalds 28417bd8f09fSMarcel Holtmann if (hdev->send(hdev, skb) < 0) 284251086991SMarcel Holtmann BT_ERR("%s sending frame failed", hdev->name); 28431da177e4SLinus Torvalds } 28441da177e4SLinus Torvalds 28453119ae95SJohan Hedberg void hci_req_init(struct hci_request *req, struct hci_dev *hdev) 28463119ae95SJohan Hedberg { 28473119ae95SJohan Hedberg skb_queue_head_init(&req->cmd_q); 28483119ae95SJohan Hedberg req->hdev = hdev; 28495d73e034SAndre Guedes req->err = 0; 28503119ae95SJohan Hedberg } 28513119ae95SJohan Hedberg 28523119ae95SJohan Hedberg int hci_req_run(struct hci_request *req, hci_req_complete_t complete) 28533119ae95SJohan Hedberg { 28543119ae95SJohan Hedberg struct hci_dev *hdev = req->hdev; 28553119ae95SJohan Hedberg struct sk_buff *skb; 28563119ae95SJohan Hedberg unsigned long flags; 28573119ae95SJohan Hedberg 28583119ae95SJohan Hedberg BT_DBG("length %u", skb_queue_len(&req->cmd_q)); 28593119ae95SJohan Hedberg 28605d73e034SAndre Guedes /* If an error occured during request building, remove all HCI 28615d73e034SAndre Guedes * commands queued on the HCI request queue. 28625d73e034SAndre Guedes */ 28635d73e034SAndre Guedes if (req->err) { 28645d73e034SAndre Guedes skb_queue_purge(&req->cmd_q); 28655d73e034SAndre Guedes return req->err; 28665d73e034SAndre Guedes } 28675d73e034SAndre Guedes 28683119ae95SJohan Hedberg /* Do not allow empty requests */ 28693119ae95SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 2870382b0c39SAndre Guedes return -ENODATA; 28713119ae95SJohan Hedberg 28723119ae95SJohan Hedberg skb = skb_peek_tail(&req->cmd_q); 28733119ae95SJohan Hedberg bt_cb(skb)->req.complete = complete; 28743119ae95SJohan Hedberg 28753119ae95SJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 28763119ae95SJohan Hedberg skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q); 28773119ae95SJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 28783119ae95SJohan Hedberg 28793119ae95SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 28803119ae95SJohan Hedberg 28813119ae95SJohan Hedberg return 0; 28823119ae95SJohan Hedberg } 28833119ae95SJohan Hedberg 28841ca3a9d0SJohan Hedberg static struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, 288507dc93ddSJohan Hedberg u32 plen, const void *param) 28861da177e4SLinus Torvalds { 28871da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 28881da177e4SLinus Torvalds struct hci_command_hdr *hdr; 28891da177e4SLinus Torvalds struct sk_buff *skb; 28901da177e4SLinus Torvalds 28911da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 28921ca3a9d0SJohan Hedberg if (!skb) 28931ca3a9d0SJohan Hedberg return NULL; 28941da177e4SLinus Torvalds 28951da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 2896a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 28971da177e4SLinus Torvalds hdr->plen = plen; 28981da177e4SLinus Torvalds 28991da177e4SLinus Torvalds if (plen) 29001da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 29011da177e4SLinus Torvalds 29021da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 29031da177e4SLinus Torvalds 29040d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 2905c78ae283SMarcel Holtmann 29061ca3a9d0SJohan Hedberg return skb; 29071ca3a9d0SJohan Hedberg } 29081ca3a9d0SJohan Hedberg 29091ca3a9d0SJohan Hedberg /* Send HCI command */ 291007dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 291107dc93ddSJohan Hedberg const void *param) 29121ca3a9d0SJohan Hedberg { 29131ca3a9d0SJohan Hedberg struct sk_buff *skb; 29141ca3a9d0SJohan Hedberg 29151ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 29161ca3a9d0SJohan Hedberg 29171ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 29181ca3a9d0SJohan Hedberg if (!skb) { 29191ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 29201ca3a9d0SJohan Hedberg return -ENOMEM; 29211ca3a9d0SJohan Hedberg } 29221ca3a9d0SJohan Hedberg 292311714b3dSJohan Hedberg /* Stand-alone HCI commands must be flaged as 292411714b3dSJohan Hedberg * single-command requests. 292511714b3dSJohan Hedberg */ 292611714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 292711714b3dSJohan Hedberg 29281da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 2929c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 29301da177e4SLinus Torvalds 29311da177e4SLinus Torvalds return 0; 29321da177e4SLinus Torvalds } 29331da177e4SLinus Torvalds 293471c76a17SJohan Hedberg /* Queue a command to an asynchronous HCI request */ 293507dc93ddSJohan Hedberg void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen, 293607dc93ddSJohan Hedberg const void *param, u8 event) 293771c76a17SJohan Hedberg { 293871c76a17SJohan Hedberg struct hci_dev *hdev = req->hdev; 293971c76a17SJohan Hedberg struct sk_buff *skb; 294071c76a17SJohan Hedberg 294171c76a17SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 294271c76a17SJohan Hedberg 294334739c1eSAndre Guedes /* If an error occured during request building, there is no point in 294434739c1eSAndre Guedes * queueing the HCI command. We can simply return. 294534739c1eSAndre Guedes */ 294634739c1eSAndre Guedes if (req->err) 294734739c1eSAndre Guedes return; 294834739c1eSAndre Guedes 294971c76a17SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 295071c76a17SJohan Hedberg if (!skb) { 29515d73e034SAndre Guedes BT_ERR("%s no memory for command (opcode 0x%4.4x)", 29525d73e034SAndre Guedes hdev->name, opcode); 29535d73e034SAndre Guedes req->err = -ENOMEM; 2954e348fe6bSAndre Guedes return; 295571c76a17SJohan Hedberg } 295671c76a17SJohan Hedberg 295771c76a17SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 295871c76a17SJohan Hedberg bt_cb(skb)->req.start = true; 295971c76a17SJohan Hedberg 296002350a72SJohan Hedberg bt_cb(skb)->req.event = event; 296102350a72SJohan Hedberg 296271c76a17SJohan Hedberg skb_queue_tail(&req->cmd_q, skb); 296371c76a17SJohan Hedberg } 296471c76a17SJohan Hedberg 296507dc93ddSJohan Hedberg void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, 296607dc93ddSJohan Hedberg const void *param) 296702350a72SJohan Hedberg { 296802350a72SJohan Hedberg hci_req_add_ev(req, opcode, plen, param, 0); 296902350a72SJohan Hedberg } 297002350a72SJohan Hedberg 29711da177e4SLinus Torvalds /* Get data from the previously sent command */ 2972a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 29731da177e4SLinus Torvalds { 29741da177e4SLinus Torvalds struct hci_command_hdr *hdr; 29751da177e4SLinus Torvalds 29761da177e4SLinus Torvalds if (!hdev->sent_cmd) 29771da177e4SLinus Torvalds return NULL; 29781da177e4SLinus Torvalds 29791da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 29801da177e4SLinus Torvalds 2981a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 29821da177e4SLinus Torvalds return NULL; 29831da177e4SLinus Torvalds 2984f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 29851da177e4SLinus Torvalds 29861da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 29871da177e4SLinus Torvalds } 29881da177e4SLinus Torvalds 29891da177e4SLinus Torvalds /* Send ACL data */ 29901da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 29911da177e4SLinus Torvalds { 29921da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 29931da177e4SLinus Torvalds int len = skb->len; 29941da177e4SLinus Torvalds 2995badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 2996badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 29979c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 2998aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 2999aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 30001da177e4SLinus Torvalds } 30011da177e4SLinus Torvalds 3002ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 300373d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 30041da177e4SLinus Torvalds { 3005ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 30061da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 30071da177e4SLinus Torvalds struct sk_buff *list; 30081da177e4SLinus Torvalds 3009087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3010087bfd99SGustavo Padovan skb->data_len = 0; 3011087bfd99SGustavo Padovan 3012087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3013204a6e54SAndrei Emeltchenko 3014204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3015204a6e54SAndrei Emeltchenko case HCI_BREDR: 3016087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3017204a6e54SAndrei Emeltchenko break; 3018204a6e54SAndrei Emeltchenko case HCI_AMP: 3019204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3020204a6e54SAndrei Emeltchenko break; 3021204a6e54SAndrei Emeltchenko default: 3022204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 3023204a6e54SAndrei Emeltchenko return; 3024204a6e54SAndrei Emeltchenko } 3025087bfd99SGustavo Padovan 302670f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 302770f23020SAndrei Emeltchenko if (!list) { 30281da177e4SLinus Torvalds /* Non fragmented */ 30291da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 30301da177e4SLinus Torvalds 303173d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 30321da177e4SLinus Torvalds } else { 30331da177e4SLinus Torvalds /* Fragmented */ 30341da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 30351da177e4SLinus Torvalds 30361da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 30371da177e4SLinus Torvalds 30381da177e4SLinus Torvalds /* Queue all fragments atomically */ 3039af3e6359SGustavo F. Padovan spin_lock(&queue->lock); 30401da177e4SLinus Torvalds 304173d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3042e702112fSAndrei Emeltchenko 3043e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3044e702112fSAndrei Emeltchenko flags |= ACL_CONT; 30451da177e4SLinus Torvalds do { 30461da177e4SLinus Torvalds skb = list; list = list->next; 30471da177e4SLinus Torvalds 30480d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3049e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 30501da177e4SLinus Torvalds 30511da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 30521da177e4SLinus Torvalds 305373d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 30541da177e4SLinus Torvalds } while (list); 30551da177e4SLinus Torvalds 3056af3e6359SGustavo F. Padovan spin_unlock(&queue->lock); 30571da177e4SLinus Torvalds } 305873d80debSLuiz Augusto von Dentz } 305973d80debSLuiz Augusto von Dentz 306073d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 306173d80debSLuiz Augusto von Dentz { 3062ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 306373d80debSLuiz Augusto von Dentz 3064f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 306573d80debSLuiz Augusto von Dentz 3066ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 30671da177e4SLinus Torvalds 30683eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 30691da177e4SLinus Torvalds } 30701da177e4SLinus Torvalds 30711da177e4SLinus Torvalds /* Send SCO data */ 30720d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 30731da177e4SLinus Torvalds { 30741da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 30751da177e4SLinus Torvalds struct hci_sco_hdr hdr; 30761da177e4SLinus Torvalds 30771da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 30781da177e4SLinus Torvalds 3079aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 30801da177e4SLinus Torvalds hdr.dlen = skb->len; 30811da177e4SLinus Torvalds 3082badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3083badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 30849c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 30851da177e4SLinus Torvalds 30860d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 3087c78ae283SMarcel Holtmann 30881da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 30893eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 30901da177e4SLinus Torvalds } 30911da177e4SLinus Torvalds 30921da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 30931da177e4SLinus Torvalds 30941da177e4SLinus Torvalds /* HCI Connection scheduler */ 30956039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3096a8c5fb1aSGustavo Padovan int *quote) 30971da177e4SLinus Torvalds { 30981da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 30998035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3100abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 31011da177e4SLinus Torvalds 31021da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 31031da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3104bf4c6325SGustavo F. Padovan 3105bf4c6325SGustavo F. Padovan rcu_read_lock(); 3106bf4c6325SGustavo F. Padovan 3107bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3108769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 31091da177e4SLinus Torvalds continue; 3110769be974SMarcel Holtmann 3111769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3112769be974SMarcel Holtmann continue; 3113769be974SMarcel Holtmann 31141da177e4SLinus Torvalds num++; 31151da177e4SLinus Torvalds 31161da177e4SLinus Torvalds if (c->sent < min) { 31171da177e4SLinus Torvalds min = c->sent; 31181da177e4SLinus Torvalds conn = c; 31191da177e4SLinus Torvalds } 312052087a79SLuiz Augusto von Dentz 312152087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 312252087a79SLuiz Augusto von Dentz break; 31231da177e4SLinus Torvalds } 31241da177e4SLinus Torvalds 3125bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3126bf4c6325SGustavo F. Padovan 31271da177e4SLinus Torvalds if (conn) { 31286ed58ec5SVille Tervo int cnt, q; 31296ed58ec5SVille Tervo 31306ed58ec5SVille Tervo switch (conn->type) { 31316ed58ec5SVille Tervo case ACL_LINK: 31326ed58ec5SVille Tervo cnt = hdev->acl_cnt; 31336ed58ec5SVille Tervo break; 31346ed58ec5SVille Tervo case SCO_LINK: 31356ed58ec5SVille Tervo case ESCO_LINK: 31366ed58ec5SVille Tervo cnt = hdev->sco_cnt; 31376ed58ec5SVille Tervo break; 31386ed58ec5SVille Tervo case LE_LINK: 31396ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 31406ed58ec5SVille Tervo break; 31416ed58ec5SVille Tervo default: 31426ed58ec5SVille Tervo cnt = 0; 31436ed58ec5SVille Tervo BT_ERR("Unknown link type"); 31446ed58ec5SVille Tervo } 31456ed58ec5SVille Tervo 31466ed58ec5SVille Tervo q = cnt / num; 31471da177e4SLinus Torvalds *quote = q ? q : 1; 31481da177e4SLinus Torvalds } else 31491da177e4SLinus Torvalds *quote = 0; 31501da177e4SLinus Torvalds 31511da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 31521da177e4SLinus Torvalds return conn; 31531da177e4SLinus Torvalds } 31541da177e4SLinus Torvalds 31556039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 31561da177e4SLinus Torvalds { 31571da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 31581da177e4SLinus Torvalds struct hci_conn *c; 31591da177e4SLinus Torvalds 3160bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 31611da177e4SLinus Torvalds 3162bf4c6325SGustavo F. Padovan rcu_read_lock(); 3163bf4c6325SGustavo F. Padovan 31641da177e4SLinus Torvalds /* Kill stalled connections */ 3165bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3166bae1f5d9SVille Tervo if (c->type == type && c->sent) { 31676ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 31686ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 3169bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 31701da177e4SLinus Torvalds } 31711da177e4SLinus Torvalds } 3172bf4c6325SGustavo F. Padovan 3173bf4c6325SGustavo F. Padovan rcu_read_unlock(); 31741da177e4SLinus Torvalds } 31751da177e4SLinus Torvalds 31766039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 317773d80debSLuiz Augusto von Dentz int *quote) 317873d80debSLuiz Augusto von Dentz { 317973d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 318073d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3181abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 318273d80debSLuiz Augusto von Dentz struct hci_conn *conn; 318373d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 318473d80debSLuiz Augusto von Dentz 318573d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 318673d80debSLuiz Augusto von Dentz 3187bf4c6325SGustavo F. Padovan rcu_read_lock(); 3188bf4c6325SGustavo F. Padovan 3189bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 319073d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 319173d80debSLuiz Augusto von Dentz 319273d80debSLuiz Augusto von Dentz if (conn->type != type) 319373d80debSLuiz Augusto von Dentz continue; 319473d80debSLuiz Augusto von Dentz 319573d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 319673d80debSLuiz Augusto von Dentz continue; 319773d80debSLuiz Augusto von Dentz 319873d80debSLuiz Augusto von Dentz conn_num++; 319973d80debSLuiz Augusto von Dentz 32008192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 320173d80debSLuiz Augusto von Dentz struct sk_buff *skb; 320273d80debSLuiz Augusto von Dentz 320373d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 320473d80debSLuiz Augusto von Dentz continue; 320573d80debSLuiz Augusto von Dentz 320673d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 320773d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 320873d80debSLuiz Augusto von Dentz continue; 320973d80debSLuiz Augusto von Dentz 321073d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 321173d80debSLuiz Augusto von Dentz num = 0; 321273d80debSLuiz Augusto von Dentz min = ~0; 321373d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 321473d80debSLuiz Augusto von Dentz } 321573d80debSLuiz Augusto von Dentz 321673d80debSLuiz Augusto von Dentz num++; 321773d80debSLuiz Augusto von Dentz 321873d80debSLuiz Augusto von Dentz if (conn->sent < min) { 321973d80debSLuiz Augusto von Dentz min = conn->sent; 322073d80debSLuiz Augusto von Dentz chan = tmp; 322173d80debSLuiz Augusto von Dentz } 322273d80debSLuiz Augusto von Dentz } 322373d80debSLuiz Augusto von Dentz 322473d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 322573d80debSLuiz Augusto von Dentz break; 322673d80debSLuiz Augusto von Dentz } 322773d80debSLuiz Augusto von Dentz 3228bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3229bf4c6325SGustavo F. Padovan 323073d80debSLuiz Augusto von Dentz if (!chan) 323173d80debSLuiz Augusto von Dentz return NULL; 323273d80debSLuiz Augusto von Dentz 323373d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 323473d80debSLuiz Augusto von Dentz case ACL_LINK: 323573d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 323673d80debSLuiz Augusto von Dentz break; 3237bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3238bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3239bd1eb66bSAndrei Emeltchenko break; 324073d80debSLuiz Augusto von Dentz case SCO_LINK: 324173d80debSLuiz Augusto von Dentz case ESCO_LINK: 324273d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 324373d80debSLuiz Augusto von Dentz break; 324473d80debSLuiz Augusto von Dentz case LE_LINK: 324573d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 324673d80debSLuiz Augusto von Dentz break; 324773d80debSLuiz Augusto von Dentz default: 324873d80debSLuiz Augusto von Dentz cnt = 0; 324973d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 325073d80debSLuiz Augusto von Dentz } 325173d80debSLuiz Augusto von Dentz 325273d80debSLuiz Augusto von Dentz q = cnt / num; 325373d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 325473d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 325573d80debSLuiz Augusto von Dentz return chan; 325673d80debSLuiz Augusto von Dentz } 325773d80debSLuiz Augusto von Dentz 325802b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 325902b20f0bSLuiz Augusto von Dentz { 326002b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 326102b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 326202b20f0bSLuiz Augusto von Dentz int num = 0; 326302b20f0bSLuiz Augusto von Dentz 326402b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 326502b20f0bSLuiz Augusto von Dentz 3266bf4c6325SGustavo F. Padovan rcu_read_lock(); 3267bf4c6325SGustavo F. Padovan 3268bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 326902b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 327002b20f0bSLuiz Augusto von Dentz 327102b20f0bSLuiz Augusto von Dentz if (conn->type != type) 327202b20f0bSLuiz Augusto von Dentz continue; 327302b20f0bSLuiz Augusto von Dentz 327402b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 327502b20f0bSLuiz Augusto von Dentz continue; 327602b20f0bSLuiz Augusto von Dentz 327702b20f0bSLuiz Augusto von Dentz num++; 327802b20f0bSLuiz Augusto von Dentz 32798192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 328002b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 328102b20f0bSLuiz Augusto von Dentz 328202b20f0bSLuiz Augusto von Dentz if (chan->sent) { 328302b20f0bSLuiz Augusto von Dentz chan->sent = 0; 328402b20f0bSLuiz Augusto von Dentz continue; 328502b20f0bSLuiz Augusto von Dentz } 328602b20f0bSLuiz Augusto von Dentz 328702b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 328802b20f0bSLuiz Augusto von Dentz continue; 328902b20f0bSLuiz Augusto von Dentz 329002b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 329102b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 329202b20f0bSLuiz Augusto von Dentz continue; 329302b20f0bSLuiz Augusto von Dentz 329402b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 329502b20f0bSLuiz Augusto von Dentz 329602b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 329702b20f0bSLuiz Augusto von Dentz skb->priority); 329802b20f0bSLuiz Augusto von Dentz } 329902b20f0bSLuiz Augusto von Dentz 330002b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 330102b20f0bSLuiz Augusto von Dentz break; 330202b20f0bSLuiz Augusto von Dentz } 3303bf4c6325SGustavo F. Padovan 3304bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3305bf4c6325SGustavo F. Padovan 330602b20f0bSLuiz Augusto von Dentz } 330702b20f0bSLuiz Augusto von Dentz 3308b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 3309b71d385aSAndrei Emeltchenko { 3310b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 3311b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 3312b71d385aSAndrei Emeltchenko } 3313b71d385aSAndrei Emeltchenko 33146039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 33151da177e4SLinus Torvalds { 33161da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 33171da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 33181da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 331963d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 33205f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 3321bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 33221da177e4SLinus Torvalds } 332363d2bc1bSAndrei Emeltchenko } 33241da177e4SLinus Torvalds 33256039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 332663d2bc1bSAndrei Emeltchenko { 332763d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 332863d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 332963d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 333063d2bc1bSAndrei Emeltchenko int quote; 333163d2bc1bSAndrei Emeltchenko 333263d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 333304837f64SMarcel Holtmann 333473d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 333573d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 3336ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3337ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 333873d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 333973d80debSLuiz Augusto von Dentz skb->len, skb->priority); 334073d80debSLuiz Augusto von Dentz 3341ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3342ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3343ec1cce24SLuiz Augusto von Dentz break; 3344ec1cce24SLuiz Augusto von Dentz 3345ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3346ec1cce24SLuiz Augusto von Dentz 334773d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 334873d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 334904837f64SMarcel Holtmann 335057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 33511da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 33521da177e4SLinus Torvalds 33531da177e4SLinus Torvalds hdev->acl_cnt--; 335473d80debSLuiz Augusto von Dentz chan->sent++; 335573d80debSLuiz Augusto von Dentz chan->conn->sent++; 33561da177e4SLinus Torvalds } 33571da177e4SLinus Torvalds } 335802b20f0bSLuiz Augusto von Dentz 335902b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 336002b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 33611da177e4SLinus Torvalds } 33621da177e4SLinus Torvalds 33636039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 3364b71d385aSAndrei Emeltchenko { 336563d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 3366b71d385aSAndrei Emeltchenko struct hci_chan *chan; 3367b71d385aSAndrei Emeltchenko struct sk_buff *skb; 3368b71d385aSAndrei Emeltchenko int quote; 3369bd1eb66bSAndrei Emeltchenko u8 type; 3370b71d385aSAndrei Emeltchenko 337163d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 3372b71d385aSAndrei Emeltchenko 3373bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3374bd1eb66bSAndrei Emeltchenko 3375bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 3376bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 3377bd1eb66bSAndrei Emeltchenko else 3378bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 3379bd1eb66bSAndrei Emeltchenko 3380b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 3381bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 3382b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 3383b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 3384b71d385aSAndrei Emeltchenko int blocks; 3385b71d385aSAndrei Emeltchenko 3386b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 3387b71d385aSAndrei Emeltchenko skb->len, skb->priority); 3388b71d385aSAndrei Emeltchenko 3389b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 3390b71d385aSAndrei Emeltchenko if (skb->priority < priority) 3391b71d385aSAndrei Emeltchenko break; 3392b71d385aSAndrei Emeltchenko 3393b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 3394b71d385aSAndrei Emeltchenko 3395b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 3396b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 3397b71d385aSAndrei Emeltchenko return; 3398b71d385aSAndrei Emeltchenko 3399b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 3400b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 3401b71d385aSAndrei Emeltchenko 340257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3403b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 3404b71d385aSAndrei Emeltchenko 3405b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 3406b71d385aSAndrei Emeltchenko quote -= blocks; 3407b71d385aSAndrei Emeltchenko 3408b71d385aSAndrei Emeltchenko chan->sent += blocks; 3409b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 3410b71d385aSAndrei Emeltchenko } 3411b71d385aSAndrei Emeltchenko } 3412b71d385aSAndrei Emeltchenko 3413b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 3414bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 3415b71d385aSAndrei Emeltchenko } 3416b71d385aSAndrei Emeltchenko 34176039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 3418b71d385aSAndrei Emeltchenko { 3419b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3420b71d385aSAndrei Emeltchenko 3421bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 3422bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 3423bd1eb66bSAndrei Emeltchenko return; 3424bd1eb66bSAndrei Emeltchenko 3425bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 3426bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 3427b71d385aSAndrei Emeltchenko return; 3428b71d385aSAndrei Emeltchenko 3429b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 3430b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 3431b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 3432b71d385aSAndrei Emeltchenko break; 3433b71d385aSAndrei Emeltchenko 3434b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 3435b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 3436b71d385aSAndrei Emeltchenko break; 3437b71d385aSAndrei Emeltchenko } 3438b71d385aSAndrei Emeltchenko } 3439b71d385aSAndrei Emeltchenko 34401da177e4SLinus Torvalds /* Schedule SCO */ 34416039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 34421da177e4SLinus Torvalds { 34431da177e4SLinus Torvalds struct hci_conn *conn; 34441da177e4SLinus Torvalds struct sk_buff *skb; 34451da177e4SLinus Torvalds int quote; 34461da177e4SLinus Torvalds 34471da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 34481da177e4SLinus Torvalds 344952087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 345052087a79SLuiz Augusto von Dentz return; 345152087a79SLuiz Augusto von Dentz 34521da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 34531da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 34541da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 345557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 34561da177e4SLinus Torvalds 34571da177e4SLinus Torvalds conn->sent++; 34581da177e4SLinus Torvalds if (conn->sent == ~0) 34591da177e4SLinus Torvalds conn->sent = 0; 34601da177e4SLinus Torvalds } 34611da177e4SLinus Torvalds } 34621da177e4SLinus Torvalds } 34631da177e4SLinus Torvalds 34646039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 3465b6a0dc82SMarcel Holtmann { 3466b6a0dc82SMarcel Holtmann struct hci_conn *conn; 3467b6a0dc82SMarcel Holtmann struct sk_buff *skb; 3468b6a0dc82SMarcel Holtmann int quote; 3469b6a0dc82SMarcel Holtmann 3470b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 3471b6a0dc82SMarcel Holtmann 347252087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 347352087a79SLuiz Augusto von Dentz return; 347452087a79SLuiz Augusto von Dentz 34758fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 34768fc9ced3SGustavo Padovan "e))) { 3477b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 3478b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 347957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3480b6a0dc82SMarcel Holtmann 3481b6a0dc82SMarcel Holtmann conn->sent++; 3482b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 3483b6a0dc82SMarcel Holtmann conn->sent = 0; 3484b6a0dc82SMarcel Holtmann } 3485b6a0dc82SMarcel Holtmann } 3486b6a0dc82SMarcel Holtmann } 3487b6a0dc82SMarcel Holtmann 34886039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 34896ed58ec5SVille Tervo { 349073d80debSLuiz Augusto von Dentz struct hci_chan *chan; 34916ed58ec5SVille Tervo struct sk_buff *skb; 349202b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 34936ed58ec5SVille Tervo 34946ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 34956ed58ec5SVille Tervo 349652087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 349752087a79SLuiz Augusto von Dentz return; 349852087a79SLuiz Augusto von Dentz 34996ed58ec5SVille Tervo if (!test_bit(HCI_RAW, &hdev->flags)) { 35006ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 35016ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 3502bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 35036ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 3504bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 35056ed58ec5SVille Tervo } 35066ed58ec5SVille Tervo 35076ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 350802b20f0bSLuiz Augusto von Dentz tmp = cnt; 350973d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 3510ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3511ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 351273d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 351373d80debSLuiz Augusto von Dentz skb->len, skb->priority); 35146ed58ec5SVille Tervo 3515ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3516ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3517ec1cce24SLuiz Augusto von Dentz break; 3518ec1cce24SLuiz Augusto von Dentz 3519ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3520ec1cce24SLuiz Augusto von Dentz 352157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 35226ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 35236ed58ec5SVille Tervo 35246ed58ec5SVille Tervo cnt--; 352573d80debSLuiz Augusto von Dentz chan->sent++; 352673d80debSLuiz Augusto von Dentz chan->conn->sent++; 35276ed58ec5SVille Tervo } 35286ed58ec5SVille Tervo } 352973d80debSLuiz Augusto von Dentz 35306ed58ec5SVille Tervo if (hdev->le_pkts) 35316ed58ec5SVille Tervo hdev->le_cnt = cnt; 35326ed58ec5SVille Tervo else 35336ed58ec5SVille Tervo hdev->acl_cnt = cnt; 353402b20f0bSLuiz Augusto von Dentz 353502b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 353602b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 35376ed58ec5SVille Tervo } 35386ed58ec5SVille Tervo 35393eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 35401da177e4SLinus Torvalds { 35413eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 35421da177e4SLinus Torvalds struct sk_buff *skb; 35431da177e4SLinus Torvalds 35446ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 35456ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 35461da177e4SLinus Torvalds 354752de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 35481da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 35491da177e4SLinus Torvalds hci_sched_acl(hdev); 35501da177e4SLinus Torvalds hci_sched_sco(hdev); 3551b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 35526ed58ec5SVille Tervo hci_sched_le(hdev); 355352de599eSMarcel Holtmann } 35546ed58ec5SVille Tervo 35551da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 35561da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 355757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 35581da177e4SLinus Torvalds } 35591da177e4SLinus Torvalds 356025985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 35611da177e4SLinus Torvalds 35621da177e4SLinus Torvalds /* ACL data packet */ 35636039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 35641da177e4SLinus Torvalds { 35651da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 35661da177e4SLinus Torvalds struct hci_conn *conn; 35671da177e4SLinus Torvalds __u16 handle, flags; 35681da177e4SLinus Torvalds 35691da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 35701da177e4SLinus Torvalds 35711da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 35721da177e4SLinus Torvalds flags = hci_flags(handle); 35731da177e4SLinus Torvalds handle = hci_handle(handle); 35741da177e4SLinus Torvalds 3575f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 3576a8c5fb1aSGustavo Padovan handle, flags); 35771da177e4SLinus Torvalds 35781da177e4SLinus Torvalds hdev->stat.acl_rx++; 35791da177e4SLinus Torvalds 35801da177e4SLinus Torvalds hci_dev_lock(hdev); 35811da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 35821da177e4SLinus Torvalds hci_dev_unlock(hdev); 35831da177e4SLinus Torvalds 35841da177e4SLinus Torvalds if (conn) { 358565983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 358604837f64SMarcel Holtmann 35871da177e4SLinus Torvalds /* Send to upper protocol */ 3588686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 35891da177e4SLinus Torvalds return; 35901da177e4SLinus Torvalds } else { 35911da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 35921da177e4SLinus Torvalds hdev->name, handle); 35931da177e4SLinus Torvalds } 35941da177e4SLinus Torvalds 35951da177e4SLinus Torvalds kfree_skb(skb); 35961da177e4SLinus Torvalds } 35971da177e4SLinus Torvalds 35981da177e4SLinus Torvalds /* SCO data packet */ 35996039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 36001da177e4SLinus Torvalds { 36011da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 36021da177e4SLinus Torvalds struct hci_conn *conn; 36031da177e4SLinus Torvalds __u16 handle; 36041da177e4SLinus Torvalds 36051da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 36061da177e4SLinus Torvalds 36071da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 36081da177e4SLinus Torvalds 3609f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 36101da177e4SLinus Torvalds 36111da177e4SLinus Torvalds hdev->stat.sco_rx++; 36121da177e4SLinus Torvalds 36131da177e4SLinus Torvalds hci_dev_lock(hdev); 36141da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 36151da177e4SLinus Torvalds hci_dev_unlock(hdev); 36161da177e4SLinus Torvalds 36171da177e4SLinus Torvalds if (conn) { 36181da177e4SLinus Torvalds /* Send to upper protocol */ 3619686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 36201da177e4SLinus Torvalds return; 36211da177e4SLinus Torvalds } else { 36221da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 36231da177e4SLinus Torvalds hdev->name, handle); 36241da177e4SLinus Torvalds } 36251da177e4SLinus Torvalds 36261da177e4SLinus Torvalds kfree_skb(skb); 36271da177e4SLinus Torvalds } 36281da177e4SLinus Torvalds 36299238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 36309238f36aSJohan Hedberg { 36319238f36aSJohan Hedberg struct sk_buff *skb; 36329238f36aSJohan Hedberg 36339238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 36349238f36aSJohan Hedberg if (!skb) 36359238f36aSJohan Hedberg return true; 36369238f36aSJohan Hedberg 36379238f36aSJohan Hedberg return bt_cb(skb)->req.start; 36389238f36aSJohan Hedberg } 36399238f36aSJohan Hedberg 364042c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 364142c6b129SJohan Hedberg { 364242c6b129SJohan Hedberg struct hci_command_hdr *sent; 364342c6b129SJohan Hedberg struct sk_buff *skb; 364442c6b129SJohan Hedberg u16 opcode; 364542c6b129SJohan Hedberg 364642c6b129SJohan Hedberg if (!hdev->sent_cmd) 364742c6b129SJohan Hedberg return; 364842c6b129SJohan Hedberg 364942c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 365042c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 365142c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 365242c6b129SJohan Hedberg return; 365342c6b129SJohan Hedberg 365442c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 365542c6b129SJohan Hedberg if (!skb) 365642c6b129SJohan Hedberg return; 365742c6b129SJohan Hedberg 365842c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 365942c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 366042c6b129SJohan Hedberg } 366142c6b129SJohan Hedberg 36629238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 36639238f36aSJohan Hedberg { 36649238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 36659238f36aSJohan Hedberg struct sk_buff *skb; 36669238f36aSJohan Hedberg unsigned long flags; 36679238f36aSJohan Hedberg 36689238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 36699238f36aSJohan Hedberg 367042c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 367142c6b129SJohan Hedberg * sent we need to do special handling of it. 36729238f36aSJohan Hedberg */ 367342c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 367442c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 367542c6b129SJohan Hedberg * reset complete event during init and any pending 367642c6b129SJohan Hedberg * command will never be completed. In such a case we 367742c6b129SJohan Hedberg * need to resend whatever was the last sent 367842c6b129SJohan Hedberg * command. 367942c6b129SJohan Hedberg */ 368042c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 368142c6b129SJohan Hedberg hci_resend_last(hdev); 368242c6b129SJohan Hedberg 36839238f36aSJohan Hedberg return; 368442c6b129SJohan Hedberg } 36859238f36aSJohan Hedberg 36869238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 36879238f36aSJohan Hedberg * this request the request is not yet complete. 36889238f36aSJohan Hedberg */ 36899238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 36909238f36aSJohan Hedberg return; 36919238f36aSJohan Hedberg 36929238f36aSJohan Hedberg /* If this was the last command in a request the complete 36939238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 36949238f36aSJohan Hedberg * command queue (hdev->cmd_q). 36959238f36aSJohan Hedberg */ 36969238f36aSJohan Hedberg if (hdev->sent_cmd) { 36979238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 369853e21fbcSJohan Hedberg 369953e21fbcSJohan Hedberg if (req_complete) { 370053e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 370153e21fbcSJohan Hedberg * avoid calling the callback more than once if 370253e21fbcSJohan Hedberg * this function gets called again. 370353e21fbcSJohan Hedberg */ 370453e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 370553e21fbcSJohan Hedberg 37069238f36aSJohan Hedberg goto call_complete; 37079238f36aSJohan Hedberg } 370853e21fbcSJohan Hedberg } 37099238f36aSJohan Hedberg 37109238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 37119238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 37129238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 37139238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 37149238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 37159238f36aSJohan Hedberg break; 37169238f36aSJohan Hedberg } 37179238f36aSJohan Hedberg 37189238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 37199238f36aSJohan Hedberg kfree_skb(skb); 37209238f36aSJohan Hedberg } 37219238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 37229238f36aSJohan Hedberg 37239238f36aSJohan Hedberg call_complete: 37249238f36aSJohan Hedberg if (req_complete) 37259238f36aSJohan Hedberg req_complete(hdev, status); 37269238f36aSJohan Hedberg } 37279238f36aSJohan Hedberg 3728b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 37291da177e4SLinus Torvalds { 3730b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 37311da177e4SLinus Torvalds struct sk_buff *skb; 37321da177e4SLinus Torvalds 37331da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 37341da177e4SLinus Torvalds 37351da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 3736cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3737cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3738cd82e61cSMarcel Holtmann 37391da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 37401da177e4SLinus Torvalds /* Send copy to the sockets */ 3741470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 37421da177e4SLinus Torvalds } 37431da177e4SLinus Torvalds 37440736cfa8SMarcel Holtmann if (test_bit(HCI_RAW, &hdev->flags) || 37450736cfa8SMarcel Holtmann test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 37461da177e4SLinus Torvalds kfree_skb(skb); 37471da177e4SLinus Torvalds continue; 37481da177e4SLinus Torvalds } 37491da177e4SLinus Torvalds 37501da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 37511da177e4SLinus Torvalds /* Don't process data packets in this states. */ 37520d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 37531da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 37541da177e4SLinus Torvalds case HCI_SCODATA_PKT: 37551da177e4SLinus Torvalds kfree_skb(skb); 37561da177e4SLinus Torvalds continue; 37573ff50b79SStephen Hemminger } 37581da177e4SLinus Torvalds } 37591da177e4SLinus Torvalds 37601da177e4SLinus Torvalds /* Process frame */ 37610d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 37621da177e4SLinus Torvalds case HCI_EVENT_PKT: 3763b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 37641da177e4SLinus Torvalds hci_event_packet(hdev, skb); 37651da177e4SLinus Torvalds break; 37661da177e4SLinus Torvalds 37671da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 37681da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 37691da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 37701da177e4SLinus Torvalds break; 37711da177e4SLinus Torvalds 37721da177e4SLinus Torvalds case HCI_SCODATA_PKT: 37731da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 37741da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 37751da177e4SLinus Torvalds break; 37761da177e4SLinus Torvalds 37771da177e4SLinus Torvalds default: 37781da177e4SLinus Torvalds kfree_skb(skb); 37791da177e4SLinus Torvalds break; 37801da177e4SLinus Torvalds } 37811da177e4SLinus Torvalds } 37821da177e4SLinus Torvalds } 37831da177e4SLinus Torvalds 3784c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 37851da177e4SLinus Torvalds { 3786c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 37871da177e4SLinus Torvalds struct sk_buff *skb; 37881da177e4SLinus Torvalds 37892104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 37902104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 37911da177e4SLinus Torvalds 37921da177e4SLinus Torvalds /* Send queued commands */ 37935a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 37945a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 37955a08ecceSAndrei Emeltchenko if (!skb) 37965a08ecceSAndrei Emeltchenko return; 37975a08ecceSAndrei Emeltchenko 37981da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 37991da177e4SLinus Torvalds 3800a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 380170f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 38021da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 380357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 38047bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 38057bdb8a5cSSzymon Janc del_timer(&hdev->cmd_timer); 38067bdb8a5cSSzymon Janc else 38076bd32326SVille Tervo mod_timer(&hdev->cmd_timer, 38085f246e89SAndrei Emeltchenko jiffies + HCI_CMD_TIMEOUT); 38091da177e4SLinus Torvalds } else { 38101da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 3811c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 38121da177e4SLinus Torvalds } 38131da177e4SLinus Torvalds } 38141da177e4SLinus Torvalds } 3815