11da177e4SLinus Torvalds /* 21da177e4SLinus Torvalds BlueZ - Bluetooth protocol stack for Linux 31da177e4SLinus Torvalds Copyright (C) 2000-2001 Qualcomm Incorporated 4590051deSGustavo F. Padovan Copyright (C) 2011 ProFUSION Embedded Systems 51da177e4SLinus Torvalds 61da177e4SLinus Torvalds Written 2000,2001 by Maxim Krasnyansky <maxk@qualcomm.com> 71da177e4SLinus Torvalds 81da177e4SLinus Torvalds This program is free software; you can redistribute it and/or modify 91da177e4SLinus Torvalds it under the terms of the GNU General Public License version 2 as 101da177e4SLinus Torvalds published by the Free Software Foundation; 111da177e4SLinus Torvalds 121da177e4SLinus Torvalds THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 131da177e4SLinus Torvalds OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 141da177e4SLinus Torvalds FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT OF THIRD PARTY RIGHTS. 151da177e4SLinus Torvalds IN NO EVENT SHALL THE COPYRIGHT HOLDER(S) AND AUTHOR(S) BE LIABLE FOR ANY 161da177e4SLinus Torvalds CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL DAMAGES, OR ANY DAMAGES 171da177e4SLinus Torvalds WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 181da177e4SLinus Torvalds ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 191da177e4SLinus Torvalds OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 201da177e4SLinus Torvalds 211da177e4SLinus Torvalds ALL LIABILITY, INCLUDING LIABILITY FOR INFRINGEMENT OF ANY PATENTS, 221da177e4SLinus Torvalds COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS, RELATING TO USE OF THIS 231da177e4SLinus Torvalds SOFTWARE IS DISCLAIMED. 241da177e4SLinus Torvalds */ 251da177e4SLinus Torvalds 261da177e4SLinus Torvalds /* Bluetooth HCI core. */ 271da177e4SLinus Torvalds 288c520a59SGustavo Padovan #include <linux/export.h> 293df92b31SSasha Levin #include <linux/idr.h> 30611b30f7SMarcel Holtmann #include <linux/rfkill.h> 31baf27f6eSMarcel Holtmann #include <linux/debugfs.h> 3299780a7bSJohan Hedberg #include <linux/crypto.h> 3347219839SMarcel Holtmann #include <asm/unaligned.h> 341da177e4SLinus Torvalds 351da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 361da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 374bc58f51SJohan Hedberg #include <net/bluetooth/l2cap.h> 38af58925cSMarcel Holtmann #include <net/bluetooth/mgmt.h> 391da177e4SLinus Torvalds 400857dd3bSJohan Hedberg #include "hci_request.h" 4160c5f5fbSMarcel Holtmann #include "hci_debugfs.h" 42970c4e46SJohan Hedberg #include "smp.h" 43970c4e46SJohan Hedberg 44b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work); 45c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work); 463eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work); 471da177e4SLinus Torvalds 481da177e4SLinus Torvalds /* HCI device list */ 491da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 501da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 511da177e4SLinus Torvalds 521da177e4SLinus Torvalds /* HCI callback list */ 531da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 541da177e4SLinus Torvalds DEFINE_RWLOCK(hci_cb_list_lock); 551da177e4SLinus Torvalds 563df92b31SSasha Levin /* HCI ID Numbering */ 573df92b31SSasha Levin static DEFINE_IDA(hci_index_ida); 583df92b31SSasha Levin 59899de765SMarcel Holtmann /* ----- HCI requests ----- */ 60899de765SMarcel Holtmann 61899de765SMarcel Holtmann #define HCI_REQ_DONE 0 62899de765SMarcel Holtmann #define HCI_REQ_PEND 1 63899de765SMarcel Holtmann #define HCI_REQ_CANCELED 2 64899de765SMarcel Holtmann 65899de765SMarcel Holtmann #define hci_req_lock(d) mutex_lock(&d->req_lock) 66899de765SMarcel Holtmann #define hci_req_unlock(d) mutex_unlock(&d->req_lock) 67899de765SMarcel Holtmann 681da177e4SLinus Torvalds /* ---- HCI notifications ---- */ 691da177e4SLinus Torvalds 706516455dSMarcel Holtmann static void hci_notify(struct hci_dev *hdev, int event) 711da177e4SLinus Torvalds { 72040030efSMarcel Holtmann hci_sock_dev_event(hdev, event); 731da177e4SLinus Torvalds } 741da177e4SLinus Torvalds 75baf27f6eSMarcel Holtmann /* ---- HCI debugfs entries ---- */ 76baf27f6eSMarcel Holtmann 774b4148e9SMarcel Holtmann static ssize_t dut_mode_read(struct file *file, char __user *user_buf, 784b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 794b4148e9SMarcel Holtmann { 804b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 814b4148e9SMarcel Holtmann char buf[3]; 824b4148e9SMarcel Holtmann 83111902f7SMarcel Holtmann buf[0] = test_bit(HCI_DUT_MODE, &hdev->dbg_flags) ? 'Y': 'N'; 844b4148e9SMarcel Holtmann buf[1] = '\n'; 854b4148e9SMarcel Holtmann buf[2] = '\0'; 864b4148e9SMarcel Holtmann return simple_read_from_buffer(user_buf, count, ppos, buf, 2); 874b4148e9SMarcel Holtmann } 884b4148e9SMarcel Holtmann 894b4148e9SMarcel Holtmann static ssize_t dut_mode_write(struct file *file, const char __user *user_buf, 904b4148e9SMarcel Holtmann size_t count, loff_t *ppos) 914b4148e9SMarcel Holtmann { 924b4148e9SMarcel Holtmann struct hci_dev *hdev = file->private_data; 934b4148e9SMarcel Holtmann struct sk_buff *skb; 944b4148e9SMarcel Holtmann char buf[32]; 954b4148e9SMarcel Holtmann size_t buf_size = min(count, (sizeof(buf)-1)); 964b4148e9SMarcel Holtmann bool enable; 974b4148e9SMarcel Holtmann int err; 984b4148e9SMarcel Holtmann 994b4148e9SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 1004b4148e9SMarcel Holtmann return -ENETDOWN; 1014b4148e9SMarcel Holtmann 1024b4148e9SMarcel Holtmann if (copy_from_user(buf, user_buf, buf_size)) 1034b4148e9SMarcel Holtmann return -EFAULT; 1044b4148e9SMarcel Holtmann 1054b4148e9SMarcel Holtmann buf[buf_size] = '\0'; 1064b4148e9SMarcel Holtmann if (strtobool(buf, &enable)) 1074b4148e9SMarcel Holtmann return -EINVAL; 1084b4148e9SMarcel Holtmann 109111902f7SMarcel Holtmann if (enable == test_bit(HCI_DUT_MODE, &hdev->dbg_flags)) 1104b4148e9SMarcel Holtmann return -EALREADY; 1114b4148e9SMarcel Holtmann 1124b4148e9SMarcel Holtmann hci_req_lock(hdev); 1134b4148e9SMarcel Holtmann if (enable) 1144b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_ENABLE_DUT_MODE, 0, NULL, 1154b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 1164b4148e9SMarcel Holtmann else 1174b4148e9SMarcel Holtmann skb = __hci_cmd_sync(hdev, HCI_OP_RESET, 0, NULL, 1184b4148e9SMarcel Holtmann HCI_CMD_TIMEOUT); 1194b4148e9SMarcel Holtmann hci_req_unlock(hdev); 1204b4148e9SMarcel Holtmann 1214b4148e9SMarcel Holtmann if (IS_ERR(skb)) 1224b4148e9SMarcel Holtmann return PTR_ERR(skb); 1234b4148e9SMarcel Holtmann 1244b4148e9SMarcel Holtmann err = -bt_to_errno(skb->data[0]); 1254b4148e9SMarcel Holtmann kfree_skb(skb); 1264b4148e9SMarcel Holtmann 1274b4148e9SMarcel Holtmann if (err < 0) 1284b4148e9SMarcel Holtmann return err; 1294b4148e9SMarcel Holtmann 130111902f7SMarcel Holtmann change_bit(HCI_DUT_MODE, &hdev->dbg_flags); 1314b4148e9SMarcel Holtmann 1324b4148e9SMarcel Holtmann return count; 1334b4148e9SMarcel Holtmann } 1344b4148e9SMarcel Holtmann 1354b4148e9SMarcel Holtmann static const struct file_operations dut_mode_fops = { 1364b4148e9SMarcel Holtmann .open = simple_open, 1374b4148e9SMarcel Holtmann .read = dut_mode_read, 1384b4148e9SMarcel Holtmann .write = dut_mode_write, 1394b4148e9SMarcel Holtmann .llseek = default_llseek, 1404b4148e9SMarcel Holtmann }; 1414b4148e9SMarcel Holtmann 1421da177e4SLinus Torvalds /* ---- HCI requests ---- */ 1431da177e4SLinus Torvalds 1441904a853SMarcel Holtmann static void hci_req_sync_complete(struct hci_dev *hdev, u8 result, u16 opcode) 1451da177e4SLinus Torvalds { 14642c6b129SJohan Hedberg BT_DBG("%s result 0x%2.2x", hdev->name, result); 14775fb0e32SJohan Hedberg 1481da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1491da177e4SLinus Torvalds hdev->req_result = result; 1501da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 1511da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1521da177e4SLinus Torvalds } 1531da177e4SLinus Torvalds } 1541da177e4SLinus Torvalds 1551da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 1561da177e4SLinus Torvalds { 1571da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 1581da177e4SLinus Torvalds 1591da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1601da177e4SLinus Torvalds hdev->req_result = err; 1611da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 1621da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1631da177e4SLinus Torvalds } 1641da177e4SLinus Torvalds } 1651da177e4SLinus Torvalds 16677a63e0aSFengguang Wu static struct sk_buff *hci_get_cmd_complete(struct hci_dev *hdev, u16 opcode, 16777a63e0aSFengguang Wu u8 event) 16875e84b7cSJohan Hedberg { 16975e84b7cSJohan Hedberg struct hci_ev_cmd_complete *ev; 17075e84b7cSJohan Hedberg struct hci_event_hdr *hdr; 17175e84b7cSJohan Hedberg struct sk_buff *skb; 17275e84b7cSJohan Hedberg 17375e84b7cSJohan Hedberg hci_dev_lock(hdev); 17475e84b7cSJohan Hedberg 17575e84b7cSJohan Hedberg skb = hdev->recv_evt; 17675e84b7cSJohan Hedberg hdev->recv_evt = NULL; 17775e84b7cSJohan Hedberg 17875e84b7cSJohan Hedberg hci_dev_unlock(hdev); 17975e84b7cSJohan Hedberg 18075e84b7cSJohan Hedberg if (!skb) 18175e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 18275e84b7cSJohan Hedberg 18375e84b7cSJohan Hedberg if (skb->len < sizeof(*hdr)) { 18475e84b7cSJohan Hedberg BT_ERR("Too short HCI event"); 18575e84b7cSJohan Hedberg goto failed; 18675e84b7cSJohan Hedberg } 18775e84b7cSJohan Hedberg 18875e84b7cSJohan Hedberg hdr = (void *) skb->data; 18975e84b7cSJohan Hedberg skb_pull(skb, HCI_EVENT_HDR_SIZE); 19075e84b7cSJohan Hedberg 1917b1abbbeSJohan Hedberg if (event) { 1927b1abbbeSJohan Hedberg if (hdr->evt != event) 1937b1abbbeSJohan Hedberg goto failed; 1947b1abbbeSJohan Hedberg return skb; 1957b1abbbeSJohan Hedberg } 1967b1abbbeSJohan Hedberg 19775e84b7cSJohan Hedberg if (hdr->evt != HCI_EV_CMD_COMPLETE) { 19875e84b7cSJohan Hedberg BT_DBG("Last event is not cmd complete (0x%2.2x)", hdr->evt); 19975e84b7cSJohan Hedberg goto failed; 20075e84b7cSJohan Hedberg } 20175e84b7cSJohan Hedberg 20275e84b7cSJohan Hedberg if (skb->len < sizeof(*ev)) { 20375e84b7cSJohan Hedberg BT_ERR("Too short cmd_complete event"); 20475e84b7cSJohan Hedberg goto failed; 20575e84b7cSJohan Hedberg } 20675e84b7cSJohan Hedberg 20775e84b7cSJohan Hedberg ev = (void *) skb->data; 20875e84b7cSJohan Hedberg skb_pull(skb, sizeof(*ev)); 20975e84b7cSJohan Hedberg 21075e84b7cSJohan Hedberg if (opcode == __le16_to_cpu(ev->opcode)) 21175e84b7cSJohan Hedberg return skb; 21275e84b7cSJohan Hedberg 21375e84b7cSJohan Hedberg BT_DBG("opcode doesn't match (0x%2.2x != 0x%2.2x)", opcode, 21475e84b7cSJohan Hedberg __le16_to_cpu(ev->opcode)); 21575e84b7cSJohan Hedberg 21675e84b7cSJohan Hedberg failed: 21775e84b7cSJohan Hedberg kfree_skb(skb); 21875e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 21975e84b7cSJohan Hedberg } 22075e84b7cSJohan Hedberg 2217b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, 22207dc93ddSJohan Hedberg const void *param, u8 event, u32 timeout) 22375e84b7cSJohan Hedberg { 22475e84b7cSJohan Hedberg DECLARE_WAITQUEUE(wait, current); 22575e84b7cSJohan Hedberg struct hci_request req; 22675e84b7cSJohan Hedberg int err = 0; 22775e84b7cSJohan Hedberg 22875e84b7cSJohan Hedberg BT_DBG("%s", hdev->name); 22975e84b7cSJohan Hedberg 23075e84b7cSJohan Hedberg hci_req_init(&req, hdev); 23175e84b7cSJohan Hedberg 2327b1abbbeSJohan Hedberg hci_req_add_ev(&req, opcode, plen, param, event); 23375e84b7cSJohan Hedberg 23475e84b7cSJohan Hedberg hdev->req_status = HCI_REQ_PEND; 23575e84b7cSJohan Hedberg 23675e84b7cSJohan Hedberg add_wait_queue(&hdev->req_wait_q, &wait); 23775e84b7cSJohan Hedberg set_current_state(TASK_INTERRUPTIBLE); 23875e84b7cSJohan Hedberg 239039fada5SChan-yeol Park err = hci_req_run(&req, hci_req_sync_complete); 240039fada5SChan-yeol Park if (err < 0) { 241039fada5SChan-yeol Park remove_wait_queue(&hdev->req_wait_q, &wait); 24222a3ceabSJohan Hedberg set_current_state(TASK_RUNNING); 243039fada5SChan-yeol Park return ERR_PTR(err); 244039fada5SChan-yeol Park } 245039fada5SChan-yeol Park 24675e84b7cSJohan Hedberg schedule_timeout(timeout); 24775e84b7cSJohan Hedberg 24875e84b7cSJohan Hedberg remove_wait_queue(&hdev->req_wait_q, &wait); 24975e84b7cSJohan Hedberg 25075e84b7cSJohan Hedberg if (signal_pending(current)) 25175e84b7cSJohan Hedberg return ERR_PTR(-EINTR); 25275e84b7cSJohan Hedberg 25375e84b7cSJohan Hedberg switch (hdev->req_status) { 25475e84b7cSJohan Hedberg case HCI_REQ_DONE: 25575e84b7cSJohan Hedberg err = -bt_to_errno(hdev->req_result); 25675e84b7cSJohan Hedberg break; 25775e84b7cSJohan Hedberg 25875e84b7cSJohan Hedberg case HCI_REQ_CANCELED: 25975e84b7cSJohan Hedberg err = -hdev->req_result; 26075e84b7cSJohan Hedberg break; 26175e84b7cSJohan Hedberg 26275e84b7cSJohan Hedberg default: 26375e84b7cSJohan Hedberg err = -ETIMEDOUT; 26475e84b7cSJohan Hedberg break; 26575e84b7cSJohan Hedberg } 26675e84b7cSJohan Hedberg 26775e84b7cSJohan Hedberg hdev->req_status = hdev->req_result = 0; 26875e84b7cSJohan Hedberg 26975e84b7cSJohan Hedberg BT_DBG("%s end: err %d", hdev->name, err); 27075e84b7cSJohan Hedberg 27175e84b7cSJohan Hedberg if (err < 0) 27275e84b7cSJohan Hedberg return ERR_PTR(err); 27375e84b7cSJohan Hedberg 2747b1abbbeSJohan Hedberg return hci_get_cmd_complete(hdev, opcode, event); 2757b1abbbeSJohan Hedberg } 2767b1abbbeSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync_ev); 2777b1abbbeSJohan Hedberg 2787b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 27907dc93ddSJohan Hedberg const void *param, u32 timeout) 2807b1abbbeSJohan Hedberg { 2817b1abbbeSJohan Hedberg return __hci_cmd_sync_ev(hdev, opcode, plen, param, 0, timeout); 28275e84b7cSJohan Hedberg } 28375e84b7cSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync); 28475e84b7cSJohan Hedberg 2851da177e4SLinus Torvalds /* Execute request and wait for completion. */ 28601178cd4SJohan Hedberg static int __hci_req_sync(struct hci_dev *hdev, 28742c6b129SJohan Hedberg void (*func)(struct hci_request *req, 28842c6b129SJohan Hedberg unsigned long opt), 2891da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 2901da177e4SLinus Torvalds { 29142c6b129SJohan Hedberg struct hci_request req; 2921da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 2931da177e4SLinus Torvalds int err = 0; 2941da177e4SLinus Torvalds 2951da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 2961da177e4SLinus Torvalds 29742c6b129SJohan Hedberg hci_req_init(&req, hdev); 29842c6b129SJohan Hedberg 2991da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 3001da177e4SLinus Torvalds 30142c6b129SJohan Hedberg func(&req, opt); 30253cce22dSJohan Hedberg 303039fada5SChan-yeol Park add_wait_queue(&hdev->req_wait_q, &wait); 304039fada5SChan-yeol Park set_current_state(TASK_INTERRUPTIBLE); 305039fada5SChan-yeol Park 30642c6b129SJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 30742c6b129SJohan Hedberg if (err < 0) { 30853cce22dSJohan Hedberg hdev->req_status = 0; 309920c8300SAndre Guedes 310039fada5SChan-yeol Park remove_wait_queue(&hdev->req_wait_q, &wait); 31122a3ceabSJohan Hedberg set_current_state(TASK_RUNNING); 312039fada5SChan-yeol Park 313920c8300SAndre Guedes /* ENODATA means the HCI request command queue is empty. 314920c8300SAndre Guedes * This can happen when a request with conditionals doesn't 315920c8300SAndre Guedes * trigger any commands to be sent. This is normal behavior 316920c8300SAndre Guedes * and should not trigger an error return. 31742c6b129SJohan Hedberg */ 318920c8300SAndre Guedes if (err == -ENODATA) 31942c6b129SJohan Hedberg return 0; 320920c8300SAndre Guedes 321920c8300SAndre Guedes return err; 32253cce22dSJohan Hedberg } 32353cce22dSJohan Hedberg 3241da177e4SLinus Torvalds schedule_timeout(timeout); 3251da177e4SLinus Torvalds 3261da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 3271da177e4SLinus Torvalds 3281da177e4SLinus Torvalds if (signal_pending(current)) 3291da177e4SLinus Torvalds return -EINTR; 3301da177e4SLinus Torvalds 3311da177e4SLinus Torvalds switch (hdev->req_status) { 3321da177e4SLinus Torvalds case HCI_REQ_DONE: 333e175072fSJoe Perches err = -bt_to_errno(hdev->req_result); 3341da177e4SLinus Torvalds break; 3351da177e4SLinus Torvalds 3361da177e4SLinus Torvalds case HCI_REQ_CANCELED: 3371da177e4SLinus Torvalds err = -hdev->req_result; 3381da177e4SLinus Torvalds break; 3391da177e4SLinus Torvalds 3401da177e4SLinus Torvalds default: 3411da177e4SLinus Torvalds err = -ETIMEDOUT; 3421da177e4SLinus Torvalds break; 3433ff50b79SStephen Hemminger } 3441da177e4SLinus Torvalds 345a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 3461da177e4SLinus Torvalds 3471da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 3481da177e4SLinus Torvalds 3491da177e4SLinus Torvalds return err; 3501da177e4SLinus Torvalds } 3511da177e4SLinus Torvalds 35201178cd4SJohan Hedberg static int hci_req_sync(struct hci_dev *hdev, 35342c6b129SJohan Hedberg void (*req)(struct hci_request *req, 35442c6b129SJohan Hedberg unsigned long opt), 3551da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 3561da177e4SLinus Torvalds { 3571da177e4SLinus Torvalds int ret; 3581da177e4SLinus Torvalds 3597c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 3607c6a329eSMarcel Holtmann return -ENETDOWN; 3617c6a329eSMarcel Holtmann 3621da177e4SLinus Torvalds /* Serialize all requests */ 3631da177e4SLinus Torvalds hci_req_lock(hdev); 36401178cd4SJohan Hedberg ret = __hci_req_sync(hdev, req, opt, timeout); 3651da177e4SLinus Torvalds hci_req_unlock(hdev); 3661da177e4SLinus Torvalds 3671da177e4SLinus Torvalds return ret; 3681da177e4SLinus Torvalds } 3691da177e4SLinus Torvalds 37042c6b129SJohan Hedberg static void hci_reset_req(struct hci_request *req, unsigned long opt) 3711da177e4SLinus Torvalds { 37242c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 3731da177e4SLinus Torvalds 3741da177e4SLinus Torvalds /* Reset device */ 37542c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 37642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 3771da177e4SLinus Torvalds } 3781da177e4SLinus Torvalds 37942c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 3801da177e4SLinus Torvalds { 38142c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 3822455a3eaSAndrei Emeltchenko 3831da177e4SLinus Torvalds /* Read Local Supported Features */ 38442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 3851da177e4SLinus Torvalds 3861143e5a6SMarcel Holtmann /* Read Local Version */ 38742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 3882177bab5SJohan Hedberg 3892177bab5SJohan Hedberg /* Read BD Address */ 39042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 3911da177e4SLinus Torvalds } 3921da177e4SLinus Torvalds 39342c6b129SJohan Hedberg static void amp_init(struct hci_request *req) 394e61ef499SAndrei Emeltchenko { 39542c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 3962455a3eaSAndrei Emeltchenko 397e61ef499SAndrei Emeltchenko /* Read Local Version */ 39842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 3996bcbc489SAndrei Emeltchenko 400f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 401f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 402f6996cfeSMarcel Holtmann 403f6996cfeSMarcel Holtmann /* Read Local Supported Features */ 404f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 405f6996cfeSMarcel Holtmann 4066bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 40742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 408e71dfabaSAndrei Emeltchenko 409e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 41042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 4117528ca1cSMarcel Holtmann 412f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 413f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 414f38ba941SMarcel Holtmann 4157528ca1cSMarcel Holtmann /* Read Location Data */ 4167528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 417e61ef499SAndrei Emeltchenko } 418e61ef499SAndrei Emeltchenko 41942c6b129SJohan Hedberg static void hci_init1_req(struct hci_request *req, unsigned long opt) 420e61ef499SAndrei Emeltchenko { 42142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 422e61ef499SAndrei Emeltchenko 423e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 424e61ef499SAndrei Emeltchenko 42511778716SAndrei Emeltchenko /* Reset */ 42611778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 42742c6b129SJohan Hedberg hci_reset_req(req, 0); 42811778716SAndrei Emeltchenko 429e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 430e61ef499SAndrei Emeltchenko case HCI_BREDR: 43142c6b129SJohan Hedberg bredr_init(req); 432e61ef499SAndrei Emeltchenko break; 433e61ef499SAndrei Emeltchenko 434e61ef499SAndrei Emeltchenko case HCI_AMP: 43542c6b129SJohan Hedberg amp_init(req); 436e61ef499SAndrei Emeltchenko break; 437e61ef499SAndrei Emeltchenko 438e61ef499SAndrei Emeltchenko default: 439e61ef499SAndrei Emeltchenko BT_ERR("Unknown device type %d", hdev->dev_type); 440e61ef499SAndrei Emeltchenko break; 441e61ef499SAndrei Emeltchenko } 442e61ef499SAndrei Emeltchenko } 443e61ef499SAndrei Emeltchenko 44442c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 4452177bab5SJohan Hedberg { 4462177bab5SJohan Hedberg __le16 param; 4472177bab5SJohan Hedberg __u8 flt_type; 4482177bab5SJohan Hedberg 4492177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 45042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 4512177bab5SJohan Hedberg 4522177bab5SJohan Hedberg /* Read Class of Device */ 45342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 4542177bab5SJohan Hedberg 4552177bab5SJohan Hedberg /* Read Local Name */ 45642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 4572177bab5SJohan Hedberg 4582177bab5SJohan Hedberg /* Read Voice Setting */ 45942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 4602177bab5SJohan Hedberg 461b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 462b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 463b4cb9fb2SMarcel Holtmann 4644b836f39SMarcel Holtmann /* Read Current IAC LAP */ 4654b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 4664b836f39SMarcel Holtmann 4672177bab5SJohan Hedberg /* Clear Event Filters */ 4682177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 46942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 4702177bab5SJohan Hedberg 4712177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 472dcf4adbfSJoe Perches param = cpu_to_le16(0x7d00); 47342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 4742177bab5SJohan Hedberg } 4752177bab5SJohan Hedberg 47642c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 4772177bab5SJohan Hedberg { 478c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 479c73eee91SJohan Hedberg 4802177bab5SJohan Hedberg /* Read LE Buffer Size */ 48142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 4822177bab5SJohan Hedberg 4832177bab5SJohan Hedberg /* Read LE Local Supported Features */ 48442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 4852177bab5SJohan Hedberg 486747d3f03SMarcel Holtmann /* Read LE Supported States */ 487747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 488747d3f03SMarcel Holtmann 4892177bab5SJohan Hedberg /* Read LE White List Size */ 49042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 0, NULL); 4912177bab5SJohan Hedberg 492747d3f03SMarcel Holtmann /* Clear LE White List */ 493747d3f03SMarcel Holtmann hci_req_add(req, HCI_OP_LE_CLEAR_WHITE_LIST, 0, NULL); 494c73eee91SJohan Hedberg 495c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 496c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 497c73eee91SJohan Hedberg set_bit(HCI_LE_ENABLED, &hdev->dev_flags); 4982177bab5SJohan Hedberg } 4992177bab5SJohan Hedberg 50042c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 5012177bab5SJohan Hedberg { 50242c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 50342c6b129SJohan Hedberg 5042177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 5052177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 5062177bab5SJohan Hedberg * command otherwise. 5072177bab5SJohan Hedberg */ 5082177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 5092177bab5SJohan Hedberg 5102177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 5112177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 5122177bab5SJohan Hedberg */ 5132177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 5142177bab5SJohan Hedberg return; 5152177bab5SJohan Hedberg 5162177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 5172177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 5182177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 5192177bab5SJohan Hedberg events[4] |= 0x04; /* Read Remote Extended Features Complete */ 5202177bab5SJohan Hedberg events[5] |= 0x08; /* Synchronous Connection Complete */ 5212177bab5SJohan Hedberg events[5] |= 0x10; /* Synchronous Connection Changed */ 522c7882cbdSMarcel Holtmann } else { 523c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 524c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 525c7882cbdSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 526c7882cbdSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information Complete */ 527c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 528c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 529c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 530c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 531c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 5320da71f1bSMarcel Holtmann 5330da71f1bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) { 5340da71f1bSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 535c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 5362177bab5SJohan Hedberg } 5370da71f1bSMarcel Holtmann } 5382177bab5SJohan Hedberg 5392177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 5402177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 5412177bab5SJohan Hedberg 5422177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 5432177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 5442177bab5SJohan Hedberg 5452177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 5462177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 5472177bab5SJohan Hedberg 5482177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 5492177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 5502177bab5SJohan Hedberg 5512177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 5522177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 5532177bab5SJohan Hedberg 5542177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 5552177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 5562177bab5SJohan Hedberg 5572177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 5582177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 5592177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 5602177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 5612177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 5622177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 5632177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 5642177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 5652177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 5662177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 5672177bab5SJohan Hedberg * Features Notification 5682177bab5SJohan Hedberg */ 5692177bab5SJohan Hedberg } 5702177bab5SJohan Hedberg 5712177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 5722177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 5732177bab5SJohan Hedberg 57442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 5752177bab5SJohan Hedberg } 5762177bab5SJohan Hedberg 57742c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 5782177bab5SJohan Hedberg { 57942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 58042c6b129SJohan Hedberg 5812177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 58242c6b129SJohan Hedberg bredr_setup(req); 58356f87901SJohan Hedberg else 58456f87901SJohan Hedberg clear_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 5852177bab5SJohan Hedberg 5862177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 58742c6b129SJohan Hedberg le_setup(req); 5882177bab5SJohan Hedberg 5890f3adeaeSMarcel Holtmann /* All Bluetooth 1.2 and later controllers should support the 5900f3adeaeSMarcel Holtmann * HCI command for reading the local supported commands. 5910f3adeaeSMarcel Holtmann * 5920f3adeaeSMarcel Holtmann * Unfortunately some controllers indicate Bluetooth 1.2 support, 5930f3adeaeSMarcel Holtmann * but do not have support for this command. If that is the case, 5940f3adeaeSMarcel Holtmann * the driver can quirk the behavior and skip reading the local 5950f3adeaeSMarcel Holtmann * supported commands. 5963f8e2d75SJohan Hedberg */ 5970f3adeaeSMarcel Holtmann if (hdev->hci_ver > BLUETOOTH_VER_1_1 && 5980f3adeaeSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_LOCAL_COMMANDS, &hdev->quirks)) 59942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 6002177bab5SJohan Hedberg 6012177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 60257af75a8SMarcel Holtmann /* When SSP is available, then the host features page 60357af75a8SMarcel Holtmann * should also be available as well. However some 60457af75a8SMarcel Holtmann * controllers list the max_page as 0 as long as SSP 60557af75a8SMarcel Holtmann * has not been enabled. To achieve proper debugging 60657af75a8SMarcel Holtmann * output, force the minimum max_page to 1 at least. 60757af75a8SMarcel Holtmann */ 60857af75a8SMarcel Holtmann hdev->max_page = 0x01; 60957af75a8SMarcel Holtmann 6102177bab5SJohan Hedberg if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) { 6112177bab5SJohan Hedberg u8 mode = 0x01; 612574ea3c7SMarcel Holtmann 61342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 6142177bab5SJohan Hedberg sizeof(mode), &mode); 6152177bab5SJohan Hedberg } else { 6162177bab5SJohan Hedberg struct hci_cp_write_eir cp; 6172177bab5SJohan Hedberg 6182177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 6192177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 6202177bab5SJohan Hedberg 62142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 6222177bab5SJohan Hedberg } 6232177bab5SJohan Hedberg } 6242177bab5SJohan Hedberg 625043ec9bfSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 626043ec9bfSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) { 62704422da9SMarcel Holtmann u8 mode; 62804422da9SMarcel Holtmann 62904422da9SMarcel Holtmann /* If Extended Inquiry Result events are supported, then 63004422da9SMarcel Holtmann * they are clearly preferred over Inquiry Result with RSSI 63104422da9SMarcel Holtmann * events. 63204422da9SMarcel Holtmann */ 63304422da9SMarcel Holtmann mode = lmp_ext_inq_capable(hdev) ? 0x02 : 0x01; 63404422da9SMarcel Holtmann 63504422da9SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 63604422da9SMarcel Holtmann } 6372177bab5SJohan Hedberg 6382177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 63942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 6402177bab5SJohan Hedberg 6412177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 6422177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 6432177bab5SJohan Hedberg 6442177bab5SJohan Hedberg cp.page = 0x01; 64542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 64642c6b129SJohan Hedberg sizeof(cp), &cp); 6472177bab5SJohan Hedberg } 6482177bab5SJohan Hedberg 6492177bab5SJohan Hedberg if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) { 6502177bab5SJohan Hedberg u8 enable = 1; 65142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 6522177bab5SJohan Hedberg &enable); 6532177bab5SJohan Hedberg } 6542177bab5SJohan Hedberg } 6552177bab5SJohan Hedberg 65642c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 6572177bab5SJohan Hedberg { 65842c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 6592177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 6602177bab5SJohan Hedberg u16 link_policy = 0; 6612177bab5SJohan Hedberg 6622177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 6632177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 6642177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 6652177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 6662177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 6672177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 6682177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 6692177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 6702177bab5SJohan Hedberg 6712177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 67242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 6732177bab5SJohan Hedberg } 6742177bab5SJohan Hedberg 67542c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 6762177bab5SJohan Hedberg { 67742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 6782177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 6792177bab5SJohan Hedberg 680c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 681c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 682c73eee91SJohan Hedberg return; 683c73eee91SJohan Hedberg 6842177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 6852177bab5SJohan Hedberg 6862177bab5SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) { 6872177bab5SJohan Hedberg cp.le = 0x01; 68832226e4fSMarcel Holtmann cp.simul = 0x00; 6892177bab5SJohan Hedberg } 6902177bab5SJohan Hedberg 6912177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 69242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 6932177bab5SJohan Hedberg &cp); 6942177bab5SJohan Hedberg } 6952177bab5SJohan Hedberg 696d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 697d62e6d67SJohan Hedberg { 698d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 699d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 700d62e6d67SJohan Hedberg 701d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 702d62e6d67SJohan Hedberg * enable all necessary events for it. 703d62e6d67SJohan Hedberg */ 70453b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 705d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 706d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 707d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 708d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 709d62e6d67SJohan Hedberg } 710d62e6d67SJohan Hedberg 711d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 712d62e6d67SJohan Hedberg * enable all necessary events for it. 713d62e6d67SJohan Hedberg */ 71453b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 715d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 716d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 717d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 718d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 719d62e6d67SJohan Hedberg } 720d62e6d67SJohan Hedberg 72140c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 722cd7ca0ecSMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) 72340c59fcbSMarcel Holtmann events[2] |= 0x80; 72440c59fcbSMarcel Holtmann 725d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 726d62e6d67SJohan Hedberg } 727d62e6d67SJohan Hedberg 72842c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 7292177bab5SJohan Hedberg { 73042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 731d2c5d77fSJohan Hedberg u8 p; 73242c6b129SJohan Hedberg 7330da71f1bSMarcel Holtmann hci_setup_event_mask(req); 7340da71f1bSMarcel Holtmann 73548ce62c4SMarcel Holtmann if (hdev->commands[6] & 0x20) { 73648ce62c4SMarcel Holtmann struct hci_cp_read_stored_link_key cp; 73748ce62c4SMarcel Holtmann 73848ce62c4SMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 73948ce62c4SMarcel Holtmann cp.read_all = 0x01; 74048ce62c4SMarcel Holtmann hci_req_add(req, HCI_OP_READ_STORED_LINK_KEY, sizeof(cp), &cp); 74148ce62c4SMarcel Holtmann } 74248ce62c4SMarcel Holtmann 7432177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 74442c6b129SJohan Hedberg hci_setup_link_policy(req); 7452177bab5SJohan Hedberg 746417287deSMarcel Holtmann if (hdev->commands[8] & 0x01) 747417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 748417287deSMarcel Holtmann 749417287deSMarcel Holtmann /* Some older Broadcom based Bluetooth 1.2 controllers do not 750417287deSMarcel Holtmann * support the Read Page Scan Type command. Check support for 751417287deSMarcel Holtmann * this command in the bit mask of supported commands. 752417287deSMarcel Holtmann */ 753417287deSMarcel Holtmann if (hdev->commands[13] & 0x01) 754417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 755417287deSMarcel Holtmann 7569193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 7579193c6e8SAndre Guedes u8 events[8]; 7589193c6e8SAndre Guedes 7599193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 7604d6c705bSMarcel Holtmann events[0] = 0x0f; 7614d6c705bSMarcel Holtmann 7624d6c705bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) 7634d6c705bSMarcel Holtmann events[0] |= 0x10; /* LE Long Term Key Request */ 764662bc2e6SAndre Guedes 765662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 766662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 767662bc2e6SAndre Guedes */ 768662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 769662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 770662bc2e6SAndre Guedes * Parameter Request 771662bc2e6SAndre Guedes */ 772662bc2e6SAndre Guedes 773a9f6068eSMarcel Holtmann /* If the controller supports the Data Length Extension 774a9f6068eSMarcel Holtmann * feature, enable the corresponding event. 775a9f6068eSMarcel Holtmann */ 776a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) 777a9f6068eSMarcel Holtmann events[0] |= 0x40; /* LE Data Length Change */ 778a9f6068eSMarcel Holtmann 7794b71bba4SMarcel Holtmann /* If the controller supports Extended Scanner Filter 7804b71bba4SMarcel Holtmann * Policies, enable the correspondig event. 7814b71bba4SMarcel Holtmann */ 7824b71bba4SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_EXT_SCAN_POLICY) 7834b71bba4SMarcel Holtmann events[1] |= 0x04; /* LE Direct Advertising 7844b71bba4SMarcel Holtmann * Report 7854b71bba4SMarcel Holtmann */ 7864b71bba4SMarcel Holtmann 7875a34bd5fSMarcel Holtmann /* If the controller supports the LE Read Local P-256 7885a34bd5fSMarcel Holtmann * Public Key command, enable the corresponding event. 7895a34bd5fSMarcel Holtmann */ 7905a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x02) 7915a34bd5fSMarcel Holtmann events[0] |= 0x80; /* LE Read Local P-256 7925a34bd5fSMarcel Holtmann * Public Key Complete 7935a34bd5fSMarcel Holtmann */ 7945a34bd5fSMarcel Holtmann 7955a34bd5fSMarcel Holtmann /* If the controller supports the LE Generate DHKey 7965a34bd5fSMarcel Holtmann * command, enable the corresponding event. 7975a34bd5fSMarcel Holtmann */ 7985a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x04) 7995a34bd5fSMarcel Holtmann events[1] |= 0x01; /* LE Generate DHKey Complete */ 8005a34bd5fSMarcel Holtmann 8019193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 8029193c6e8SAndre Guedes events); 8039193c6e8SAndre Guedes 80415a49ccaSMarcel Holtmann if (hdev->commands[25] & 0x40) { 80515a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 80615a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 80715a49ccaSMarcel Holtmann } 80815a49ccaSMarcel Holtmann 809a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 810a9f6068eSMarcel Holtmann /* Read LE Maximum Data Length */ 811a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_MAX_DATA_LEN, 0, NULL); 812a9f6068eSMarcel Holtmann 813a9f6068eSMarcel Holtmann /* Read LE Suggested Default Data Length */ 814a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_DEF_DATA_LEN, 0, NULL); 815a9f6068eSMarcel Holtmann } 816a9f6068eSMarcel Holtmann 81742c6b129SJohan Hedberg hci_set_le_support(req); 8189193c6e8SAndre Guedes } 819d2c5d77fSJohan Hedberg 820d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 821d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 822d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 823d2c5d77fSJohan Hedberg 824d2c5d77fSJohan Hedberg cp.page = p; 825d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 826d2c5d77fSJohan Hedberg sizeof(cp), &cp); 827d2c5d77fSJohan Hedberg } 8282177bab5SJohan Hedberg } 8292177bab5SJohan Hedberg 8305d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 8315d4e7e8dSJohan Hedberg { 8325d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 8335d4e7e8dSJohan Hedberg 83436f260ceSMarcel Holtmann /* Some Broadcom based Bluetooth controllers do not support the 83536f260ceSMarcel Holtmann * Delete Stored Link Key command. They are clearly indicating its 83636f260ceSMarcel Holtmann * absence in the bit mask of supported commands. 83736f260ceSMarcel Holtmann * 83836f260ceSMarcel Holtmann * Check the supported commands and only if the the command is marked 83936f260ceSMarcel Holtmann * as supported send it. If not supported assume that the controller 84036f260ceSMarcel Holtmann * does not have actual support for stored link keys which makes this 84136f260ceSMarcel Holtmann * command redundant anyway. 84236f260ceSMarcel Holtmann * 84336f260ceSMarcel Holtmann * Some controllers indicate that they support handling deleting 84436f260ceSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 84536f260ceSMarcel Holtmann * just disable this command. 84636f260ceSMarcel Holtmann */ 84736f260ceSMarcel Holtmann if (hdev->commands[6] & 0x80 && 84836f260ceSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 84936f260ceSMarcel Holtmann struct hci_cp_delete_stored_link_key cp; 85036f260ceSMarcel Holtmann 85136f260ceSMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 85236f260ceSMarcel Holtmann cp.delete_all = 0x01; 85336f260ceSMarcel Holtmann hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 85436f260ceSMarcel Holtmann sizeof(cp), &cp); 85536f260ceSMarcel Holtmann } 85636f260ceSMarcel Holtmann 857d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 858d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 859d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 860d62e6d67SJohan Hedberg 861109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 862109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 863109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 864109e3191SMarcel Holtmann 865f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 866f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 867f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 868f4fe73edSMarcel Holtmann 8695d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 87053b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 8715d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 872a6d0d690SMarcel Holtmann 873a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 874574ea3c7SMarcel Holtmann if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags) && 875574ea3c7SMarcel Holtmann bredr_sc_enabled(hdev)) { 876a6d0d690SMarcel Holtmann u8 support = 0x01; 877574ea3c7SMarcel Holtmann 878a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 879a6d0d690SMarcel Holtmann sizeof(support), &support); 880a6d0d690SMarcel Holtmann } 8815d4e7e8dSJohan Hedberg } 8825d4e7e8dSJohan Hedberg 8832177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 8842177bab5SJohan Hedberg { 8852177bab5SJohan Hedberg int err; 8862177bab5SJohan Hedberg 8872177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 8882177bab5SJohan Hedberg if (err < 0) 8892177bab5SJohan Hedberg return err; 8902177bab5SJohan Hedberg 8914b4148e9SMarcel Holtmann /* The Device Under Test (DUT) mode is special and available for 8924b4148e9SMarcel Holtmann * all controller types. So just create it early on. 8934b4148e9SMarcel Holtmann */ 8944b4148e9SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 8954b4148e9SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 8964b4148e9SMarcel Holtmann &dut_mode_fops); 8974b4148e9SMarcel Holtmann } 8984b4148e9SMarcel Holtmann 8992177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 9002177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 9012177bab5SJohan Hedberg * first stage init. 9022177bab5SJohan Hedberg */ 9032177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 9042177bab5SJohan Hedberg return 0; 9052177bab5SJohan Hedberg 9062177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 9072177bab5SJohan Hedberg if (err < 0) 9082177bab5SJohan Hedberg return err; 9092177bab5SJohan Hedberg 9105d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 9115d4e7e8dSJohan Hedberg if (err < 0) 9125d4e7e8dSJohan Hedberg return err; 9135d4e7e8dSJohan Hedberg 914baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 915baf27f6eSMarcel Holtmann if (err < 0) 916baf27f6eSMarcel Holtmann return err; 917baf27f6eSMarcel Holtmann 918ec6cef9cSMarcel Holtmann /* This function is only called when the controller is actually in 919ec6cef9cSMarcel Holtmann * configured state. When the controller is marked as unconfigured, 920ec6cef9cSMarcel Holtmann * this initialization procedure is not run. 921ec6cef9cSMarcel Holtmann * 922ec6cef9cSMarcel Holtmann * It means that it is possible that a controller runs through its 923ec6cef9cSMarcel Holtmann * setup phase and then discovers missing settings. If that is the 924ec6cef9cSMarcel Holtmann * case, then this function will not be called. It then will only 925ec6cef9cSMarcel Holtmann * be called during the config phase. 926ec6cef9cSMarcel Holtmann * 927ec6cef9cSMarcel Holtmann * So only when in setup phase or config phase, create the debugfs 928ec6cef9cSMarcel Holtmann * entries and register the SMP channels. 929baf27f6eSMarcel Holtmann */ 930ec6cef9cSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 931ec6cef9cSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) 932baf27f6eSMarcel Holtmann return 0; 933baf27f6eSMarcel Holtmann 93460c5f5fbSMarcel Holtmann hci_debugfs_create_common(hdev); 93560c5f5fbSMarcel Holtmann 93671c3b60eSMarcel Holtmann if (lmp_bredr_capable(hdev)) 93760c5f5fbSMarcel Holtmann hci_debugfs_create_bredr(hdev); 9382bfa3531SMarcel Holtmann 939162a3bacSMarcel Holtmann if (lmp_le_capable(hdev)) 94060c5f5fbSMarcel Holtmann hci_debugfs_create_le(hdev); 941e7b8fc92SMarcel Holtmann 942baf27f6eSMarcel Holtmann return 0; 9432177bab5SJohan Hedberg } 9442177bab5SJohan Hedberg 9450ebca7d6SMarcel Holtmann static void hci_init0_req(struct hci_request *req, unsigned long opt) 9460ebca7d6SMarcel Holtmann { 9470ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 9480ebca7d6SMarcel Holtmann 9490ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 9500ebca7d6SMarcel Holtmann 9510ebca7d6SMarcel Holtmann /* Reset */ 9520ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 9530ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 9540ebca7d6SMarcel Holtmann 9550ebca7d6SMarcel Holtmann /* Read Local Version */ 9560ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 9570ebca7d6SMarcel Holtmann 9580ebca7d6SMarcel Holtmann /* Read BD Address */ 9590ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 9600ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 9610ebca7d6SMarcel Holtmann } 9620ebca7d6SMarcel Holtmann 9630ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 9640ebca7d6SMarcel Holtmann { 9650ebca7d6SMarcel Holtmann int err; 9660ebca7d6SMarcel Holtmann 967cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 968cc78b44bSMarcel Holtmann return 0; 969cc78b44bSMarcel Holtmann 9700ebca7d6SMarcel Holtmann err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT); 9710ebca7d6SMarcel Holtmann if (err < 0) 9720ebca7d6SMarcel Holtmann return err; 9730ebca7d6SMarcel Holtmann 9740ebca7d6SMarcel Holtmann return 0; 9750ebca7d6SMarcel Holtmann } 9760ebca7d6SMarcel Holtmann 97742c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 9781da177e4SLinus Torvalds { 9791da177e4SLinus Torvalds __u8 scan = opt; 9801da177e4SLinus Torvalds 98142c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 9821da177e4SLinus Torvalds 9831da177e4SLinus Torvalds /* Inquiry and Page scans */ 98442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 9851da177e4SLinus Torvalds } 9861da177e4SLinus Torvalds 98742c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 9881da177e4SLinus Torvalds { 9891da177e4SLinus Torvalds __u8 auth = opt; 9901da177e4SLinus Torvalds 99142c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 9921da177e4SLinus Torvalds 9931da177e4SLinus Torvalds /* Authentication */ 99442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 9951da177e4SLinus Torvalds } 9961da177e4SLinus Torvalds 99742c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 9981da177e4SLinus Torvalds { 9991da177e4SLinus Torvalds __u8 encrypt = opt; 10001da177e4SLinus Torvalds 100142c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 10021da177e4SLinus Torvalds 1003e4e8e37cSMarcel Holtmann /* Encryption */ 100442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 10051da177e4SLinus Torvalds } 10061da177e4SLinus Torvalds 100742c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1008e4e8e37cSMarcel Holtmann { 1009e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1010e4e8e37cSMarcel Holtmann 101142c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1012e4e8e37cSMarcel Holtmann 1013e4e8e37cSMarcel Holtmann /* Default link policy */ 101442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1015e4e8e37cSMarcel Holtmann } 1016e4e8e37cSMarcel Holtmann 10171da177e4SLinus Torvalds /* Get HCI device by index. 10181da177e4SLinus Torvalds * Device is held on return. */ 10191da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 10201da177e4SLinus Torvalds { 10218035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 10221da177e4SLinus Torvalds 10231da177e4SLinus Torvalds BT_DBG("%d", index); 10241da177e4SLinus Torvalds 10251da177e4SLinus Torvalds if (index < 0) 10261da177e4SLinus Torvalds return NULL; 10271da177e4SLinus Torvalds 10281da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 10298035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 10301da177e4SLinus Torvalds if (d->id == index) { 10311da177e4SLinus Torvalds hdev = hci_dev_hold(d); 10321da177e4SLinus Torvalds break; 10331da177e4SLinus Torvalds } 10341da177e4SLinus Torvalds } 10351da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 10361da177e4SLinus Torvalds return hdev; 10371da177e4SLinus Torvalds } 10381da177e4SLinus Torvalds 10391da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1040ff9ef578SJohan Hedberg 104130dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 104230dc78e1SJohan Hedberg { 104330dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 104430dc78e1SJohan Hedberg 10456fbe195dSAndre Guedes switch (discov->state) { 1046343f935bSAndre Guedes case DISCOVERY_FINDING: 10476fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 104830dc78e1SJohan Hedberg return true; 104930dc78e1SJohan Hedberg 10506fbe195dSAndre Guedes default: 105130dc78e1SJohan Hedberg return false; 105230dc78e1SJohan Hedberg } 10536fbe195dSAndre Guedes } 105430dc78e1SJohan Hedberg 1055ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1056ff9ef578SJohan Hedberg { 1057bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 1058bb3e0a33SJohan Hedberg 1059ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1060ff9ef578SJohan Hedberg 1061bb3e0a33SJohan Hedberg if (old_state == state) 1062ff9ef578SJohan Hedberg return; 1063ff9ef578SJohan Hedberg 1064bb3e0a33SJohan Hedberg hdev->discovery.state = state; 1065bb3e0a33SJohan Hedberg 1066ff9ef578SJohan Hedberg switch (state) { 1067ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1068c54c3860SAndre Guedes hci_update_background_scan(hdev); 1069c54c3860SAndre Guedes 1070bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1071ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1072ff9ef578SJohan Hedberg break; 1073ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1074ff9ef578SJohan Hedberg break; 1075343f935bSAndre Guedes case DISCOVERY_FINDING: 1076ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1077ff9ef578SJohan Hedberg break; 107830dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 107930dc78e1SJohan Hedberg break; 1080ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1081ff9ef578SJohan Hedberg break; 1082ff9ef578SJohan Hedberg } 1083ff9ef578SJohan Hedberg } 1084ff9ef578SJohan Hedberg 10851f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 10861da177e4SLinus Torvalds { 108730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1088b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 10891da177e4SLinus Torvalds 1090561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1091561aafbcSJohan Hedberg list_del(&p->all); 1092b57c1a56SJohan Hedberg kfree(p); 10931da177e4SLinus Torvalds } 1094561aafbcSJohan Hedberg 1095561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1096561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 10971da177e4SLinus Torvalds } 10981da177e4SLinus Torvalds 1099a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1100a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 11011da177e4SLinus Torvalds { 110230883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 11031da177e4SLinus Torvalds struct inquiry_entry *e; 11041da177e4SLinus Torvalds 11056ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 11061da177e4SLinus Torvalds 1107561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 11081da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 11091da177e4SLinus Torvalds return e; 11101da177e4SLinus Torvalds } 11111da177e4SLinus Torvalds 1112b57c1a56SJohan Hedberg return NULL; 1113b57c1a56SJohan Hedberg } 1114b57c1a56SJohan Hedberg 1115561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1116561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1117561aafbcSJohan Hedberg { 111830883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1119561aafbcSJohan Hedberg struct inquiry_entry *e; 1120561aafbcSJohan Hedberg 11216ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1122561aafbcSJohan Hedberg 1123561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1124561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1125561aafbcSJohan Hedberg return e; 1126561aafbcSJohan Hedberg } 1127561aafbcSJohan Hedberg 1128561aafbcSJohan Hedberg return NULL; 1129561aafbcSJohan Hedberg } 1130561aafbcSJohan Hedberg 113130dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 113230dc78e1SJohan Hedberg bdaddr_t *bdaddr, 113330dc78e1SJohan Hedberg int state) 113430dc78e1SJohan Hedberg { 113530dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 113630dc78e1SJohan Hedberg struct inquiry_entry *e; 113730dc78e1SJohan Hedberg 11386ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 113930dc78e1SJohan Hedberg 114030dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 114130dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 114230dc78e1SJohan Hedberg return e; 114330dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 114430dc78e1SJohan Hedberg return e; 114530dc78e1SJohan Hedberg } 114630dc78e1SJohan Hedberg 114730dc78e1SJohan Hedberg return NULL; 114830dc78e1SJohan Hedberg } 114930dc78e1SJohan Hedberg 1150a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1151a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1152a3d4e20aSJohan Hedberg { 1153a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1154a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1155a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1156a3d4e20aSJohan Hedberg 1157a3d4e20aSJohan Hedberg list_del(&ie->list); 1158a3d4e20aSJohan Hedberg 1159a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1160a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1161a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1162a3d4e20aSJohan Hedberg break; 1163a3d4e20aSJohan Hedberg pos = &p->list; 1164a3d4e20aSJohan Hedberg } 1165a3d4e20aSJohan Hedberg 1166a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1167a3d4e20aSJohan Hedberg } 1168a3d4e20aSJohan Hedberg 1169af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1170af58925cSMarcel Holtmann bool name_known) 11711da177e4SLinus Torvalds { 117230883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 117370f23020SAndrei Emeltchenko struct inquiry_entry *ie; 1174af58925cSMarcel Holtmann u32 flags = 0; 11751da177e4SLinus Torvalds 11766ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 11771da177e4SLinus Torvalds 11786928a924SJohan Hedberg hci_remove_remote_oob_data(hdev, &data->bdaddr, BDADDR_BREDR); 11792b2fec4dSSzymon Janc 1180af58925cSMarcel Holtmann if (!data->ssp_mode) 1181af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1182388fc8faSJohan Hedberg 118370f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1184a3d4e20aSJohan Hedberg if (ie) { 1185af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 1186af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1187388fc8faSJohan Hedberg 1188a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1189a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1190a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1191a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1192a3d4e20aSJohan Hedberg } 1193a3d4e20aSJohan Hedberg 1194561aafbcSJohan Hedberg goto update; 1195a3d4e20aSJohan Hedberg } 1196561aafbcSJohan Hedberg 11971da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 119827f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 1199af58925cSMarcel Holtmann if (!ie) { 1200af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 1201af58925cSMarcel Holtmann goto done; 1202af58925cSMarcel Holtmann } 120370f23020SAndrei Emeltchenko 1204561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1205561aafbcSJohan Hedberg 1206561aafbcSJohan Hedberg if (name_known) { 1207561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1208561aafbcSJohan Hedberg } else { 1209561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1210561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1211561aafbcSJohan Hedberg } 1212561aafbcSJohan Hedberg 1213561aafbcSJohan Hedberg update: 1214561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1215561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1216561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1217561aafbcSJohan Hedberg list_del(&ie->list); 12181da177e4SLinus Torvalds } 12191da177e4SLinus Torvalds 122070f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 122170f23020SAndrei Emeltchenko ie->timestamp = jiffies; 12221da177e4SLinus Torvalds cache->timestamp = jiffies; 12233175405bSJohan Hedberg 12243175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 1225af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 12263175405bSJohan Hedberg 1227af58925cSMarcel Holtmann done: 1228af58925cSMarcel Holtmann return flags; 12291da177e4SLinus Torvalds } 12301da177e4SLinus Torvalds 12311da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 12321da177e4SLinus Torvalds { 123330883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 12341da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 12351da177e4SLinus Torvalds struct inquiry_entry *e; 12361da177e4SLinus Torvalds int copied = 0; 12371da177e4SLinus Torvalds 1238561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 12391da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1240b57c1a56SJohan Hedberg 1241b57c1a56SJohan Hedberg if (copied >= num) 1242b57c1a56SJohan Hedberg break; 1243b57c1a56SJohan Hedberg 12441da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 12451da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 12461da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 12471da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 12481da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 12491da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1250b57c1a56SJohan Hedberg 12511da177e4SLinus Torvalds info++; 1252b57c1a56SJohan Hedberg copied++; 12531da177e4SLinus Torvalds } 12541da177e4SLinus Torvalds 12551da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 12561da177e4SLinus Torvalds return copied; 12571da177e4SLinus Torvalds } 12581da177e4SLinus Torvalds 125942c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 12601da177e4SLinus Torvalds { 12611da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 126242c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 12631da177e4SLinus Torvalds struct hci_cp_inquiry cp; 12641da177e4SLinus Torvalds 12651da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 12661da177e4SLinus Torvalds 12671da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 12681da177e4SLinus Torvalds return; 12691da177e4SLinus Torvalds 12701da177e4SLinus Torvalds /* Start Inquiry */ 12711da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 12721da177e4SLinus Torvalds cp.length = ir->length; 12731da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 127442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 12751da177e4SLinus Torvalds } 12761da177e4SLinus Torvalds 12771da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 12781da177e4SLinus Torvalds { 12791da177e4SLinus Torvalds __u8 __user *ptr = arg; 12801da177e4SLinus Torvalds struct hci_inquiry_req ir; 12811da177e4SLinus Torvalds struct hci_dev *hdev; 12821da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 12831da177e4SLinus Torvalds long timeo; 12841da177e4SLinus Torvalds __u8 *buf; 12851da177e4SLinus Torvalds 12861da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 12871da177e4SLinus Torvalds return -EFAULT; 12881da177e4SLinus Torvalds 12895a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 12905a08ecceSAndrei Emeltchenko if (!hdev) 12911da177e4SLinus Torvalds return -ENODEV; 12921da177e4SLinus Torvalds 12930736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 12940736cfa8SMarcel Holtmann err = -EBUSY; 12950736cfa8SMarcel Holtmann goto done; 12960736cfa8SMarcel Holtmann } 12970736cfa8SMarcel Holtmann 12984a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 1299fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1300fee746b0SMarcel Holtmann goto done; 1301fee746b0SMarcel Holtmann } 1302fee746b0SMarcel Holtmann 13035b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 13045b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 13055b69bef5SMarcel Holtmann goto done; 13065b69bef5SMarcel Holtmann } 13075b69bef5SMarcel Holtmann 130856f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 130956f87901SJohan Hedberg err = -EOPNOTSUPP; 131056f87901SJohan Hedberg goto done; 131156f87901SJohan Hedberg } 131256f87901SJohan Hedberg 131309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13141da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1315a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 13161f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 13171da177e4SLinus Torvalds do_inquiry = 1; 13181da177e4SLinus Torvalds } 131909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13201da177e4SLinus Torvalds 132104837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 132270f23020SAndrei Emeltchenko 132370f23020SAndrei Emeltchenko if (do_inquiry) { 132401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 132501178cd4SJohan Hedberg timeo); 132670f23020SAndrei Emeltchenko if (err < 0) 13271da177e4SLinus Torvalds goto done; 13283e13fa1eSAndre Guedes 13293e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 13303e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 13313e13fa1eSAndre Guedes */ 133274316201SNeilBrown if (wait_on_bit(&hdev->flags, HCI_INQUIRY, 13333e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 13343e13fa1eSAndre Guedes return -EINTR; 133570f23020SAndrei Emeltchenko } 13361da177e4SLinus Torvalds 13378fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 13388fc9ced3SGustavo Padovan * 255 entries 13398fc9ced3SGustavo Padovan */ 13401da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 13411da177e4SLinus Torvalds 13421da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 13431da177e4SLinus Torvalds * copy it to the user space. 13441da177e4SLinus Torvalds */ 134570f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 134670f23020SAndrei Emeltchenko if (!buf) { 13471da177e4SLinus Torvalds err = -ENOMEM; 13481da177e4SLinus Torvalds goto done; 13491da177e4SLinus Torvalds } 13501da177e4SLinus Torvalds 135109fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13521da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 135309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13541da177e4SLinus Torvalds 13551da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 13561da177e4SLinus Torvalds 13571da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 13581da177e4SLinus Torvalds ptr += sizeof(ir); 13591da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 13601da177e4SLinus Torvalds ir.num_rsp)) 13611da177e4SLinus Torvalds err = -EFAULT; 13621da177e4SLinus Torvalds } else 13631da177e4SLinus Torvalds err = -EFAULT; 13641da177e4SLinus Torvalds 13651da177e4SLinus Torvalds kfree(buf); 13661da177e4SLinus Torvalds 13671da177e4SLinus Torvalds done: 13681da177e4SLinus Torvalds hci_dev_put(hdev); 13691da177e4SLinus Torvalds return err; 13701da177e4SLinus Torvalds } 13711da177e4SLinus Torvalds 1372cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 13731da177e4SLinus Torvalds { 13741da177e4SLinus Torvalds int ret = 0; 13751da177e4SLinus Torvalds 13761da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 13771da177e4SLinus Torvalds 13781da177e4SLinus Torvalds hci_req_lock(hdev); 13791da177e4SLinus Torvalds 138094324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 138194324962SJohan Hovold ret = -ENODEV; 138294324962SJohan Hovold goto done; 138394324962SJohan Hovold } 138494324962SJohan Hovold 1385d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 1386d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 1387a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1388a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1389bf543036SJohan Hedberg */ 1390a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 1391611b30f7SMarcel Holtmann ret = -ERFKILL; 1392611b30f7SMarcel Holtmann goto done; 1393611b30f7SMarcel Holtmann } 1394611b30f7SMarcel Holtmann 1395a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1396a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1397a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1398a5c8f270SMarcel Holtmann * or not. 1399a5c8f270SMarcel Holtmann * 1400c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 1401c6beca0eSMarcel Holtmann * if a public address or static random address is 1402c6beca0eSMarcel Holtmann * available. 1403c6beca0eSMarcel Holtmann * 1404a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1405a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1406a5c8f270SMarcel Holtmann */ 1407c6beca0eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 1408c6beca0eSMarcel Holtmann hdev->dev_type == HCI_BREDR && 1409a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1410a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1411a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1412a5c8f270SMarcel Holtmann goto done; 1413a5c8f270SMarcel Holtmann } 1414a5c8f270SMarcel Holtmann } 1415a5c8f270SMarcel Holtmann 14161da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 14171da177e4SLinus Torvalds ret = -EALREADY; 14181da177e4SLinus Torvalds goto done; 14191da177e4SLinus Torvalds } 14201da177e4SLinus Torvalds 14211da177e4SLinus Torvalds if (hdev->open(hdev)) { 14221da177e4SLinus Torvalds ret = -EIO; 14231da177e4SLinus Torvalds goto done; 14241da177e4SLinus Torvalds } 14251da177e4SLinus Torvalds 14261da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 14271da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1428f41c70c4SMarcel Holtmann 1429af202f84SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 1430af202f84SMarcel Holtmann if (hdev->setup) 1431f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1432f41c70c4SMarcel Holtmann 1433af202f84SMarcel Holtmann /* The transport driver can set these quirks before 1434af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 1435af202f84SMarcel Holtmann * 1436af202f84SMarcel Holtmann * In case any of them is set, the controller has to 1437af202f84SMarcel Holtmann * start up as unconfigured. 1438af202f84SMarcel Holtmann */ 1439eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 1440eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 144189bc22d2SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 1442f41c70c4SMarcel Holtmann 14430ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 14440ebca7d6SMarcel Holtmann * read at least the version information provided by 14450ebca7d6SMarcel Holtmann * the Read Local Version Information command. 14460ebca7d6SMarcel Holtmann * 14470ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 14480ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 14490ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 14500ebca7d6SMarcel Holtmann */ 14510ebca7d6SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 14520ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 145389bc22d2SMarcel Holtmann } 145489bc22d2SMarcel Holtmann 14559713c17bSMarcel Holtmann if (test_bit(HCI_CONFIG, &hdev->dev_flags)) { 14569713c17bSMarcel Holtmann /* If public address change is configured, ensure that 14579713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 14589713c17bSMarcel Holtmann * support changing the public address, fail the power 14599713c17bSMarcel Holtmann * on procedure. 146024c457e2SMarcel Holtmann */ 14619713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 14629713c17bSMarcel Holtmann hdev->set_bdaddr) 146324c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 146424c457e2SMarcel Holtmann else 146524c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 146624c457e2SMarcel Holtmann } 146724c457e2SMarcel Holtmann 1468f41c70c4SMarcel Holtmann if (!ret) { 14694a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 14700736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 14712177bab5SJohan Hedberg ret = __hci_init(hdev); 14721da177e4SLinus Torvalds } 14731da177e4SLinus Torvalds 1474f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1475f41c70c4SMarcel Holtmann 14761da177e4SLinus Torvalds if (!ret) { 14771da177e4SLinus Torvalds hci_dev_hold(hdev); 1478d6bfd59cSJohan Hedberg set_bit(HCI_RPA_EXPIRED, &hdev->dev_flags); 14791da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 14801da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 1481bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 1482d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags) && 14834a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 14840736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 14851514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 148609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1487744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 148809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 148956e5cb86SJohan Hedberg } 14901da177e4SLinus Torvalds } else { 14911da177e4SLinus Torvalds /* Init failed, cleanup */ 14923eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1493c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1494b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 14951da177e4SLinus Torvalds 14961da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 14971da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 14981da177e4SLinus Torvalds 14991da177e4SLinus Torvalds if (hdev->flush) 15001da177e4SLinus Torvalds hdev->flush(hdev); 15011da177e4SLinus Torvalds 15021da177e4SLinus Torvalds if (hdev->sent_cmd) { 15031da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 15041da177e4SLinus Torvalds hdev->sent_cmd = NULL; 15051da177e4SLinus Torvalds } 15061da177e4SLinus Torvalds 15071da177e4SLinus Torvalds hdev->close(hdev); 1508fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 15091da177e4SLinus Torvalds } 15101da177e4SLinus Torvalds 15111da177e4SLinus Torvalds done: 15121da177e4SLinus Torvalds hci_req_unlock(hdev); 15131da177e4SLinus Torvalds return ret; 15141da177e4SLinus Torvalds } 15151da177e4SLinus Torvalds 1516cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1517cbed0ca1SJohan Hedberg 1518cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1519cbed0ca1SJohan Hedberg { 1520cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1521cbed0ca1SJohan Hedberg int err; 1522cbed0ca1SJohan Hedberg 1523cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1524cbed0ca1SJohan Hedberg if (!hdev) 1525cbed0ca1SJohan Hedberg return -ENODEV; 1526cbed0ca1SJohan Hedberg 15274a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 1528fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 1529fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 1530fee746b0SMarcel Holtmann * possible. 1531fee746b0SMarcel Holtmann * 1532fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 1533fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 1534fee746b0SMarcel Holtmann * open the device. 1535fee746b0SMarcel Holtmann */ 15364a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 1537fee746b0SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 1538fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1539fee746b0SMarcel Holtmann goto done; 1540fee746b0SMarcel Holtmann } 1541fee746b0SMarcel Holtmann 1542e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1543e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1544e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1545e1d08f40SJohan Hedberg * completed. 1546e1d08f40SJohan Hedberg */ 1547e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 1548e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1549e1d08f40SJohan Hedberg 1550a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1551a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1552a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1553a5c8f270SMarcel Holtmann */ 1554e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1555e1d08f40SJohan Hedberg 155612aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 1557b6ae8457SJohan Hedberg * are brought up using legacy ioctl, set the HCI_BONDABLE bit 155812aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 155912aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 156012aa4f0aSMarcel Holtmann * to explicitly enable it. 156112aa4f0aSMarcel Holtmann */ 156212aa4f0aSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 156312aa4f0aSMarcel Holtmann !test_bit(HCI_MGMT, &hdev->dev_flags)) 1564b6ae8457SJohan Hedberg set_bit(HCI_BONDABLE, &hdev->dev_flags); 156512aa4f0aSMarcel Holtmann 1566cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1567cbed0ca1SJohan Hedberg 1568fee746b0SMarcel Holtmann done: 1569cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1570cbed0ca1SJohan Hedberg return err; 1571cbed0ca1SJohan Hedberg } 1572cbed0ca1SJohan Hedberg 1573d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 1574d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 1575d7347f3cSJohan Hedberg { 1576d7347f3cSJohan Hedberg struct hci_conn_params *p; 1577d7347f3cSJohan Hedberg 1578f161dd41SJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) { 1579f161dd41SJohan Hedberg if (p->conn) { 1580f161dd41SJohan Hedberg hci_conn_drop(p->conn); 1581f8aaf9b6SJohan Hedberg hci_conn_put(p->conn); 1582f161dd41SJohan Hedberg p->conn = NULL; 1583f161dd41SJohan Hedberg } 1584d7347f3cSJohan Hedberg list_del_init(&p->action); 1585f161dd41SJohan Hedberg } 1586d7347f3cSJohan Hedberg 1587d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 1588d7347f3cSJohan Hedberg } 1589d7347f3cSJohan Hedberg 15901da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 15911da177e4SLinus Torvalds { 15921da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 15931da177e4SLinus Torvalds 1594a44fecbdSTedd Ho-Jeong An if (!test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 1595a44fecbdSTedd Ho-Jeong An /* Execute vendor specific shutdown routine */ 1596a44fecbdSTedd Ho-Jeong An if (hdev->shutdown) 1597a44fecbdSTedd Ho-Jeong An hdev->shutdown(hdev); 1598a44fecbdSTedd Ho-Jeong An } 1599a44fecbdSTedd Ho-Jeong An 160078c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 160178c04c0bSVinicius Costa Gomes 16021da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 16031da177e4SLinus Torvalds hci_req_lock(hdev); 16041da177e4SLinus Torvalds 16051da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 160665cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 16071da177e4SLinus Torvalds hci_req_unlock(hdev); 16081da177e4SLinus Torvalds return 0; 16091da177e4SLinus Torvalds } 16101da177e4SLinus Torvalds 16113eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 16123eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1613b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 16141da177e4SLinus Torvalds 161516ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 1616e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 161716ab91abSJohan Hedberg hdev->discov_timeout = 0; 16185e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 1619310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 162016ab91abSJohan Hedberg } 162116ab91abSJohan Hedberg 1622a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 16237d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 16247d78525dSJohan Hedberg 16257ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 16262d28cfe7SJakub Pawlowski cancel_delayed_work_sync(&hdev->le_scan_restart); 16274518bb0fSJohan Hedberg 16284518bb0fSJohan Hedberg if (test_bit(HCI_MGMT, &hdev->dev_flags)) 1629d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 16307ba8b4beSAndre Guedes 163176727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 163276727c02SJohan Hedberg * ensuring the workqueue is empty up front. 163376727c02SJohan Hedberg */ 163476727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 163576727c02SJohan Hedberg 163609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 16371aeb9c65SJohan Hedberg 16388f502f84SJohan Hedberg hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 16398f502f84SJohan Hedberg 16401aeb9c65SJohan Hedberg if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 16411aeb9c65SJohan Hedberg if (hdev->dev_type == HCI_BREDR) 16421aeb9c65SJohan Hedberg mgmt_powered(hdev, 0); 16431aeb9c65SJohan Hedberg } 16441aeb9c65SJohan Hedberg 16451f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 1646d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 1647f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 164809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 16491da177e4SLinus Torvalds 165064dae967SMarcel Holtmann smp_unregister(hdev); 165164dae967SMarcel Holtmann 16521da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 16531da177e4SLinus Torvalds 16541da177e4SLinus Torvalds if (hdev->flush) 16551da177e4SLinus Torvalds hdev->flush(hdev); 16561da177e4SLinus Torvalds 16571da177e4SLinus Torvalds /* Reset device */ 16581da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16591da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 16604a964404SMarcel Holtmann if (!test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 16614a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 1662a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 16631da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 166401178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 16651da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 16661da177e4SLinus Torvalds } 16671da177e4SLinus Torvalds 1668c347b765SGustavo F. Padovan /* flush cmd work */ 1669c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 16701da177e4SLinus Torvalds 16711da177e4SLinus Torvalds /* Drop queues */ 16721da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 16731da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16741da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 16751da177e4SLinus Torvalds 16761da177e4SLinus Torvalds /* Drop last sent command */ 16771da177e4SLinus Torvalds if (hdev->sent_cmd) { 167865cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 16791da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 16801da177e4SLinus Torvalds hdev->sent_cmd = NULL; 16811da177e4SLinus Torvalds } 16821da177e4SLinus Torvalds 1683b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 1684b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 1685b6ddb638SJohan Hedberg 16861da177e4SLinus Torvalds /* After this point our queues are empty 16871da177e4SLinus Torvalds * and no tasks are scheduled. */ 16881da177e4SLinus Torvalds hdev->close(hdev); 16891da177e4SLinus Torvalds 169035b973c9SJohan Hedberg /* Clear flags */ 1691fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 169235b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 169335b973c9SJohan Hedberg 1694ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1695536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1696ced5c338SAndrei Emeltchenko 1697e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 169809b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 16997a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 1700e59fda8dSJohan Hedberg 17011da177e4SLinus Torvalds hci_req_unlock(hdev); 17021da177e4SLinus Torvalds 17031da177e4SLinus Torvalds hci_dev_put(hdev); 17041da177e4SLinus Torvalds return 0; 17051da177e4SLinus Torvalds } 17061da177e4SLinus Torvalds 17071da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 17081da177e4SLinus Torvalds { 17091da177e4SLinus Torvalds struct hci_dev *hdev; 17101da177e4SLinus Torvalds int err; 17111da177e4SLinus Torvalds 171270f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 171370f23020SAndrei Emeltchenko if (!hdev) 17141da177e4SLinus Torvalds return -ENODEV; 17158ee56540SMarcel Holtmann 17160736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 17170736cfa8SMarcel Holtmann err = -EBUSY; 17180736cfa8SMarcel Holtmann goto done; 17190736cfa8SMarcel Holtmann } 17200736cfa8SMarcel Holtmann 17218ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 17228ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 17238ee56540SMarcel Holtmann 17241da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 17258ee56540SMarcel Holtmann 17260736cfa8SMarcel Holtmann done: 17271da177e4SLinus Torvalds hci_dev_put(hdev); 17281da177e4SLinus Torvalds return err; 17291da177e4SLinus Torvalds } 17301da177e4SLinus Torvalds 17315c912495SMarcel Holtmann static int hci_dev_do_reset(struct hci_dev *hdev) 17321da177e4SLinus Torvalds { 17335c912495SMarcel Holtmann int ret; 17341da177e4SLinus Torvalds 17355c912495SMarcel Holtmann BT_DBG("%s %p", hdev->name, hdev); 17361da177e4SLinus Torvalds 17371da177e4SLinus Torvalds hci_req_lock(hdev); 17381da177e4SLinus Torvalds 17391da177e4SLinus Torvalds /* Drop queues */ 17401da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 17411da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17421da177e4SLinus Torvalds 174376727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 174476727c02SJohan Hedberg * ensuring the workqueue is empty up front. 174576727c02SJohan Hedberg */ 174676727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 174776727c02SJohan Hedberg 174809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17491f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 17501da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 175109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17521da177e4SLinus Torvalds 17531da177e4SLinus Torvalds if (hdev->flush) 17541da177e4SLinus Torvalds hdev->flush(hdev); 17551da177e4SLinus Torvalds 17561da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 17576ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 17581da177e4SLinus Torvalds 175901178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 17601da177e4SLinus Torvalds 17611da177e4SLinus Torvalds hci_req_unlock(hdev); 17621da177e4SLinus Torvalds return ret; 17631da177e4SLinus Torvalds } 17641da177e4SLinus Torvalds 17655c912495SMarcel Holtmann int hci_dev_reset(__u16 dev) 17665c912495SMarcel Holtmann { 17675c912495SMarcel Holtmann struct hci_dev *hdev; 17685c912495SMarcel Holtmann int err; 17695c912495SMarcel Holtmann 17705c912495SMarcel Holtmann hdev = hci_dev_get(dev); 17715c912495SMarcel Holtmann if (!hdev) 17725c912495SMarcel Holtmann return -ENODEV; 17735c912495SMarcel Holtmann 17745c912495SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 17755c912495SMarcel Holtmann err = -ENETDOWN; 17765c912495SMarcel Holtmann goto done; 17775c912495SMarcel Holtmann } 17785c912495SMarcel Holtmann 17795c912495SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 17805c912495SMarcel Holtmann err = -EBUSY; 17815c912495SMarcel Holtmann goto done; 17825c912495SMarcel Holtmann } 17835c912495SMarcel Holtmann 17845c912495SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 17855c912495SMarcel Holtmann err = -EOPNOTSUPP; 17865c912495SMarcel Holtmann goto done; 17875c912495SMarcel Holtmann } 17885c912495SMarcel Holtmann 17895c912495SMarcel Holtmann err = hci_dev_do_reset(hdev); 17905c912495SMarcel Holtmann 17915c912495SMarcel Holtmann done: 17925c912495SMarcel Holtmann hci_dev_put(hdev); 17935c912495SMarcel Holtmann return err; 17945c912495SMarcel Holtmann } 17955c912495SMarcel Holtmann 17961da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 17971da177e4SLinus Torvalds { 17981da177e4SLinus Torvalds struct hci_dev *hdev; 17991da177e4SLinus Torvalds int ret = 0; 18001da177e4SLinus Torvalds 180170f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 180270f23020SAndrei Emeltchenko if (!hdev) 18031da177e4SLinus Torvalds return -ENODEV; 18041da177e4SLinus Torvalds 18050736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 18060736cfa8SMarcel Holtmann ret = -EBUSY; 18070736cfa8SMarcel Holtmann goto done; 18080736cfa8SMarcel Holtmann } 18090736cfa8SMarcel Holtmann 18104a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 1811fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 1812fee746b0SMarcel Holtmann goto done; 1813fee746b0SMarcel Holtmann } 1814fee746b0SMarcel Holtmann 18151da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 18161da177e4SLinus Torvalds 18170736cfa8SMarcel Holtmann done: 18181da177e4SLinus Torvalds hci_dev_put(hdev); 18191da177e4SLinus Torvalds return ret; 18201da177e4SLinus Torvalds } 18211da177e4SLinus Torvalds 1822123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 1823123abc08SJohan Hedberg { 1824bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 1825123abc08SJohan Hedberg 1826123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 1827123abc08SJohan Hedberg 1828123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 1829123abc08SJohan Hedberg conn_changed = !test_and_set_bit(HCI_CONNECTABLE, 1830123abc08SJohan Hedberg &hdev->dev_flags); 1831123abc08SJohan Hedberg else 1832123abc08SJohan Hedberg conn_changed = test_and_clear_bit(HCI_CONNECTABLE, 1833123abc08SJohan Hedberg &hdev->dev_flags); 1834123abc08SJohan Hedberg 1835bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 1836bc6d2d04SJohan Hedberg discov_changed = !test_and_set_bit(HCI_DISCOVERABLE, 1837bc6d2d04SJohan Hedberg &hdev->dev_flags); 1838bc6d2d04SJohan Hedberg } else { 1839bc6d2d04SJohan Hedberg clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 1840bc6d2d04SJohan Hedberg discov_changed = test_and_clear_bit(HCI_DISCOVERABLE, 1841bc6d2d04SJohan Hedberg &hdev->dev_flags); 1842bc6d2d04SJohan Hedberg } 1843bc6d2d04SJohan Hedberg 1844123abc08SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 1845123abc08SJohan Hedberg return; 1846123abc08SJohan Hedberg 1847bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 1848bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 1849bc6d2d04SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 1850bc6d2d04SJohan Hedberg 1851bc6d2d04SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 1852bc6d2d04SJohan Hedberg mgmt_update_adv_data(hdev); 1853bc6d2d04SJohan Hedberg 1854123abc08SJohan Hedberg mgmt_new_settings(hdev); 1855123abc08SJohan Hedberg } 1856bc6d2d04SJohan Hedberg } 1857123abc08SJohan Hedberg 18581da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 18591da177e4SLinus Torvalds { 18601da177e4SLinus Torvalds struct hci_dev *hdev; 18611da177e4SLinus Torvalds struct hci_dev_req dr; 18621da177e4SLinus Torvalds int err = 0; 18631da177e4SLinus Torvalds 18641da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 18651da177e4SLinus Torvalds return -EFAULT; 18661da177e4SLinus Torvalds 186770f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 186870f23020SAndrei Emeltchenko if (!hdev) 18691da177e4SLinus Torvalds return -ENODEV; 18701da177e4SLinus Torvalds 18710736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 18720736cfa8SMarcel Holtmann err = -EBUSY; 18730736cfa8SMarcel Holtmann goto done; 18740736cfa8SMarcel Holtmann } 18750736cfa8SMarcel Holtmann 18764a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 1877fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1878fee746b0SMarcel Holtmann goto done; 1879fee746b0SMarcel Holtmann } 1880fee746b0SMarcel Holtmann 18815b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 18825b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 18835b69bef5SMarcel Holtmann goto done; 18845b69bef5SMarcel Holtmann } 18855b69bef5SMarcel Holtmann 188656f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 188756f87901SJohan Hedberg err = -EOPNOTSUPP; 188856f87901SJohan Hedberg goto done; 188956f87901SJohan Hedberg } 189056f87901SJohan Hedberg 18911da177e4SLinus Torvalds switch (cmd) { 18921da177e4SLinus Torvalds case HCISETAUTH: 189301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 18945f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 18951da177e4SLinus Torvalds break; 18961da177e4SLinus Torvalds 18971da177e4SLinus Torvalds case HCISETENCRYPT: 18981da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 18991da177e4SLinus Torvalds err = -EOPNOTSUPP; 19001da177e4SLinus Torvalds break; 19011da177e4SLinus Torvalds } 19021da177e4SLinus Torvalds 19031da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 19041da177e4SLinus Torvalds /* Auth must be enabled first */ 190501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19065f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19071da177e4SLinus Torvalds if (err) 19081da177e4SLinus Torvalds break; 19091da177e4SLinus Torvalds } 19101da177e4SLinus Torvalds 191101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 19125f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19131da177e4SLinus Torvalds break; 19141da177e4SLinus Torvalds 19151da177e4SLinus Torvalds case HCISETSCAN: 191601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 19175f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 191891a668b0SJohan Hedberg 1919bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 1920bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 192191a668b0SJohan Hedberg */ 1922123abc08SJohan Hedberg if (!err) 1923123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 19241da177e4SLinus Torvalds break; 19251da177e4SLinus Torvalds 19261da177e4SLinus Torvalds case HCISETLINKPOL: 192701178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 19285f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19291da177e4SLinus Torvalds break; 19301da177e4SLinus Torvalds 19311da177e4SLinus Torvalds case HCISETLINKMODE: 1932e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 1933e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 1934e4e8e37cSMarcel Holtmann break; 1935e4e8e37cSMarcel Holtmann 1936e4e8e37cSMarcel Holtmann case HCISETPTYPE: 1937e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 19381da177e4SLinus Torvalds break; 19391da177e4SLinus Torvalds 19401da177e4SLinus Torvalds case HCISETACLMTU: 19411da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 19421da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 19431da177e4SLinus Torvalds break; 19441da177e4SLinus Torvalds 19451da177e4SLinus Torvalds case HCISETSCOMTU: 19461da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 19471da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 19481da177e4SLinus Torvalds break; 19491da177e4SLinus Torvalds 19501da177e4SLinus Torvalds default: 19511da177e4SLinus Torvalds err = -EINVAL; 19521da177e4SLinus Torvalds break; 19531da177e4SLinus Torvalds } 1954e4e8e37cSMarcel Holtmann 19550736cfa8SMarcel Holtmann done: 19561da177e4SLinus Torvalds hci_dev_put(hdev); 19571da177e4SLinus Torvalds return err; 19581da177e4SLinus Torvalds } 19591da177e4SLinus Torvalds 19601da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 19611da177e4SLinus Torvalds { 19628035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 19631da177e4SLinus Torvalds struct hci_dev_list_req *dl; 19641da177e4SLinus Torvalds struct hci_dev_req *dr; 19651da177e4SLinus Torvalds int n = 0, size, err; 19661da177e4SLinus Torvalds __u16 dev_num; 19671da177e4SLinus Torvalds 19681da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 19691da177e4SLinus Torvalds return -EFAULT; 19701da177e4SLinus Torvalds 19711da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 19721da177e4SLinus Torvalds return -EINVAL; 19731da177e4SLinus Torvalds 19741da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 19751da177e4SLinus Torvalds 197670f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 197770f23020SAndrei Emeltchenko if (!dl) 19781da177e4SLinus Torvalds return -ENOMEM; 19791da177e4SLinus Torvalds 19801da177e4SLinus Torvalds dr = dl->dev_req; 19811da177e4SLinus Torvalds 1982f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 19838035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 19842e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 1985c542a06cSJohan Hedberg 19862e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 19872e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 19882e84d8dbSMarcel Holtmann * device is actually down. 19892e84d8dbSMarcel Holtmann */ 19902e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 19912e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 1992c542a06cSJohan Hedberg 19931da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 19942e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 1995c542a06cSJohan Hedberg 19961da177e4SLinus Torvalds if (++n >= dev_num) 19971da177e4SLinus Torvalds break; 19981da177e4SLinus Torvalds } 1999f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 20001da177e4SLinus Torvalds 20011da177e4SLinus Torvalds dl->dev_num = n; 20021da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 20031da177e4SLinus Torvalds 20041da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 20051da177e4SLinus Torvalds kfree(dl); 20061da177e4SLinus Torvalds 20071da177e4SLinus Torvalds return err ? -EFAULT : 0; 20081da177e4SLinus Torvalds } 20091da177e4SLinus Torvalds 20101da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 20111da177e4SLinus Torvalds { 20121da177e4SLinus Torvalds struct hci_dev *hdev; 20131da177e4SLinus Torvalds struct hci_dev_info di; 20142e84d8dbSMarcel Holtmann unsigned long flags; 20151da177e4SLinus Torvalds int err = 0; 20161da177e4SLinus Torvalds 20171da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 20181da177e4SLinus Torvalds return -EFAULT; 20191da177e4SLinus Torvalds 202070f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 202170f23020SAndrei Emeltchenko if (!hdev) 20221da177e4SLinus Torvalds return -ENODEV; 20231da177e4SLinus Torvalds 20242e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 20252e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 20262e84d8dbSMarcel Holtmann * device is actually down. 20272e84d8dbSMarcel Holtmann */ 20282e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 20292e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 20302e84d8dbSMarcel Holtmann else 20312e84d8dbSMarcel Holtmann flags = hdev->flags; 2032c542a06cSJohan Hedberg 20331da177e4SLinus Torvalds strcpy(di.name, hdev->name); 20341da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 203560f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 20362e84d8dbSMarcel Holtmann di.flags = flags; 20371da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2038572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 20391da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 20401da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 20411da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 20421da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2043572c7f84SJohan Hedberg } else { 2044572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2045572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2046572c7f84SJohan Hedberg di.sco_mtu = 0; 2047572c7f84SJohan Hedberg di.sco_pkts = 0; 2048572c7f84SJohan Hedberg } 20491da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 20501da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 20511da177e4SLinus Torvalds 20521da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 20531da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 20541da177e4SLinus Torvalds 20551da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 20561da177e4SLinus Torvalds err = -EFAULT; 20571da177e4SLinus Torvalds 20581da177e4SLinus Torvalds hci_dev_put(hdev); 20591da177e4SLinus Torvalds 20601da177e4SLinus Torvalds return err; 20611da177e4SLinus Torvalds } 20621da177e4SLinus Torvalds 20631da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 20641da177e4SLinus Torvalds 2065611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2066611b30f7SMarcel Holtmann { 2067611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2068611b30f7SMarcel Holtmann 2069611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2070611b30f7SMarcel Holtmann 20710736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 20720736cfa8SMarcel Holtmann return -EBUSY; 20730736cfa8SMarcel Holtmann 20745e130367SJohan Hedberg if (blocked) { 20755e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 2076d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2077d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) 2078611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 20795e130367SJohan Hedberg } else { 20805e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 20815e130367SJohan Hedberg } 2082611b30f7SMarcel Holtmann 2083611b30f7SMarcel Holtmann return 0; 2084611b30f7SMarcel Holtmann } 2085611b30f7SMarcel Holtmann 2086611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2087611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2088611b30f7SMarcel Holtmann }; 2089611b30f7SMarcel Holtmann 2090ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2091ab81cbf9SJohan Hedberg { 2092ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 209396570ffcSJohan Hedberg int err; 2094ab81cbf9SJohan Hedberg 2095ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2096ab81cbf9SJohan Hedberg 2097cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 209896570ffcSJohan Hedberg if (err < 0) { 20993ad67582SJaganath Kanakkassery hci_dev_lock(hdev); 210096570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 21013ad67582SJaganath Kanakkassery hci_dev_unlock(hdev); 2102ab81cbf9SJohan Hedberg return; 210396570ffcSJohan Hedberg } 2104ab81cbf9SJohan Hedberg 2105a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2106a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2107a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2108a5c8f270SMarcel Holtmann */ 2109a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 21104a964404SMarcel Holtmann test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) || 2111a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 2112a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2113a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2114bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2115bf543036SJohan Hedberg hci_dev_do_close(hdev); 2116bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 211719202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 211819202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2119bf543036SJohan Hedberg } 2120ab81cbf9SJohan Hedberg 2121fee746b0SMarcel Holtmann if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) { 21224a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 21234a964404SMarcel Holtmann * so that userspace can easily identify them. 21244a964404SMarcel Holtmann */ 21254a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 21264a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 21270602a8adSMarcel Holtmann 21280602a8adSMarcel Holtmann /* For fully configured devices, this will send 21290602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 21300602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 21310602a8adSMarcel Holtmann * 21320602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 21330602a8adSMarcel Holtmann * and no event will be send. 21340602a8adSMarcel Holtmann */ 2135744cf19eSJohan Hedberg mgmt_index_added(hdev); 2136d603b76bSMarcel Holtmann } else if (test_and_clear_bit(HCI_CONFIG, &hdev->dev_flags)) { 21375ea234d3SMarcel Holtmann /* When the controller is now configured, then it 21385ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 21395ea234d3SMarcel Holtmann */ 21405ea234d3SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 21415ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 21425ea234d3SMarcel Holtmann 2143d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2144d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 2145d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 2146d603b76bSMarcel Holtmann */ 2147d603b76bSMarcel Holtmann mgmt_index_added(hdev); 2148ab81cbf9SJohan Hedberg } 2149ab81cbf9SJohan Hedberg } 2150ab81cbf9SJohan Hedberg 2151ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2152ab81cbf9SJohan Hedberg { 21533243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 21543243553fSJohan Hedberg power_off.work); 2155ab81cbf9SJohan Hedberg 2156ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2157ab81cbf9SJohan Hedberg 21588ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2159ab81cbf9SJohan Hedberg } 2160ab81cbf9SJohan Hedberg 2161c7741d16SMarcel Holtmann static void hci_error_reset(struct work_struct *work) 2162c7741d16SMarcel Holtmann { 2163c7741d16SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, error_reset); 2164c7741d16SMarcel Holtmann 2165c7741d16SMarcel Holtmann BT_DBG("%s", hdev->name); 2166c7741d16SMarcel Holtmann 2167c7741d16SMarcel Holtmann if (hdev->hw_error) 2168c7741d16SMarcel Holtmann hdev->hw_error(hdev, hdev->hw_error_code); 2169c7741d16SMarcel Holtmann else 2170c7741d16SMarcel Holtmann BT_ERR("%s hardware error 0x%2.2x", hdev->name, 2171c7741d16SMarcel Holtmann hdev->hw_error_code); 2172c7741d16SMarcel Holtmann 2173c7741d16SMarcel Holtmann if (hci_dev_do_close(hdev)) 2174c7741d16SMarcel Holtmann return; 2175c7741d16SMarcel Holtmann 2176c7741d16SMarcel Holtmann hci_dev_do_open(hdev); 2177c7741d16SMarcel Holtmann } 2178c7741d16SMarcel Holtmann 217916ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 218016ab91abSJohan Hedberg { 218116ab91abSJohan Hedberg struct hci_dev *hdev; 218216ab91abSJohan Hedberg 218316ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 218416ab91abSJohan Hedberg 218516ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 218616ab91abSJohan Hedberg 2187d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 218816ab91abSJohan Hedberg } 218916ab91abSJohan Hedberg 219035f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 21912aeb9a1aSJohan Hedberg { 21924821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 21932aeb9a1aSJohan Hedberg 21944821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 21954821002cSJohan Hedberg list_del(&uuid->list); 21962aeb9a1aSJohan Hedberg kfree(uuid); 21972aeb9a1aSJohan Hedberg } 21982aeb9a1aSJohan Hedberg } 21992aeb9a1aSJohan Hedberg 220035f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 220155ed8ca1SJohan Hedberg { 220255ed8ca1SJohan Hedberg struct link_key *key; 220355ed8ca1SJohan Hedberg 22040378b597SJohan Hedberg list_for_each_entry_rcu(key, &hdev->link_keys, list) { 22050378b597SJohan Hedberg list_del_rcu(&key->list); 22060378b597SJohan Hedberg kfree_rcu(key, rcu); 220755ed8ca1SJohan Hedberg } 220855ed8ca1SJohan Hedberg } 220955ed8ca1SJohan Hedberg 221035f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 2211b899efafSVinicius Costa Gomes { 2212970d0f1bSJohan Hedberg struct smp_ltk *k; 2213b899efafSVinicius Costa Gomes 2214970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2215970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2216970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2217b899efafSVinicius Costa Gomes } 2218b899efafSVinicius Costa Gomes } 2219b899efafSVinicius Costa Gomes 2220970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 2221970c4e46SJohan Hedberg { 2222adae20cbSJohan Hedberg struct smp_irk *k; 2223970c4e46SJohan Hedberg 2224adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2225adae20cbSJohan Hedberg list_del_rcu(&k->list); 2226adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2227970c4e46SJohan Hedberg } 2228970c4e46SJohan Hedberg } 2229970c4e46SJohan Hedberg 223055ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 223155ed8ca1SJohan Hedberg { 223255ed8ca1SJohan Hedberg struct link_key *k; 223355ed8ca1SJohan Hedberg 22340378b597SJohan Hedberg rcu_read_lock(); 22350378b597SJohan Hedberg list_for_each_entry_rcu(k, &hdev->link_keys, list) { 22360378b597SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) { 22370378b597SJohan Hedberg rcu_read_unlock(); 223855ed8ca1SJohan Hedberg return k; 22390378b597SJohan Hedberg } 22400378b597SJohan Hedberg } 22410378b597SJohan Hedberg rcu_read_unlock(); 224255ed8ca1SJohan Hedberg 224355ed8ca1SJohan Hedberg return NULL; 224455ed8ca1SJohan Hedberg } 224555ed8ca1SJohan Hedberg 2246745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2247d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2248d25e28abSJohan Hedberg { 2249d25e28abSJohan Hedberg /* Legacy key */ 2250d25e28abSJohan Hedberg if (key_type < 0x03) 2251745c0ce3SVishal Agarwal return true; 2252d25e28abSJohan Hedberg 2253d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2254d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2255745c0ce3SVishal Agarwal return false; 2256d25e28abSJohan Hedberg 2257d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2258d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2259745c0ce3SVishal Agarwal return false; 2260d25e28abSJohan Hedberg 2261d25e28abSJohan Hedberg /* Security mode 3 case */ 2262d25e28abSJohan Hedberg if (!conn) 2263745c0ce3SVishal Agarwal return true; 2264d25e28abSJohan Hedberg 2265e3befab9SJohan Hedberg /* BR/EDR key derived using SC from an LE link */ 2266e3befab9SJohan Hedberg if (conn->type == LE_LINK) 2267e3befab9SJohan Hedberg return true; 2268e3befab9SJohan Hedberg 2269d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2270d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2271745c0ce3SVishal Agarwal return true; 2272d25e28abSJohan Hedberg 2273d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2274d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2275745c0ce3SVishal Agarwal return true; 2276d25e28abSJohan Hedberg 2277d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2278d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2279745c0ce3SVishal Agarwal return true; 2280d25e28abSJohan Hedberg 2281d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2282d25e28abSJohan Hedberg * persistently */ 2283745c0ce3SVishal Agarwal return false; 2284d25e28abSJohan Hedberg } 2285d25e28abSJohan Hedberg 2286e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 228798a0b845SJohan Hedberg { 2288e804d25dSJohan Hedberg if (type == SMP_LTK) 2289e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 229098a0b845SJohan Hedberg 2291e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 229298a0b845SJohan Hedberg } 229398a0b845SJohan Hedberg 2294f3a73d97SJohan Hedberg struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2295e804d25dSJohan Hedberg u8 addr_type, u8 role) 229675d262c2SVinicius Costa Gomes { 2297c9839a11SVinicius Costa Gomes struct smp_ltk *k; 229875d262c2SVinicius Costa Gomes 2299970d0f1bSJohan Hedberg rcu_read_lock(); 2300970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 23015378bc56SJohan Hedberg if (addr_type != k->bdaddr_type || bacmp(bdaddr, &k->bdaddr)) 23025378bc56SJohan Hedberg continue; 23035378bc56SJohan Hedberg 2304923e2414SJohan Hedberg if (smp_ltk_is_sc(k) || ltk_role(k->type) == role) { 2305970d0f1bSJohan Hedberg rcu_read_unlock(); 230675d262c2SVinicius Costa Gomes return k; 2307970d0f1bSJohan Hedberg } 2308970d0f1bSJohan Hedberg } 2309970d0f1bSJohan Hedberg rcu_read_unlock(); 231075d262c2SVinicius Costa Gomes 231175d262c2SVinicius Costa Gomes return NULL; 231275d262c2SVinicius Costa Gomes } 231375d262c2SVinicius Costa Gomes 2314970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 2315970c4e46SJohan Hedberg { 2316970c4e46SJohan Hedberg struct smp_irk *irk; 2317970c4e46SJohan Hedberg 2318adae20cbSJohan Hedberg rcu_read_lock(); 2319adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2320adae20cbSJohan Hedberg if (!bacmp(&irk->rpa, rpa)) { 2321adae20cbSJohan Hedberg rcu_read_unlock(); 2322970c4e46SJohan Hedberg return irk; 2323970c4e46SJohan Hedberg } 2324adae20cbSJohan Hedberg } 2325970c4e46SJohan Hedberg 2326adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2327defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 2328970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2329adae20cbSJohan Hedberg rcu_read_unlock(); 2330970c4e46SJohan Hedberg return irk; 2331970c4e46SJohan Hedberg } 2332970c4e46SJohan Hedberg } 2333adae20cbSJohan Hedberg rcu_read_unlock(); 2334970c4e46SJohan Hedberg 2335970c4e46SJohan Hedberg return NULL; 2336970c4e46SJohan Hedberg } 2337970c4e46SJohan Hedberg 2338970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2339970c4e46SJohan Hedberg u8 addr_type) 2340970c4e46SJohan Hedberg { 2341970c4e46SJohan Hedberg struct smp_irk *irk; 2342970c4e46SJohan Hedberg 23436cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 23446cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 23456cfc9988SJohan Hedberg return NULL; 23466cfc9988SJohan Hedberg 2347adae20cbSJohan Hedberg rcu_read_lock(); 2348adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2349970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 2350adae20cbSJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) { 2351adae20cbSJohan Hedberg rcu_read_unlock(); 2352970c4e46SJohan Hedberg return irk; 2353970c4e46SJohan Hedberg } 2354adae20cbSJohan Hedberg } 2355adae20cbSJohan Hedberg rcu_read_unlock(); 2356970c4e46SJohan Hedberg 2357970c4e46SJohan Hedberg return NULL; 2358970c4e46SJohan Hedberg } 2359970c4e46SJohan Hedberg 2360567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 23617652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 23627652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 236355ed8ca1SJohan Hedberg { 236455ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2365745c0ce3SVishal Agarwal u8 old_key_type; 236655ed8ca1SJohan Hedberg 236755ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 236855ed8ca1SJohan Hedberg if (old_key) { 236955ed8ca1SJohan Hedberg old_key_type = old_key->type; 237055ed8ca1SJohan Hedberg key = old_key; 237155ed8ca1SJohan Hedberg } else { 237212adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 23730a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 237455ed8ca1SJohan Hedberg if (!key) 2375567fa2aaSJohan Hedberg return NULL; 23760378b597SJohan Hedberg list_add_rcu(&key->list, &hdev->link_keys); 237755ed8ca1SJohan Hedberg } 237855ed8ca1SJohan Hedberg 23796ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 238055ed8ca1SJohan Hedberg 2381d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2382d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2383d25e28abSJohan Hedberg * previous key */ 2384d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2385a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2386d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2387655fe6ecSJohan Hedberg if (conn) 2388655fe6ecSJohan Hedberg conn->key_type = type; 2389655fe6ecSJohan Hedberg } 2390d25e28abSJohan Hedberg 239155ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 23929b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 239355ed8ca1SJohan Hedberg key->pin_len = pin_len; 239455ed8ca1SJohan Hedberg 2395b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 239655ed8ca1SJohan Hedberg key->type = old_key_type; 23974748fed2SJohan Hedberg else 23984748fed2SJohan Hedberg key->type = type; 23994748fed2SJohan Hedberg 24007652ff6aSJohan Hedberg if (persistent) 24017652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 24027652ff6aSJohan Hedberg old_key_type); 24034df378a1SJohan Hedberg 2404567fa2aaSJohan Hedberg return key; 240555ed8ca1SJohan Hedberg } 240655ed8ca1SJohan Hedberg 2407ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 240835d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 2409fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 241075d262c2SVinicius Costa Gomes { 2411c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 2412e804d25dSJohan Hedberg u8 role = ltk_role(type); 241375d262c2SVinicius Costa Gomes 2414f3a73d97SJohan Hedberg old_key = hci_find_ltk(hdev, bdaddr, addr_type, role); 2415c9839a11SVinicius Costa Gomes if (old_key) 241675d262c2SVinicius Costa Gomes key = old_key; 2417c9839a11SVinicius Costa Gomes else { 24180a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 241975d262c2SVinicius Costa Gomes if (!key) 2420ca9142b8SJohan Hedberg return NULL; 2421970d0f1bSJohan Hedberg list_add_rcu(&key->list, &hdev->long_term_keys); 242275d262c2SVinicius Costa Gomes } 242375d262c2SVinicius Costa Gomes 242475d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2425c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2426c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2427c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2428c9839a11SVinicius Costa Gomes key->ediv = ediv; 2429fe39c7b2SMarcel Holtmann key->rand = rand; 2430c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2431c9839a11SVinicius Costa Gomes key->type = type; 243275d262c2SVinicius Costa Gomes 2433ca9142b8SJohan Hedberg return key; 243475d262c2SVinicius Costa Gomes } 243575d262c2SVinicius Costa Gomes 2436ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2437ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 2438970c4e46SJohan Hedberg { 2439970c4e46SJohan Hedberg struct smp_irk *irk; 2440970c4e46SJohan Hedberg 2441970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 2442970c4e46SJohan Hedberg if (!irk) { 2443970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 2444970c4e46SJohan Hedberg if (!irk) 2445ca9142b8SJohan Hedberg return NULL; 2446970c4e46SJohan Hedberg 2447970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 2448970c4e46SJohan Hedberg irk->addr_type = addr_type; 2449970c4e46SJohan Hedberg 2450adae20cbSJohan Hedberg list_add_rcu(&irk->list, &hdev->identity_resolving_keys); 2451970c4e46SJohan Hedberg } 2452970c4e46SJohan Hedberg 2453970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 2454970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2455970c4e46SJohan Hedberg 2456ca9142b8SJohan Hedberg return irk; 2457970c4e46SJohan Hedberg } 2458970c4e46SJohan Hedberg 245955ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 246055ed8ca1SJohan Hedberg { 246155ed8ca1SJohan Hedberg struct link_key *key; 246255ed8ca1SJohan Hedberg 246355ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 246455ed8ca1SJohan Hedberg if (!key) 246555ed8ca1SJohan Hedberg return -ENOENT; 246655ed8ca1SJohan Hedberg 24676ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 246855ed8ca1SJohan Hedberg 24690378b597SJohan Hedberg list_del_rcu(&key->list); 24700378b597SJohan Hedberg kfree_rcu(key, rcu); 247155ed8ca1SJohan Hedberg 247255ed8ca1SJohan Hedberg return 0; 247355ed8ca1SJohan Hedberg } 247455ed8ca1SJohan Hedberg 2475e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 2476b899efafSVinicius Costa Gomes { 2477970d0f1bSJohan Hedberg struct smp_ltk *k; 2478c51ffa0bSJohan Hedberg int removed = 0; 2479b899efafSVinicius Costa Gomes 2480970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2481e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 2482b899efafSVinicius Costa Gomes continue; 2483b899efafSVinicius Costa Gomes 24846ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2485b899efafSVinicius Costa Gomes 2486970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2487970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2488c51ffa0bSJohan Hedberg removed++; 2489b899efafSVinicius Costa Gomes } 2490b899efafSVinicius Costa Gomes 2491c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 2492b899efafSVinicius Costa Gomes } 2493b899efafSVinicius Costa Gomes 2494a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 2495a7ec7338SJohan Hedberg { 2496adae20cbSJohan Hedberg struct smp_irk *k; 2497a7ec7338SJohan Hedberg 2498adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2499a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 2500a7ec7338SJohan Hedberg continue; 2501a7ec7338SJohan Hedberg 2502a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2503a7ec7338SJohan Hedberg 2504adae20cbSJohan Hedberg list_del_rcu(&k->list); 2505adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2506a7ec7338SJohan Hedberg } 2507a7ec7338SJohan Hedberg } 2508a7ec7338SJohan Hedberg 25096bd32326SVille Tervo /* HCI command timer function */ 251065cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 25116bd32326SVille Tervo { 251265cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 251365cc2b49SMarcel Holtmann cmd_timer.work); 25146bd32326SVille Tervo 2515bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2516bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2517bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2518bda4f23aSAndrei Emeltchenko 2519bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 2520bda4f23aSAndrei Emeltchenko } else { 25216bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 2522bda4f23aSAndrei Emeltchenko } 2523bda4f23aSAndrei Emeltchenko 25246bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2525c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 25266bd32326SVille Tervo } 25276bd32326SVille Tervo 25282763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 25296928a924SJohan Hedberg bdaddr_t *bdaddr, u8 bdaddr_type) 25302763eda6SSzymon Janc { 25312763eda6SSzymon Janc struct oob_data *data; 25322763eda6SSzymon Janc 25336928a924SJohan Hedberg list_for_each_entry(data, &hdev->remote_oob_data, list) { 25346928a924SJohan Hedberg if (bacmp(bdaddr, &data->bdaddr) != 0) 25356928a924SJohan Hedberg continue; 25366928a924SJohan Hedberg if (data->bdaddr_type != bdaddr_type) 25376928a924SJohan Hedberg continue; 25382763eda6SSzymon Janc return data; 25396928a924SJohan Hedberg } 25402763eda6SSzymon Janc 25412763eda6SSzymon Janc return NULL; 25422763eda6SSzymon Janc } 25432763eda6SSzymon Janc 25446928a924SJohan Hedberg int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 25456928a924SJohan Hedberg u8 bdaddr_type) 25462763eda6SSzymon Janc { 25472763eda6SSzymon Janc struct oob_data *data; 25482763eda6SSzymon Janc 25496928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 25502763eda6SSzymon Janc if (!data) 25512763eda6SSzymon Janc return -ENOENT; 25522763eda6SSzymon Janc 25536928a924SJohan Hedberg BT_DBG("%s removing %pMR (%u)", hdev->name, bdaddr, bdaddr_type); 25542763eda6SSzymon Janc 25552763eda6SSzymon Janc list_del(&data->list); 25562763eda6SSzymon Janc kfree(data); 25572763eda6SSzymon Janc 25582763eda6SSzymon Janc return 0; 25592763eda6SSzymon Janc } 25602763eda6SSzymon Janc 256135f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 25622763eda6SSzymon Janc { 25632763eda6SSzymon Janc struct oob_data *data, *n; 25642763eda6SSzymon Janc 25652763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 25662763eda6SSzymon Janc list_del(&data->list); 25672763eda6SSzymon Janc kfree(data); 25682763eda6SSzymon Janc } 25692763eda6SSzymon Janc } 25702763eda6SSzymon Janc 25710798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 25726928a924SJohan Hedberg u8 bdaddr_type, u8 *hash192, u8 *rand192, 257338da1703SJohan Hedberg u8 *hash256, u8 *rand256) 25740798872eSMarcel Holtmann { 25750798872eSMarcel Holtmann struct oob_data *data; 25760798872eSMarcel Holtmann 25776928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 25780798872eSMarcel Holtmann if (!data) { 25790a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 25800798872eSMarcel Holtmann if (!data) 25810798872eSMarcel Holtmann return -ENOMEM; 25820798872eSMarcel Holtmann 25830798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 25846928a924SJohan Hedberg data->bdaddr_type = bdaddr_type; 25850798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 25860798872eSMarcel Holtmann } 25870798872eSMarcel Holtmann 258881328d5cSJohan Hedberg if (hash192 && rand192) { 25890798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 259038da1703SJohan Hedberg memcpy(data->rand192, rand192, sizeof(data->rand192)); 2591f7697b16SMarcel Holtmann if (hash256 && rand256) 2592f7697b16SMarcel Holtmann data->present = 0x03; 259381328d5cSJohan Hedberg } else { 259481328d5cSJohan Hedberg memset(data->hash192, 0, sizeof(data->hash192)); 259581328d5cSJohan Hedberg memset(data->rand192, 0, sizeof(data->rand192)); 2596f7697b16SMarcel Holtmann if (hash256 && rand256) 2597f7697b16SMarcel Holtmann data->present = 0x02; 2598f7697b16SMarcel Holtmann else 2599f7697b16SMarcel Holtmann data->present = 0x00; 260081328d5cSJohan Hedberg } 26010798872eSMarcel Holtmann 260281328d5cSJohan Hedberg if (hash256 && rand256) { 26030798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 260438da1703SJohan Hedberg memcpy(data->rand256, rand256, sizeof(data->rand256)); 260581328d5cSJohan Hedberg } else { 260681328d5cSJohan Hedberg memset(data->hash256, 0, sizeof(data->hash256)); 260781328d5cSJohan Hedberg memset(data->rand256, 0, sizeof(data->rand256)); 2608f7697b16SMarcel Holtmann if (hash192 && rand192) 2609f7697b16SMarcel Holtmann data->present = 0x01; 261081328d5cSJohan Hedberg } 26110798872eSMarcel Holtmann 26126ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 26132763eda6SSzymon Janc 26142763eda6SSzymon Janc return 0; 26152763eda6SSzymon Janc } 26162763eda6SSzymon Janc 2617dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 2618b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2619b2a66aadSAntti Julku { 2620b2a66aadSAntti Julku struct bdaddr_list *b; 2621b2a66aadSAntti Julku 2622dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 2623b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2624b2a66aadSAntti Julku return b; 2625b9ee0a78SMarcel Holtmann } 2626b2a66aadSAntti Julku 2627b2a66aadSAntti Julku return NULL; 2628b2a66aadSAntti Julku } 2629b2a66aadSAntti Julku 2630dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 2631b2a66aadSAntti Julku { 2632b2a66aadSAntti Julku struct list_head *p, *n; 2633b2a66aadSAntti Julku 2634dcc36c16SJohan Hedberg list_for_each_safe(p, n, bdaddr_list) { 2635b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 2636b2a66aadSAntti Julku 2637b2a66aadSAntti Julku list_del(p); 2638b2a66aadSAntti Julku kfree(b); 2639b2a66aadSAntti Julku } 2640b2a66aadSAntti Julku } 2641b2a66aadSAntti Julku 2642dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2643b2a66aadSAntti Julku { 2644b2a66aadSAntti Julku struct bdaddr_list *entry; 2645b2a66aadSAntti Julku 2646b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2647b2a66aadSAntti Julku return -EBADF; 2648b2a66aadSAntti Julku 2649dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 26505e762444SAntti Julku return -EEXIST; 2651b2a66aadSAntti Julku 265227f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 26535e762444SAntti Julku if (!entry) 26545e762444SAntti Julku return -ENOMEM; 2655b2a66aadSAntti Julku 2656b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2657b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2658b2a66aadSAntti Julku 2659dcc36c16SJohan Hedberg list_add(&entry->list, list); 2660b2a66aadSAntti Julku 26612a8357f2SJohan Hedberg return 0; 2662b2a66aadSAntti Julku } 2663b2a66aadSAntti Julku 2664dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2665b2a66aadSAntti Julku { 2666b2a66aadSAntti Julku struct bdaddr_list *entry; 2667b2a66aadSAntti Julku 266835f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 2669dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 267035f7498aSJohan Hedberg return 0; 267135f7498aSJohan Hedberg } 2672b2a66aadSAntti Julku 2673dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 2674d2ab0ac1SMarcel Holtmann if (!entry) 2675d2ab0ac1SMarcel Holtmann return -ENOENT; 2676d2ab0ac1SMarcel Holtmann 2677d2ab0ac1SMarcel Holtmann list_del(&entry->list); 2678d2ab0ac1SMarcel Holtmann kfree(entry); 2679d2ab0ac1SMarcel Holtmann 2680d2ab0ac1SMarcel Holtmann return 0; 2681d2ab0ac1SMarcel Holtmann } 2682d2ab0ac1SMarcel Holtmann 268315819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 268415819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 268515819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 268615819a70SAndre Guedes { 268715819a70SAndre Guedes struct hci_conn_params *params; 268815819a70SAndre Guedes 2689738f6185SJohan Hedberg /* The conn params list only contains identity addresses */ 2690738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 2691738f6185SJohan Hedberg return NULL; 2692738f6185SJohan Hedberg 269315819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 269415819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 269515819a70SAndre Guedes params->addr_type == addr_type) { 269615819a70SAndre Guedes return params; 269715819a70SAndre Guedes } 269815819a70SAndre Guedes } 269915819a70SAndre Guedes 270015819a70SAndre Guedes return NULL; 270115819a70SAndre Guedes } 270215819a70SAndre Guedes 270315819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 2704501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 27054b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 270615819a70SAndre Guedes { 2707912b42efSJohan Hedberg struct hci_conn_params *param; 270815819a70SAndre Guedes 2709738f6185SJohan Hedberg /* The list only contains identity addresses */ 2710738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 2711738f6185SJohan Hedberg return NULL; 271215819a70SAndre Guedes 2713501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 2714912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 2715912b42efSJohan Hedberg param->addr_type == addr_type) 2716912b42efSJohan Hedberg return param; 27174b10966fSMarcel Holtmann } 27184b10966fSMarcel Holtmann 27194b10966fSMarcel Holtmann return NULL; 272015819a70SAndre Guedes } 272115819a70SAndre Guedes 272215819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 272351d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 272451d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 272515819a70SAndre Guedes { 272615819a70SAndre Guedes struct hci_conn_params *params; 272715819a70SAndre Guedes 2728c46245b3SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 272951d167c0SMarcel Holtmann return NULL; 2730a9b0a04cSAndre Guedes 273115819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 2732cef952ceSAndre Guedes if (params) 273351d167c0SMarcel Holtmann return params; 273415819a70SAndre Guedes 273515819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 273615819a70SAndre Guedes if (!params) { 273715819a70SAndre Guedes BT_ERR("Out of memory"); 273851d167c0SMarcel Holtmann return NULL; 273915819a70SAndre Guedes } 274015819a70SAndre Guedes 274115819a70SAndre Guedes bacpy(¶ms->addr, addr); 274215819a70SAndre Guedes params->addr_type = addr_type; 2743cef952ceSAndre Guedes 2744cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 274593450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 2746cef952ceSAndre Guedes 2747bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 2748bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 2749bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 2750bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 2751bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 2752bf5b3c8bSMarcel Holtmann 2753bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 2754bf5b3c8bSMarcel Holtmann 275551d167c0SMarcel Holtmann return params; 2756bf5b3c8bSMarcel Holtmann } 2757bf5b3c8bSMarcel Holtmann 2758f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 2759f6c63249SJohan Hedberg { 2760f6c63249SJohan Hedberg if (params->conn) { 2761f6c63249SJohan Hedberg hci_conn_drop(params->conn); 2762f6c63249SJohan Hedberg hci_conn_put(params->conn); 2763f6c63249SJohan Hedberg } 2764f6c63249SJohan Hedberg 2765f6c63249SJohan Hedberg list_del(¶ms->action); 2766f6c63249SJohan Hedberg list_del(¶ms->list); 2767f6c63249SJohan Hedberg kfree(params); 2768f6c63249SJohan Hedberg } 2769f6c63249SJohan Hedberg 277015819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 277115819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 277215819a70SAndre Guedes { 277315819a70SAndre Guedes struct hci_conn_params *params; 277415819a70SAndre Guedes 277515819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 277615819a70SAndre Guedes if (!params) 277715819a70SAndre Guedes return; 277815819a70SAndre Guedes 2779f6c63249SJohan Hedberg hci_conn_params_free(params); 278015819a70SAndre Guedes 278195305baaSJohan Hedberg hci_update_background_scan(hdev); 278295305baaSJohan Hedberg 278315819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 278415819a70SAndre Guedes } 278515819a70SAndre Guedes 278615819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 278755af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 278815819a70SAndre Guedes { 278915819a70SAndre Guedes struct hci_conn_params *params, *tmp; 279015819a70SAndre Guedes 279115819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 279255af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 279355af49a8SJohan Hedberg continue; 279415819a70SAndre Guedes list_del(¶ms->list); 279515819a70SAndre Guedes kfree(params); 279615819a70SAndre Guedes } 279715819a70SAndre Guedes 279855af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 279955af49a8SJohan Hedberg } 280055af49a8SJohan Hedberg 280155af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 2802373110c5SJohan Hedberg void hci_conn_params_clear_all(struct hci_dev *hdev) 280315819a70SAndre Guedes { 280415819a70SAndre Guedes struct hci_conn_params *params, *tmp; 280515819a70SAndre Guedes 2806f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 2807f6c63249SJohan Hedberg hci_conn_params_free(params); 280815819a70SAndre Guedes 2809a2f41a8fSJohan Hedberg hci_update_background_scan(hdev); 28101089b67dSMarcel Holtmann 281115819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 281215819a70SAndre Guedes } 281315819a70SAndre Guedes 28141904a853SMarcel Holtmann static void inquiry_complete(struct hci_dev *hdev, u8 status, u16 opcode) 28157ba8b4beSAndre Guedes { 28164c87eaabSAndre Guedes if (status) { 28174c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 28187ba8b4beSAndre Guedes 28194c87eaabSAndre Guedes hci_dev_lock(hdev); 28204c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 28214c87eaabSAndre Guedes hci_dev_unlock(hdev); 28224c87eaabSAndre Guedes return; 28234c87eaabSAndre Guedes } 28247ba8b4beSAndre Guedes } 28257ba8b4beSAndre Guedes 28261904a853SMarcel Holtmann static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status, 28271904a853SMarcel Holtmann u16 opcode) 28287ba8b4beSAndre Guedes { 28294c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 28304c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 28314c87eaabSAndre Guedes struct hci_request req; 28324c87eaabSAndre Guedes struct hci_cp_inquiry cp; 28337ba8b4beSAndre Guedes int err; 28347ba8b4beSAndre Guedes 28354c87eaabSAndre Guedes if (status) { 28364c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 28374c87eaabSAndre Guedes return; 28387ba8b4beSAndre Guedes } 28397ba8b4beSAndre Guedes 28402d28cfe7SJakub Pawlowski hdev->discovery.scan_start = 0; 28412d28cfe7SJakub Pawlowski 28424c87eaabSAndre Guedes switch (hdev->discovery.type) { 28434c87eaabSAndre Guedes case DISCOV_TYPE_LE: 28444c87eaabSAndre Guedes hci_dev_lock(hdev); 28454c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 28464c87eaabSAndre Guedes hci_dev_unlock(hdev); 28474c87eaabSAndre Guedes break; 28487dbfac1dSAndre Guedes 28494c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 28504c87eaabSAndre Guedes hci_req_init(&req, hdev); 28517dbfac1dSAndre Guedes 28527dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 28534c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 28544c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 28554c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 28564c87eaabSAndre Guedes 28574c87eaabSAndre Guedes hci_dev_lock(hdev); 28584c87eaabSAndre Guedes 28594c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 28604c87eaabSAndre Guedes 28614c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 28624c87eaabSAndre Guedes if (err) { 28634c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 28644c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 28657dbfac1dSAndre Guedes } 28667dbfac1dSAndre Guedes 28674c87eaabSAndre Guedes hci_dev_unlock(hdev); 28684c87eaabSAndre Guedes break; 28694c87eaabSAndre Guedes } 28707dbfac1dSAndre Guedes } 28717dbfac1dSAndre Guedes 28727ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 28737ba8b4beSAndre Guedes { 28747ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 28757ba8b4beSAndre Guedes le_scan_disable.work); 28764c87eaabSAndre Guedes struct hci_request req; 28774c87eaabSAndre Guedes int err; 28787ba8b4beSAndre Guedes 28797ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 28807ba8b4beSAndre Guedes 28812d28cfe7SJakub Pawlowski cancel_delayed_work_sync(&hdev->le_scan_restart); 28822d28cfe7SJakub Pawlowski 28834c87eaabSAndre Guedes hci_req_init(&req, hdev); 28847ba8b4beSAndre Guedes 2885b1efcc28SAndre Guedes hci_req_add_le_scan_disable(&req); 28867ba8b4beSAndre Guedes 28874c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 28884c87eaabSAndre Guedes if (err) 28894c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 289028b75a89SAndre Guedes } 289128b75a89SAndre Guedes 28922d28cfe7SJakub Pawlowski static void le_scan_restart_work_complete(struct hci_dev *hdev, u8 status, 28932d28cfe7SJakub Pawlowski u16 opcode) 28942d28cfe7SJakub Pawlowski { 28952d28cfe7SJakub Pawlowski unsigned long timeout, duration, scan_start, now; 28962d28cfe7SJakub Pawlowski 28972d28cfe7SJakub Pawlowski BT_DBG("%s", hdev->name); 28982d28cfe7SJakub Pawlowski 28992d28cfe7SJakub Pawlowski if (status) { 29002d28cfe7SJakub Pawlowski BT_ERR("Failed to restart LE scan: status %d", status); 29012d28cfe7SJakub Pawlowski return; 29022d28cfe7SJakub Pawlowski } 29032d28cfe7SJakub Pawlowski 29042d28cfe7SJakub Pawlowski if (!test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks) || 29052d28cfe7SJakub Pawlowski !hdev->discovery.scan_start) 29062d28cfe7SJakub Pawlowski return; 29072d28cfe7SJakub Pawlowski 29082d28cfe7SJakub Pawlowski /* When the scan was started, hdev->le_scan_disable has been queued 29092d28cfe7SJakub Pawlowski * after duration from scan_start. During scan restart this job 29102d28cfe7SJakub Pawlowski * has been canceled, and we need to queue it again after proper 29112d28cfe7SJakub Pawlowski * timeout, to make sure that scan does not run indefinitely. 29122d28cfe7SJakub Pawlowski */ 29132d28cfe7SJakub Pawlowski duration = hdev->discovery.scan_duration; 29142d28cfe7SJakub Pawlowski scan_start = hdev->discovery.scan_start; 29152d28cfe7SJakub Pawlowski now = jiffies; 29162d28cfe7SJakub Pawlowski if (now - scan_start <= duration) { 29172d28cfe7SJakub Pawlowski int elapsed; 29182d28cfe7SJakub Pawlowski 29192d28cfe7SJakub Pawlowski if (now >= scan_start) 29202d28cfe7SJakub Pawlowski elapsed = now - scan_start; 29212d28cfe7SJakub Pawlowski else 29222d28cfe7SJakub Pawlowski elapsed = ULONG_MAX - scan_start + now; 29232d28cfe7SJakub Pawlowski 29242d28cfe7SJakub Pawlowski timeout = duration - elapsed; 29252d28cfe7SJakub Pawlowski } else { 29262d28cfe7SJakub Pawlowski timeout = 0; 29272d28cfe7SJakub Pawlowski } 29282d28cfe7SJakub Pawlowski queue_delayed_work(hdev->workqueue, 29292d28cfe7SJakub Pawlowski &hdev->le_scan_disable, timeout); 29302d28cfe7SJakub Pawlowski } 29312d28cfe7SJakub Pawlowski 29322d28cfe7SJakub Pawlowski static void le_scan_restart_work(struct work_struct *work) 29332d28cfe7SJakub Pawlowski { 29342d28cfe7SJakub Pawlowski struct hci_dev *hdev = container_of(work, struct hci_dev, 29352d28cfe7SJakub Pawlowski le_scan_restart.work); 29362d28cfe7SJakub Pawlowski struct hci_request req; 29372d28cfe7SJakub Pawlowski struct hci_cp_le_set_scan_enable cp; 29382d28cfe7SJakub Pawlowski int err; 29392d28cfe7SJakub Pawlowski 29402d28cfe7SJakub Pawlowski BT_DBG("%s", hdev->name); 29412d28cfe7SJakub Pawlowski 29422d28cfe7SJakub Pawlowski /* If controller is not scanning we are done. */ 29432d28cfe7SJakub Pawlowski if (!test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 29442d28cfe7SJakub Pawlowski return; 29452d28cfe7SJakub Pawlowski 29462d28cfe7SJakub Pawlowski hci_req_init(&req, hdev); 29472d28cfe7SJakub Pawlowski 29482d28cfe7SJakub Pawlowski hci_req_add_le_scan_disable(&req); 29492d28cfe7SJakub Pawlowski 29502d28cfe7SJakub Pawlowski memset(&cp, 0, sizeof(cp)); 29512d28cfe7SJakub Pawlowski cp.enable = LE_SCAN_ENABLE; 29522d28cfe7SJakub Pawlowski cp.filter_dup = LE_SCAN_FILTER_DUP_ENABLE; 29532d28cfe7SJakub Pawlowski hci_req_add(&req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 29542d28cfe7SJakub Pawlowski 29552d28cfe7SJakub Pawlowski err = hci_req_run(&req, le_scan_restart_work_complete); 29562d28cfe7SJakub Pawlowski if (err) 29572d28cfe7SJakub Pawlowski BT_ERR("Restart LE scan request failed: err %d", err); 29582d28cfe7SJakub Pawlowski } 29592d28cfe7SJakub Pawlowski 2960a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 2961a1f4c318SJohan Hedberg * 2962a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 2963a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 2964a1f4c318SJohan Hedberg * the static random address. 2965a1f4c318SJohan Hedberg * 2966a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 2967a1f4c318SJohan Hedberg * public address to use the static random address instead. 296850b5b952SMarcel Holtmann * 296950b5b952SMarcel Holtmann * In case BR/EDR has been disabled on a dual-mode controller and 297050b5b952SMarcel Holtmann * userspace has configured a static address, then that address 297150b5b952SMarcel Holtmann * becomes the identity address instead of the public BR/EDR address. 2972a1f4c318SJohan Hedberg */ 2973a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 2974a1f4c318SJohan Hedberg u8 *bdaddr_type) 2975a1f4c318SJohan Hedberg { 2976111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 297750b5b952SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) || 297850b5b952SMarcel Holtmann (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags) && 297950b5b952SMarcel Holtmann bacmp(&hdev->static_addr, BDADDR_ANY))) { 2980a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 2981a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 2982a1f4c318SJohan Hedberg } else { 2983a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 2984a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 2985a1f4c318SJohan Hedberg } 2986a1f4c318SJohan Hedberg } 2987a1f4c318SJohan Hedberg 29889be0dab7SDavid Herrmann /* Alloc HCI device */ 29899be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 29909be0dab7SDavid Herrmann { 29919be0dab7SDavid Herrmann struct hci_dev *hdev; 29929be0dab7SDavid Herrmann 299327f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 29949be0dab7SDavid Herrmann if (!hdev) 29959be0dab7SDavid Herrmann return NULL; 29969be0dab7SDavid Herrmann 2997b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 2998b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 2999b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 3000b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 3001b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 300296c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 3003bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 3004bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 3005b1b813d4SDavid Herrmann 3006b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3007b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3008b1b813d4SDavid Herrmann 30093f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3010628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 3011628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 3012bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3013bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 30144e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 30154e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 301604fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 301704fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3018a8e1bfaaSMarcel Holtmann hdev->le_def_tx_len = 0x001b; 3019a8e1bfaaSMarcel Holtmann hdev->le_def_tx_time = 0x0148; 3020a8e1bfaaSMarcel Holtmann hdev->le_max_tx_len = 0x001b; 3021a8e1bfaaSMarcel Holtmann hdev->le_max_tx_time = 0x0148; 3022a8e1bfaaSMarcel Holtmann hdev->le_max_rx_len = 0x001b; 3023a8e1bfaaSMarcel Holtmann hdev->le_max_rx_time = 0x0148; 3024bef64738SMarcel Holtmann 3025d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3026b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 302731ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 302831ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3029d6bfd59cSJohan Hedberg 3030b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3031b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3032b1b813d4SDavid Herrmann 3033b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3034b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 30356659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 3036b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3037b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3038b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3039970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3040b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3041d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 304215819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 304377a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 304466f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 30456b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3046b1b813d4SDavid Herrmann 3047b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3048b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3049b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3050b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3051c7741d16SMarcel Holtmann INIT_WORK(&hdev->error_reset, hci_error_reset); 3052b1b813d4SDavid Herrmann 3053b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3054b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 3055b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 30562d28cfe7SJakub Pawlowski INIT_DELAYED_WORK(&hdev->le_scan_restart, le_scan_restart_work); 3057b1b813d4SDavid Herrmann 3058b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3059b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3060b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3061b1b813d4SDavid Herrmann 3062b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3063b1b813d4SDavid Herrmann 306465cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3065b1b813d4SDavid Herrmann 3066b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3067b1b813d4SDavid Herrmann discovery_init(hdev); 30689be0dab7SDavid Herrmann 30699be0dab7SDavid Herrmann return hdev; 30709be0dab7SDavid Herrmann } 30719be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 30729be0dab7SDavid Herrmann 30739be0dab7SDavid Herrmann /* Free HCI device */ 30749be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 30759be0dab7SDavid Herrmann { 30769be0dab7SDavid Herrmann /* will free via device release */ 30779be0dab7SDavid Herrmann put_device(&hdev->dev); 30789be0dab7SDavid Herrmann } 30799be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 30809be0dab7SDavid Herrmann 30811da177e4SLinus Torvalds /* Register HCI device */ 30821da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 30831da177e4SLinus Torvalds { 3084b1b813d4SDavid Herrmann int id, error; 30851da177e4SLinus Torvalds 308674292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 30871da177e4SLinus Torvalds return -EINVAL; 30881da177e4SLinus Torvalds 308908add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 309008add513SMat Martineau * so the index can be used as the AMP controller ID. 309108add513SMat Martineau */ 30923df92b31SSasha Levin switch (hdev->dev_type) { 30933df92b31SSasha Levin case HCI_BREDR: 30943df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 30951da177e4SLinus Torvalds break; 30963df92b31SSasha Levin case HCI_AMP: 30973df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 30983df92b31SSasha Levin break; 30993df92b31SSasha Levin default: 31003df92b31SSasha Levin return -EINVAL; 31011da177e4SLinus Torvalds } 31021da177e4SLinus Torvalds 31033df92b31SSasha Levin if (id < 0) 31043df92b31SSasha Levin return id; 31053df92b31SSasha Levin 31061da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 31071da177e4SLinus Torvalds hdev->id = id; 31082d8b3a11SAndrei Emeltchenko 31092d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 31102d8b3a11SAndrei Emeltchenko 3111d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3112d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 311333ca954dSDavid Herrmann if (!hdev->workqueue) { 311433ca954dSDavid Herrmann error = -ENOMEM; 311533ca954dSDavid Herrmann goto err; 311633ca954dSDavid Herrmann } 3117f48fd9c8SMarcel Holtmann 3118d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3119d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 31206ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 31216ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 31226ead1bbcSJohan Hedberg error = -ENOMEM; 31236ead1bbcSJohan Hedberg goto err; 31246ead1bbcSJohan Hedberg } 31256ead1bbcSJohan Hedberg 31260153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 31270153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 31280153e2ecSMarcel Holtmann 3129bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 3130bdc3e0f1SMarcel Holtmann 3131bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 313233ca954dSDavid Herrmann if (error < 0) 313354506918SJohan Hedberg goto err_wqueue; 31341da177e4SLinus Torvalds 3135611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 3136a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 3137a8c5fb1aSGustavo Padovan hdev); 3138611b30f7SMarcel Holtmann if (hdev->rfkill) { 3139611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 3140611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3141611b30f7SMarcel Holtmann hdev->rfkill = NULL; 3142611b30f7SMarcel Holtmann } 3143611b30f7SMarcel Holtmann } 3144611b30f7SMarcel Holtmann 31455e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 31465e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 31475e130367SJohan Hedberg 3148a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 3149004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 3150ce2be9acSAndrei Emeltchenko 315101cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 315256f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 315356f87901SJohan Hedberg * through reading supported features during init. 315456f87901SJohan Hedberg */ 315556f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 315656f87901SJohan Hedberg } 3157ce2be9acSAndrei Emeltchenko 3158fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 3159fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 3160fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3161fcee3377SGustavo Padovan 31624a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 31634a964404SMarcel Holtmann * and should not be included in normal operation. 3164fee746b0SMarcel Holtmann */ 3165fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 31664a964404SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 3167fee746b0SMarcel Holtmann 31681da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 3169dc946bd8SDavid Herrmann hci_dev_hold(hdev); 31701da177e4SLinus Torvalds 317119202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3172fbe96d6fSMarcel Holtmann 31731da177e4SLinus Torvalds return id; 3174f48fd9c8SMarcel Holtmann 317533ca954dSDavid Herrmann err_wqueue: 317633ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 31776ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 317833ca954dSDavid Herrmann err: 31793df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3180f48fd9c8SMarcel Holtmann 318133ca954dSDavid Herrmann return error; 31821da177e4SLinus Torvalds } 31831da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 31841da177e4SLinus Torvalds 31851da177e4SLinus Torvalds /* Unregister HCI device */ 318659735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 31871da177e4SLinus Torvalds { 31883df92b31SSasha Levin int i, id; 3189ef222013SMarcel Holtmann 3190c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 31911da177e4SLinus Torvalds 319294324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 319394324962SJohan Hovold 31943df92b31SSasha Levin id = hdev->id; 31953df92b31SSasha Levin 3196f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 31971da177e4SLinus Torvalds list_del(&hdev->list); 3198f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 31991da177e4SLinus Torvalds 32001da177e4SLinus Torvalds hci_dev_do_close(hdev); 32011da177e4SLinus Torvalds 3202cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 3203ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 3204ef222013SMarcel Holtmann 3205b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3206b9b5ef18SGustavo Padovan 3207ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3208d603b76bSMarcel Holtmann !test_bit(HCI_SETUP, &hdev->dev_flags) && 3209d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 321009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3211744cf19eSJohan Hedberg mgmt_index_removed(hdev); 321209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 321356e5cb86SJohan Hedberg } 3214ab81cbf9SJohan Hedberg 32152e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 32162e58ef3eSJohan Hedberg * pending list */ 32172e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 32182e58ef3eSJohan Hedberg 32191da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 32201da177e4SLinus Torvalds 3221611b30f7SMarcel Holtmann if (hdev->rfkill) { 3222611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3223611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3224611b30f7SMarcel Holtmann } 3225611b30f7SMarcel Holtmann 3226bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 3227147e2d59SDave Young 32280153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 32290153e2ecSMarcel Holtmann 3230f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 32316ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 3232f48fd9c8SMarcel Holtmann 323309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3234dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 32356659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 32362aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 323755ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 3238b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 3239970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 32402763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 3241dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 3242373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 324322078800SMarcel Holtmann hci_discovery_filter_clear(hdev); 324409fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 3245e2e0cacbSJohan Hedberg 3246dc946bd8SDavid Herrmann hci_dev_put(hdev); 32473df92b31SSasha Levin 32483df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 32491da177e4SLinus Torvalds } 32501da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 32511da177e4SLinus Torvalds 32521da177e4SLinus Torvalds /* Suspend HCI device */ 32531da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 32541da177e4SLinus Torvalds { 32551da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 32561da177e4SLinus Torvalds return 0; 32571da177e4SLinus Torvalds } 32581da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 32591da177e4SLinus Torvalds 32601da177e4SLinus Torvalds /* Resume HCI device */ 32611da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 32621da177e4SLinus Torvalds { 32631da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 32641da177e4SLinus Torvalds return 0; 32651da177e4SLinus Torvalds } 32661da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 32671da177e4SLinus Torvalds 326875e0569fSMarcel Holtmann /* Reset HCI device */ 326975e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 327075e0569fSMarcel Holtmann { 327175e0569fSMarcel Holtmann const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 327275e0569fSMarcel Holtmann struct sk_buff *skb; 327375e0569fSMarcel Holtmann 327475e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 327575e0569fSMarcel Holtmann if (!skb) 327675e0569fSMarcel Holtmann return -ENOMEM; 327775e0569fSMarcel Holtmann 327875e0569fSMarcel Holtmann bt_cb(skb)->pkt_type = HCI_EVENT_PKT; 327975e0569fSMarcel Holtmann memcpy(skb_put(skb, 3), hw_err, 3); 328075e0569fSMarcel Holtmann 328175e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 328275e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 328375e0569fSMarcel Holtmann } 328475e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 328575e0569fSMarcel Holtmann 328676bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 3287e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 328876bca880SMarcel Holtmann { 328976bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 329076bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 329176bca880SMarcel Holtmann kfree_skb(skb); 329276bca880SMarcel Holtmann return -ENXIO; 329376bca880SMarcel Holtmann } 329476bca880SMarcel Holtmann 3295d82603c6SJorrit Schippers /* Incoming skb */ 329676bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 329776bca880SMarcel Holtmann 329876bca880SMarcel Holtmann /* Time stamp */ 329976bca880SMarcel Holtmann __net_timestamp(skb); 330076bca880SMarcel Holtmann 330176bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3302b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3303c78ae283SMarcel Holtmann 330476bca880SMarcel Holtmann return 0; 330576bca880SMarcel Holtmann } 330676bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 330776bca880SMarcel Holtmann 330833e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 33091e429f38SGustavo F. Padovan int count, __u8 index) 331033e882a5SSuraj Sumangala { 331133e882a5SSuraj Sumangala int len = 0; 331233e882a5SSuraj Sumangala int hlen = 0; 331333e882a5SSuraj Sumangala int remain = count; 331433e882a5SSuraj Sumangala struct sk_buff *skb; 331533e882a5SSuraj Sumangala struct bt_skb_cb *scb; 331633e882a5SSuraj Sumangala 331733e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 331833e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 331933e882a5SSuraj Sumangala return -EILSEQ; 332033e882a5SSuraj Sumangala 332133e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 332233e882a5SSuraj Sumangala 332333e882a5SSuraj Sumangala if (!skb) { 332433e882a5SSuraj Sumangala switch (type) { 332533e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 332633e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 332733e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 332833e882a5SSuraj Sumangala break; 332933e882a5SSuraj Sumangala case HCI_EVENT_PKT: 333033e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 333133e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 333233e882a5SSuraj Sumangala break; 333333e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 333433e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 333533e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 333633e882a5SSuraj Sumangala break; 333733e882a5SSuraj Sumangala } 333833e882a5SSuraj Sumangala 33391e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 334033e882a5SSuraj Sumangala if (!skb) 334133e882a5SSuraj Sumangala return -ENOMEM; 334233e882a5SSuraj Sumangala 334333e882a5SSuraj Sumangala scb = (void *) skb->cb; 334433e882a5SSuraj Sumangala scb->expect = hlen; 334533e882a5SSuraj Sumangala scb->pkt_type = type; 334633e882a5SSuraj Sumangala 334733e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 334833e882a5SSuraj Sumangala } 334933e882a5SSuraj Sumangala 335033e882a5SSuraj Sumangala while (count) { 335133e882a5SSuraj Sumangala scb = (void *) skb->cb; 335289bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 335333e882a5SSuraj Sumangala 335433e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 335533e882a5SSuraj Sumangala 335633e882a5SSuraj Sumangala count -= len; 335733e882a5SSuraj Sumangala data += len; 335833e882a5SSuraj Sumangala scb->expect -= len; 335933e882a5SSuraj Sumangala remain = count; 336033e882a5SSuraj Sumangala 336133e882a5SSuraj Sumangala switch (type) { 336233e882a5SSuraj Sumangala case HCI_EVENT_PKT: 336333e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 336433e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 336533e882a5SSuraj Sumangala scb->expect = h->plen; 336633e882a5SSuraj Sumangala 336733e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 336833e882a5SSuraj Sumangala kfree_skb(skb); 336933e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 337033e882a5SSuraj Sumangala return -ENOMEM; 337133e882a5SSuraj Sumangala } 337233e882a5SSuraj Sumangala } 337333e882a5SSuraj Sumangala break; 337433e882a5SSuraj Sumangala 337533e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 337633e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 337733e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 337833e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 337933e882a5SSuraj Sumangala 338033e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 338133e882a5SSuraj Sumangala kfree_skb(skb); 338233e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 338333e882a5SSuraj Sumangala return -ENOMEM; 338433e882a5SSuraj Sumangala } 338533e882a5SSuraj Sumangala } 338633e882a5SSuraj Sumangala break; 338733e882a5SSuraj Sumangala 338833e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 338933e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 339033e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 339133e882a5SSuraj Sumangala scb->expect = h->dlen; 339233e882a5SSuraj Sumangala 339333e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 339433e882a5SSuraj Sumangala kfree_skb(skb); 339533e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 339633e882a5SSuraj Sumangala return -ENOMEM; 339733e882a5SSuraj Sumangala } 339833e882a5SSuraj Sumangala } 339933e882a5SSuraj Sumangala break; 340033e882a5SSuraj Sumangala } 340133e882a5SSuraj Sumangala 340233e882a5SSuraj Sumangala if (scb->expect == 0) { 340333e882a5SSuraj Sumangala /* Complete frame */ 340433e882a5SSuraj Sumangala 340533e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 3406e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 340733e882a5SSuraj Sumangala 340833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 340933e882a5SSuraj Sumangala return remain; 341033e882a5SSuraj Sumangala } 341133e882a5SSuraj Sumangala } 341233e882a5SSuraj Sumangala 341333e882a5SSuraj Sumangala return remain; 341433e882a5SSuraj Sumangala } 341533e882a5SSuraj Sumangala 341699811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 341799811510SSuraj Sumangala 341899811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 341999811510SSuraj Sumangala { 342099811510SSuraj Sumangala int type; 342199811510SSuraj Sumangala int rem = 0; 342299811510SSuraj Sumangala 3423da5f6c37SGustavo F. Padovan while (count) { 342499811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 342599811510SSuraj Sumangala 342699811510SSuraj Sumangala if (!skb) { 342799811510SSuraj Sumangala struct { char type; } *pkt; 342899811510SSuraj Sumangala 342999811510SSuraj Sumangala /* Start of the frame */ 343099811510SSuraj Sumangala pkt = data; 343199811510SSuraj Sumangala type = pkt->type; 343299811510SSuraj Sumangala 343399811510SSuraj Sumangala data++; 343499811510SSuraj Sumangala count--; 343599811510SSuraj Sumangala } else 343699811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 343799811510SSuraj Sumangala 34381e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 34391e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 344099811510SSuraj Sumangala if (rem < 0) 344199811510SSuraj Sumangala return rem; 344299811510SSuraj Sumangala 344399811510SSuraj Sumangala data += (count - rem); 344499811510SSuraj Sumangala count = rem; 3445f81c6224SJoe Perches } 344699811510SSuraj Sumangala 344799811510SSuraj Sumangala return rem; 344899811510SSuraj Sumangala } 344999811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 345099811510SSuraj Sumangala 34511da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 34521da177e4SLinus Torvalds 34531da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 34541da177e4SLinus Torvalds { 34551da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 34561da177e4SLinus Torvalds 3457f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 34581da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 3459f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 34601da177e4SLinus Torvalds 34611da177e4SLinus Torvalds return 0; 34621da177e4SLinus Torvalds } 34631da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 34641da177e4SLinus Torvalds 34651da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 34661da177e4SLinus Torvalds { 34671da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 34681da177e4SLinus Torvalds 3469f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 34701da177e4SLinus Torvalds list_del(&cb->list); 3471f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 34721da177e4SLinus Torvalds 34731da177e4SLinus Torvalds return 0; 34741da177e4SLinus Torvalds } 34751da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 34761da177e4SLinus Torvalds 347751086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 34781da177e4SLinus Torvalds { 3479cdc52faaSMarcel Holtmann int err; 3480cdc52faaSMarcel Holtmann 34810d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 34821da177e4SLinus Torvalds 34831da177e4SLinus Torvalds /* Time stamp */ 3484a61bbcf2SPatrick McHardy __net_timestamp(skb); 34851da177e4SLinus Torvalds 3486cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3487cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3488cd82e61cSMarcel Holtmann 3489cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3490cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3491470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 34921da177e4SLinus Torvalds } 34931da177e4SLinus Torvalds 34941da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 34951da177e4SLinus Torvalds skb_orphan(skb); 34961da177e4SLinus Torvalds 3497cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 3498cdc52faaSMarcel Holtmann if (err < 0) { 3499cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 3500cdc52faaSMarcel Holtmann kfree_skb(skb); 3501cdc52faaSMarcel Holtmann } 35021da177e4SLinus Torvalds } 35031da177e4SLinus Torvalds 3504899de765SMarcel Holtmann bool hci_req_pending(struct hci_dev *hdev) 3505899de765SMarcel Holtmann { 3506899de765SMarcel Holtmann return (hdev->req_status == HCI_REQ_PEND); 3507899de765SMarcel Holtmann } 3508899de765SMarcel Holtmann 35091ca3a9d0SJohan Hedberg /* Send HCI command */ 351007dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 351107dc93ddSJohan Hedberg const void *param) 35121ca3a9d0SJohan Hedberg { 35131ca3a9d0SJohan Hedberg struct sk_buff *skb; 35141ca3a9d0SJohan Hedberg 35151ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 35161ca3a9d0SJohan Hedberg 35171ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 35181ca3a9d0SJohan Hedberg if (!skb) { 35191ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 35201ca3a9d0SJohan Hedberg return -ENOMEM; 35211ca3a9d0SJohan Hedberg } 35221ca3a9d0SJohan Hedberg 352349c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 352411714b3dSJohan Hedberg * single-command requests. 352511714b3dSJohan Hedberg */ 352611714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 352711714b3dSJohan Hedberg 35281da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3529c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 35301da177e4SLinus Torvalds 35311da177e4SLinus Torvalds return 0; 35321da177e4SLinus Torvalds } 35331da177e4SLinus Torvalds 35341da177e4SLinus Torvalds /* Get data from the previously sent command */ 3535a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 35361da177e4SLinus Torvalds { 35371da177e4SLinus Torvalds struct hci_command_hdr *hdr; 35381da177e4SLinus Torvalds 35391da177e4SLinus Torvalds if (!hdev->sent_cmd) 35401da177e4SLinus Torvalds return NULL; 35411da177e4SLinus Torvalds 35421da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 35431da177e4SLinus Torvalds 3544a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 35451da177e4SLinus Torvalds return NULL; 35461da177e4SLinus Torvalds 3547f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 35481da177e4SLinus Torvalds 35491da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 35501da177e4SLinus Torvalds } 35511da177e4SLinus Torvalds 35521da177e4SLinus Torvalds /* Send ACL data */ 35531da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 35541da177e4SLinus Torvalds { 35551da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 35561da177e4SLinus Torvalds int len = skb->len; 35571da177e4SLinus Torvalds 3558badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3559badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 35609c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3561aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3562aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 35631da177e4SLinus Torvalds } 35641da177e4SLinus Torvalds 3565ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 356673d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 35671da177e4SLinus Torvalds { 3568ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 35691da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 35701da177e4SLinus Torvalds struct sk_buff *list; 35711da177e4SLinus Torvalds 3572087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3573087bfd99SGustavo Padovan skb->data_len = 0; 3574087bfd99SGustavo Padovan 3575087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3576204a6e54SAndrei Emeltchenko 3577204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3578204a6e54SAndrei Emeltchenko case HCI_BREDR: 3579087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3580204a6e54SAndrei Emeltchenko break; 3581204a6e54SAndrei Emeltchenko case HCI_AMP: 3582204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3583204a6e54SAndrei Emeltchenko break; 3584204a6e54SAndrei Emeltchenko default: 3585204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 3586204a6e54SAndrei Emeltchenko return; 3587204a6e54SAndrei Emeltchenko } 3588087bfd99SGustavo Padovan 358970f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 359070f23020SAndrei Emeltchenko if (!list) { 35911da177e4SLinus Torvalds /* Non fragmented */ 35921da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 35931da177e4SLinus Torvalds 359473d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 35951da177e4SLinus Torvalds } else { 35961da177e4SLinus Torvalds /* Fragmented */ 35971da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 35981da177e4SLinus Torvalds 35991da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 36001da177e4SLinus Torvalds 36019cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 36029cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 36039cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 36049cfd5a23SJukka Rissanen * deadlocks. 36059cfd5a23SJukka Rissanen */ 36069cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 36071da177e4SLinus Torvalds 360873d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3609e702112fSAndrei Emeltchenko 3610e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3611e702112fSAndrei Emeltchenko flags |= ACL_CONT; 36121da177e4SLinus Torvalds do { 36131da177e4SLinus Torvalds skb = list; list = list->next; 36141da177e4SLinus Torvalds 36150d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3616e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 36171da177e4SLinus Torvalds 36181da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 36191da177e4SLinus Torvalds 362073d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 36211da177e4SLinus Torvalds } while (list); 36221da177e4SLinus Torvalds 36239cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 36241da177e4SLinus Torvalds } 362573d80debSLuiz Augusto von Dentz } 362673d80debSLuiz Augusto von Dentz 362773d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 362873d80debSLuiz Augusto von Dentz { 3629ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 363073d80debSLuiz Augusto von Dentz 3631f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 363273d80debSLuiz Augusto von Dentz 3633ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 36341da177e4SLinus Torvalds 36353eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 36361da177e4SLinus Torvalds } 36371da177e4SLinus Torvalds 36381da177e4SLinus Torvalds /* Send SCO data */ 36390d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 36401da177e4SLinus Torvalds { 36411da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 36421da177e4SLinus Torvalds struct hci_sco_hdr hdr; 36431da177e4SLinus Torvalds 36441da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 36451da177e4SLinus Torvalds 3646aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 36471da177e4SLinus Torvalds hdr.dlen = skb->len; 36481da177e4SLinus Torvalds 3649badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3650badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 36519c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 36521da177e4SLinus Torvalds 36530d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 3654c78ae283SMarcel Holtmann 36551da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 36563eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 36571da177e4SLinus Torvalds } 36581da177e4SLinus Torvalds 36591da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 36601da177e4SLinus Torvalds 36611da177e4SLinus Torvalds /* HCI Connection scheduler */ 36626039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3663a8c5fb1aSGustavo Padovan int *quote) 36641da177e4SLinus Torvalds { 36651da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 36668035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3667abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 36681da177e4SLinus Torvalds 36691da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 36701da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3671bf4c6325SGustavo F. Padovan 3672bf4c6325SGustavo F. Padovan rcu_read_lock(); 3673bf4c6325SGustavo F. Padovan 3674bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3675769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 36761da177e4SLinus Torvalds continue; 3677769be974SMarcel Holtmann 3678769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3679769be974SMarcel Holtmann continue; 3680769be974SMarcel Holtmann 36811da177e4SLinus Torvalds num++; 36821da177e4SLinus Torvalds 36831da177e4SLinus Torvalds if (c->sent < min) { 36841da177e4SLinus Torvalds min = c->sent; 36851da177e4SLinus Torvalds conn = c; 36861da177e4SLinus Torvalds } 368752087a79SLuiz Augusto von Dentz 368852087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 368952087a79SLuiz Augusto von Dentz break; 36901da177e4SLinus Torvalds } 36911da177e4SLinus Torvalds 3692bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3693bf4c6325SGustavo F. Padovan 36941da177e4SLinus Torvalds if (conn) { 36956ed58ec5SVille Tervo int cnt, q; 36966ed58ec5SVille Tervo 36976ed58ec5SVille Tervo switch (conn->type) { 36986ed58ec5SVille Tervo case ACL_LINK: 36996ed58ec5SVille Tervo cnt = hdev->acl_cnt; 37006ed58ec5SVille Tervo break; 37016ed58ec5SVille Tervo case SCO_LINK: 37026ed58ec5SVille Tervo case ESCO_LINK: 37036ed58ec5SVille Tervo cnt = hdev->sco_cnt; 37046ed58ec5SVille Tervo break; 37056ed58ec5SVille Tervo case LE_LINK: 37066ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 37076ed58ec5SVille Tervo break; 37086ed58ec5SVille Tervo default: 37096ed58ec5SVille Tervo cnt = 0; 37106ed58ec5SVille Tervo BT_ERR("Unknown link type"); 37116ed58ec5SVille Tervo } 37126ed58ec5SVille Tervo 37136ed58ec5SVille Tervo q = cnt / num; 37141da177e4SLinus Torvalds *quote = q ? q : 1; 37151da177e4SLinus Torvalds } else 37161da177e4SLinus Torvalds *quote = 0; 37171da177e4SLinus Torvalds 37181da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 37191da177e4SLinus Torvalds return conn; 37201da177e4SLinus Torvalds } 37211da177e4SLinus Torvalds 37226039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 37231da177e4SLinus Torvalds { 37241da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 37251da177e4SLinus Torvalds struct hci_conn *c; 37261da177e4SLinus Torvalds 3727bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 37281da177e4SLinus Torvalds 3729bf4c6325SGustavo F. Padovan rcu_read_lock(); 3730bf4c6325SGustavo F. Padovan 37311da177e4SLinus Torvalds /* Kill stalled connections */ 3732bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3733bae1f5d9SVille Tervo if (c->type == type && c->sent) { 37346ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 37356ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 3736bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 37371da177e4SLinus Torvalds } 37381da177e4SLinus Torvalds } 3739bf4c6325SGustavo F. Padovan 3740bf4c6325SGustavo F. Padovan rcu_read_unlock(); 37411da177e4SLinus Torvalds } 37421da177e4SLinus Torvalds 37436039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 374473d80debSLuiz Augusto von Dentz int *quote) 374573d80debSLuiz Augusto von Dentz { 374673d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 374773d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3748abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 374973d80debSLuiz Augusto von Dentz struct hci_conn *conn; 375073d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 375173d80debSLuiz Augusto von Dentz 375273d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 375373d80debSLuiz Augusto von Dentz 3754bf4c6325SGustavo F. Padovan rcu_read_lock(); 3755bf4c6325SGustavo F. Padovan 3756bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 375773d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 375873d80debSLuiz Augusto von Dentz 375973d80debSLuiz Augusto von Dentz if (conn->type != type) 376073d80debSLuiz Augusto von Dentz continue; 376173d80debSLuiz Augusto von Dentz 376273d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 376373d80debSLuiz Augusto von Dentz continue; 376473d80debSLuiz Augusto von Dentz 376573d80debSLuiz Augusto von Dentz conn_num++; 376673d80debSLuiz Augusto von Dentz 37678192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 376873d80debSLuiz Augusto von Dentz struct sk_buff *skb; 376973d80debSLuiz Augusto von Dentz 377073d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 377173d80debSLuiz Augusto von Dentz continue; 377273d80debSLuiz Augusto von Dentz 377373d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 377473d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 377573d80debSLuiz Augusto von Dentz continue; 377673d80debSLuiz Augusto von Dentz 377773d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 377873d80debSLuiz Augusto von Dentz num = 0; 377973d80debSLuiz Augusto von Dentz min = ~0; 378073d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 378173d80debSLuiz Augusto von Dentz } 378273d80debSLuiz Augusto von Dentz 378373d80debSLuiz Augusto von Dentz num++; 378473d80debSLuiz Augusto von Dentz 378573d80debSLuiz Augusto von Dentz if (conn->sent < min) { 378673d80debSLuiz Augusto von Dentz min = conn->sent; 378773d80debSLuiz Augusto von Dentz chan = tmp; 378873d80debSLuiz Augusto von Dentz } 378973d80debSLuiz Augusto von Dentz } 379073d80debSLuiz Augusto von Dentz 379173d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 379273d80debSLuiz Augusto von Dentz break; 379373d80debSLuiz Augusto von Dentz } 379473d80debSLuiz Augusto von Dentz 3795bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3796bf4c6325SGustavo F. Padovan 379773d80debSLuiz Augusto von Dentz if (!chan) 379873d80debSLuiz Augusto von Dentz return NULL; 379973d80debSLuiz Augusto von Dentz 380073d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 380173d80debSLuiz Augusto von Dentz case ACL_LINK: 380273d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 380373d80debSLuiz Augusto von Dentz break; 3804bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3805bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3806bd1eb66bSAndrei Emeltchenko break; 380773d80debSLuiz Augusto von Dentz case SCO_LINK: 380873d80debSLuiz Augusto von Dentz case ESCO_LINK: 380973d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 381073d80debSLuiz Augusto von Dentz break; 381173d80debSLuiz Augusto von Dentz case LE_LINK: 381273d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 381373d80debSLuiz Augusto von Dentz break; 381473d80debSLuiz Augusto von Dentz default: 381573d80debSLuiz Augusto von Dentz cnt = 0; 381673d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 381773d80debSLuiz Augusto von Dentz } 381873d80debSLuiz Augusto von Dentz 381973d80debSLuiz Augusto von Dentz q = cnt / num; 382073d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 382173d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 382273d80debSLuiz Augusto von Dentz return chan; 382373d80debSLuiz Augusto von Dentz } 382473d80debSLuiz Augusto von Dentz 382502b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 382602b20f0bSLuiz Augusto von Dentz { 382702b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 382802b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 382902b20f0bSLuiz Augusto von Dentz int num = 0; 383002b20f0bSLuiz Augusto von Dentz 383102b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 383202b20f0bSLuiz Augusto von Dentz 3833bf4c6325SGustavo F. Padovan rcu_read_lock(); 3834bf4c6325SGustavo F. Padovan 3835bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 383602b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 383702b20f0bSLuiz Augusto von Dentz 383802b20f0bSLuiz Augusto von Dentz if (conn->type != type) 383902b20f0bSLuiz Augusto von Dentz continue; 384002b20f0bSLuiz Augusto von Dentz 384102b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 384202b20f0bSLuiz Augusto von Dentz continue; 384302b20f0bSLuiz Augusto von Dentz 384402b20f0bSLuiz Augusto von Dentz num++; 384502b20f0bSLuiz Augusto von Dentz 38468192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 384702b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 384802b20f0bSLuiz Augusto von Dentz 384902b20f0bSLuiz Augusto von Dentz if (chan->sent) { 385002b20f0bSLuiz Augusto von Dentz chan->sent = 0; 385102b20f0bSLuiz Augusto von Dentz continue; 385202b20f0bSLuiz Augusto von Dentz } 385302b20f0bSLuiz Augusto von Dentz 385402b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 385502b20f0bSLuiz Augusto von Dentz continue; 385602b20f0bSLuiz Augusto von Dentz 385702b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 385802b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 385902b20f0bSLuiz Augusto von Dentz continue; 386002b20f0bSLuiz Augusto von Dentz 386102b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 386202b20f0bSLuiz Augusto von Dentz 386302b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 386402b20f0bSLuiz Augusto von Dentz skb->priority); 386502b20f0bSLuiz Augusto von Dentz } 386602b20f0bSLuiz Augusto von Dentz 386702b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 386802b20f0bSLuiz Augusto von Dentz break; 386902b20f0bSLuiz Augusto von Dentz } 3870bf4c6325SGustavo F. Padovan 3871bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3872bf4c6325SGustavo F. Padovan 387302b20f0bSLuiz Augusto von Dentz } 387402b20f0bSLuiz Augusto von Dentz 3875b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 3876b71d385aSAndrei Emeltchenko { 3877b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 3878b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 3879b71d385aSAndrei Emeltchenko } 3880b71d385aSAndrei Emeltchenko 38816039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 38821da177e4SLinus Torvalds { 38834a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 38841da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 38851da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 388663d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 38875f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 3888bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 38891da177e4SLinus Torvalds } 389063d2bc1bSAndrei Emeltchenko } 38911da177e4SLinus Torvalds 38926039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 389363d2bc1bSAndrei Emeltchenko { 389463d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 389563d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 389663d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 389763d2bc1bSAndrei Emeltchenko int quote; 389863d2bc1bSAndrei Emeltchenko 389963d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 390004837f64SMarcel Holtmann 390173d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 390273d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 3903ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3904ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 390573d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 390673d80debSLuiz Augusto von Dentz skb->len, skb->priority); 390773d80debSLuiz Augusto von Dentz 3908ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3909ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3910ec1cce24SLuiz Augusto von Dentz break; 3911ec1cce24SLuiz Augusto von Dentz 3912ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3913ec1cce24SLuiz Augusto von Dentz 391473d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 391573d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 391604837f64SMarcel Holtmann 391757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 39181da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 39191da177e4SLinus Torvalds 39201da177e4SLinus Torvalds hdev->acl_cnt--; 392173d80debSLuiz Augusto von Dentz chan->sent++; 392273d80debSLuiz Augusto von Dentz chan->conn->sent++; 39231da177e4SLinus Torvalds } 39241da177e4SLinus Torvalds } 392502b20f0bSLuiz Augusto von Dentz 392602b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 392702b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 39281da177e4SLinus Torvalds } 39291da177e4SLinus Torvalds 39306039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 3931b71d385aSAndrei Emeltchenko { 393263d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 3933b71d385aSAndrei Emeltchenko struct hci_chan *chan; 3934b71d385aSAndrei Emeltchenko struct sk_buff *skb; 3935b71d385aSAndrei Emeltchenko int quote; 3936bd1eb66bSAndrei Emeltchenko u8 type; 3937b71d385aSAndrei Emeltchenko 393863d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 3939b71d385aSAndrei Emeltchenko 3940bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3941bd1eb66bSAndrei Emeltchenko 3942bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 3943bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 3944bd1eb66bSAndrei Emeltchenko else 3945bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 3946bd1eb66bSAndrei Emeltchenko 3947b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 3948bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 3949b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 3950b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 3951b71d385aSAndrei Emeltchenko int blocks; 3952b71d385aSAndrei Emeltchenko 3953b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 3954b71d385aSAndrei Emeltchenko skb->len, skb->priority); 3955b71d385aSAndrei Emeltchenko 3956b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 3957b71d385aSAndrei Emeltchenko if (skb->priority < priority) 3958b71d385aSAndrei Emeltchenko break; 3959b71d385aSAndrei Emeltchenko 3960b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 3961b71d385aSAndrei Emeltchenko 3962b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 3963b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 3964b71d385aSAndrei Emeltchenko return; 3965b71d385aSAndrei Emeltchenko 3966b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 3967b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 3968b71d385aSAndrei Emeltchenko 396957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3970b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 3971b71d385aSAndrei Emeltchenko 3972b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 3973b71d385aSAndrei Emeltchenko quote -= blocks; 3974b71d385aSAndrei Emeltchenko 3975b71d385aSAndrei Emeltchenko chan->sent += blocks; 3976b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 3977b71d385aSAndrei Emeltchenko } 3978b71d385aSAndrei Emeltchenko } 3979b71d385aSAndrei Emeltchenko 3980b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 3981bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 3982b71d385aSAndrei Emeltchenko } 3983b71d385aSAndrei Emeltchenko 39846039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 3985b71d385aSAndrei Emeltchenko { 3986b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3987b71d385aSAndrei Emeltchenko 3988bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 3989bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 3990bd1eb66bSAndrei Emeltchenko return; 3991bd1eb66bSAndrei Emeltchenko 3992bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 3993bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 3994b71d385aSAndrei Emeltchenko return; 3995b71d385aSAndrei Emeltchenko 3996b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 3997b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 3998b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 3999b71d385aSAndrei Emeltchenko break; 4000b71d385aSAndrei Emeltchenko 4001b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 4002b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 4003b71d385aSAndrei Emeltchenko break; 4004b71d385aSAndrei Emeltchenko } 4005b71d385aSAndrei Emeltchenko } 4006b71d385aSAndrei Emeltchenko 40071da177e4SLinus Torvalds /* Schedule SCO */ 40086039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 40091da177e4SLinus Torvalds { 40101da177e4SLinus Torvalds struct hci_conn *conn; 40111da177e4SLinus Torvalds struct sk_buff *skb; 40121da177e4SLinus Torvalds int quote; 40131da177e4SLinus Torvalds 40141da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 40151da177e4SLinus Torvalds 401652087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 401752087a79SLuiz Augusto von Dentz return; 401852087a79SLuiz Augusto von Dentz 40191da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 40201da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 40211da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 402257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40231da177e4SLinus Torvalds 40241da177e4SLinus Torvalds conn->sent++; 40251da177e4SLinus Torvalds if (conn->sent == ~0) 40261da177e4SLinus Torvalds conn->sent = 0; 40271da177e4SLinus Torvalds } 40281da177e4SLinus Torvalds } 40291da177e4SLinus Torvalds } 40301da177e4SLinus Torvalds 40316039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 4032b6a0dc82SMarcel Holtmann { 4033b6a0dc82SMarcel Holtmann struct hci_conn *conn; 4034b6a0dc82SMarcel Holtmann struct sk_buff *skb; 4035b6a0dc82SMarcel Holtmann int quote; 4036b6a0dc82SMarcel Holtmann 4037b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 4038b6a0dc82SMarcel Holtmann 403952087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 404052087a79SLuiz Augusto von Dentz return; 404152087a79SLuiz Augusto von Dentz 40428fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 40438fc9ced3SGustavo Padovan "e))) { 4044b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 4045b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 404657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4047b6a0dc82SMarcel Holtmann 4048b6a0dc82SMarcel Holtmann conn->sent++; 4049b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 4050b6a0dc82SMarcel Holtmann conn->sent = 0; 4051b6a0dc82SMarcel Holtmann } 4052b6a0dc82SMarcel Holtmann } 4053b6a0dc82SMarcel Holtmann } 4054b6a0dc82SMarcel Holtmann 40556039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 40566ed58ec5SVille Tervo { 405773d80debSLuiz Augusto von Dentz struct hci_chan *chan; 40586ed58ec5SVille Tervo struct sk_buff *skb; 405902b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 40606ed58ec5SVille Tervo 40616ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 40626ed58ec5SVille Tervo 406352087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 406452087a79SLuiz Augusto von Dentz return; 406552087a79SLuiz Augusto von Dentz 40664a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 40676ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 40686ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 4069bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 40706ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 4071bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 40726ed58ec5SVille Tervo } 40736ed58ec5SVille Tervo 40746ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 407502b20f0bSLuiz Augusto von Dentz tmp = cnt; 407673d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 4077ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4078ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 407973d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 408073d80debSLuiz Augusto von Dentz skb->len, skb->priority); 40816ed58ec5SVille Tervo 4082ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4083ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4084ec1cce24SLuiz Augusto von Dentz break; 4085ec1cce24SLuiz Augusto von Dentz 4086ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4087ec1cce24SLuiz Augusto von Dentz 408857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40896ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 40906ed58ec5SVille Tervo 40916ed58ec5SVille Tervo cnt--; 409273d80debSLuiz Augusto von Dentz chan->sent++; 409373d80debSLuiz Augusto von Dentz chan->conn->sent++; 40946ed58ec5SVille Tervo } 40956ed58ec5SVille Tervo } 409673d80debSLuiz Augusto von Dentz 40976ed58ec5SVille Tervo if (hdev->le_pkts) 40986ed58ec5SVille Tervo hdev->le_cnt = cnt; 40996ed58ec5SVille Tervo else 41006ed58ec5SVille Tervo hdev->acl_cnt = cnt; 410102b20f0bSLuiz Augusto von Dentz 410202b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 410302b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 41046ed58ec5SVille Tervo } 41056ed58ec5SVille Tervo 41063eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 41071da177e4SLinus Torvalds { 41083eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 41091da177e4SLinus Torvalds struct sk_buff *skb; 41101da177e4SLinus Torvalds 41116ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 41126ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 41131da177e4SLinus Torvalds 411452de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 41151da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 41161da177e4SLinus Torvalds hci_sched_acl(hdev); 41171da177e4SLinus Torvalds hci_sched_sco(hdev); 4118b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 41196ed58ec5SVille Tervo hci_sched_le(hdev); 412052de599eSMarcel Holtmann } 41216ed58ec5SVille Tervo 41221da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 41231da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 412457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 41251da177e4SLinus Torvalds } 41261da177e4SLinus Torvalds 412725985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 41281da177e4SLinus Torvalds 41291da177e4SLinus Torvalds /* ACL data packet */ 41306039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 41311da177e4SLinus Torvalds { 41321da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 41331da177e4SLinus Torvalds struct hci_conn *conn; 41341da177e4SLinus Torvalds __u16 handle, flags; 41351da177e4SLinus Torvalds 41361da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 41371da177e4SLinus Torvalds 41381da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 41391da177e4SLinus Torvalds flags = hci_flags(handle); 41401da177e4SLinus Torvalds handle = hci_handle(handle); 41411da177e4SLinus Torvalds 4142f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4143a8c5fb1aSGustavo Padovan handle, flags); 41441da177e4SLinus Torvalds 41451da177e4SLinus Torvalds hdev->stat.acl_rx++; 41461da177e4SLinus Torvalds 41471da177e4SLinus Torvalds hci_dev_lock(hdev); 41481da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 41491da177e4SLinus Torvalds hci_dev_unlock(hdev); 41501da177e4SLinus Torvalds 41511da177e4SLinus Torvalds if (conn) { 415265983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 415304837f64SMarcel Holtmann 41541da177e4SLinus Torvalds /* Send to upper protocol */ 4155686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 41561da177e4SLinus Torvalds return; 41571da177e4SLinus Torvalds } else { 41581da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 41591da177e4SLinus Torvalds hdev->name, handle); 41601da177e4SLinus Torvalds } 41611da177e4SLinus Torvalds 41621da177e4SLinus Torvalds kfree_skb(skb); 41631da177e4SLinus Torvalds } 41641da177e4SLinus Torvalds 41651da177e4SLinus Torvalds /* SCO data packet */ 41666039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 41671da177e4SLinus Torvalds { 41681da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 41691da177e4SLinus Torvalds struct hci_conn *conn; 41701da177e4SLinus Torvalds __u16 handle; 41711da177e4SLinus Torvalds 41721da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 41731da177e4SLinus Torvalds 41741da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 41751da177e4SLinus Torvalds 4176f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 41771da177e4SLinus Torvalds 41781da177e4SLinus Torvalds hdev->stat.sco_rx++; 41791da177e4SLinus Torvalds 41801da177e4SLinus Torvalds hci_dev_lock(hdev); 41811da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 41821da177e4SLinus Torvalds hci_dev_unlock(hdev); 41831da177e4SLinus Torvalds 41841da177e4SLinus Torvalds if (conn) { 41851da177e4SLinus Torvalds /* Send to upper protocol */ 4186686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 41871da177e4SLinus Torvalds return; 41881da177e4SLinus Torvalds } else { 41891da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 41901da177e4SLinus Torvalds hdev->name, handle); 41911da177e4SLinus Torvalds } 41921da177e4SLinus Torvalds 41931da177e4SLinus Torvalds kfree_skb(skb); 41941da177e4SLinus Torvalds } 41951da177e4SLinus Torvalds 41969238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 41979238f36aSJohan Hedberg { 41989238f36aSJohan Hedberg struct sk_buff *skb; 41999238f36aSJohan Hedberg 42009238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 42019238f36aSJohan Hedberg if (!skb) 42029238f36aSJohan Hedberg return true; 42039238f36aSJohan Hedberg 42049238f36aSJohan Hedberg return bt_cb(skb)->req.start; 42059238f36aSJohan Hedberg } 42069238f36aSJohan Hedberg 420742c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 420842c6b129SJohan Hedberg { 420942c6b129SJohan Hedberg struct hci_command_hdr *sent; 421042c6b129SJohan Hedberg struct sk_buff *skb; 421142c6b129SJohan Hedberg u16 opcode; 421242c6b129SJohan Hedberg 421342c6b129SJohan Hedberg if (!hdev->sent_cmd) 421442c6b129SJohan Hedberg return; 421542c6b129SJohan Hedberg 421642c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 421742c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 421842c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 421942c6b129SJohan Hedberg return; 422042c6b129SJohan Hedberg 422142c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 422242c6b129SJohan Hedberg if (!skb) 422342c6b129SJohan Hedberg return; 422442c6b129SJohan Hedberg 422542c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 422642c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 422742c6b129SJohan Hedberg } 422842c6b129SJohan Hedberg 42299238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 42309238f36aSJohan Hedberg { 42319238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 42329238f36aSJohan Hedberg struct sk_buff *skb; 42339238f36aSJohan Hedberg unsigned long flags; 42349238f36aSJohan Hedberg 42359238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 42369238f36aSJohan Hedberg 423742c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 423842c6b129SJohan Hedberg * sent we need to do special handling of it. 42399238f36aSJohan Hedberg */ 424042c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 424142c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 424242c6b129SJohan Hedberg * reset complete event during init and any pending 424342c6b129SJohan Hedberg * command will never be completed. In such a case we 424442c6b129SJohan Hedberg * need to resend whatever was the last sent 424542c6b129SJohan Hedberg * command. 424642c6b129SJohan Hedberg */ 424742c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 424842c6b129SJohan Hedberg hci_resend_last(hdev); 424942c6b129SJohan Hedberg 42509238f36aSJohan Hedberg return; 425142c6b129SJohan Hedberg } 42529238f36aSJohan Hedberg 42539238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 42549238f36aSJohan Hedberg * this request the request is not yet complete. 42559238f36aSJohan Hedberg */ 42569238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 42579238f36aSJohan Hedberg return; 42589238f36aSJohan Hedberg 42599238f36aSJohan Hedberg /* If this was the last command in a request the complete 42609238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 42619238f36aSJohan Hedberg * command queue (hdev->cmd_q). 42629238f36aSJohan Hedberg */ 42639238f36aSJohan Hedberg if (hdev->sent_cmd) { 42649238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 426553e21fbcSJohan Hedberg 426653e21fbcSJohan Hedberg if (req_complete) { 426753e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 426853e21fbcSJohan Hedberg * avoid calling the callback more than once if 426953e21fbcSJohan Hedberg * this function gets called again. 427053e21fbcSJohan Hedberg */ 427153e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 427253e21fbcSJohan Hedberg 42739238f36aSJohan Hedberg goto call_complete; 42749238f36aSJohan Hedberg } 427553e21fbcSJohan Hedberg } 42769238f36aSJohan Hedberg 42779238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 42789238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 42799238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 42809238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 42819238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 42829238f36aSJohan Hedberg break; 42839238f36aSJohan Hedberg } 42849238f36aSJohan Hedberg 42859238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 42869238f36aSJohan Hedberg kfree_skb(skb); 42879238f36aSJohan Hedberg } 42889238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 42899238f36aSJohan Hedberg 42909238f36aSJohan Hedberg call_complete: 42919238f36aSJohan Hedberg if (req_complete) 42921904a853SMarcel Holtmann req_complete(hdev, status, status ? opcode : HCI_OP_NOP); 42939238f36aSJohan Hedberg } 42949238f36aSJohan Hedberg 4295b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 42961da177e4SLinus Torvalds { 4297b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 42981da177e4SLinus Torvalds struct sk_buff *skb; 42991da177e4SLinus Torvalds 43001da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 43011da177e4SLinus Torvalds 43021da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4303cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4304cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4305cd82e61cSMarcel Holtmann 43061da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 43071da177e4SLinus Torvalds /* Send copy to the sockets */ 4308470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 43091da177e4SLinus Torvalds } 43101da177e4SLinus Torvalds 4311fee746b0SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 43121da177e4SLinus Torvalds kfree_skb(skb); 43131da177e4SLinus Torvalds continue; 43141da177e4SLinus Torvalds } 43151da177e4SLinus Torvalds 43161da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 43171da177e4SLinus Torvalds /* Don't process data packets in this states. */ 43180d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 43191da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 43201da177e4SLinus Torvalds case HCI_SCODATA_PKT: 43211da177e4SLinus Torvalds kfree_skb(skb); 43221da177e4SLinus Torvalds continue; 43233ff50b79SStephen Hemminger } 43241da177e4SLinus Torvalds } 43251da177e4SLinus Torvalds 43261da177e4SLinus Torvalds /* Process frame */ 43270d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 43281da177e4SLinus Torvalds case HCI_EVENT_PKT: 4329b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 43301da177e4SLinus Torvalds hci_event_packet(hdev, skb); 43311da177e4SLinus Torvalds break; 43321da177e4SLinus Torvalds 43331da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 43341da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 43351da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 43361da177e4SLinus Torvalds break; 43371da177e4SLinus Torvalds 43381da177e4SLinus Torvalds case HCI_SCODATA_PKT: 43391da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 43401da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 43411da177e4SLinus Torvalds break; 43421da177e4SLinus Torvalds 43431da177e4SLinus Torvalds default: 43441da177e4SLinus Torvalds kfree_skb(skb); 43451da177e4SLinus Torvalds break; 43461da177e4SLinus Torvalds } 43471da177e4SLinus Torvalds } 43481da177e4SLinus Torvalds } 43491da177e4SLinus Torvalds 4350c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 43511da177e4SLinus Torvalds { 4352c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 43531da177e4SLinus Torvalds struct sk_buff *skb; 43541da177e4SLinus Torvalds 43552104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 43562104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 43571da177e4SLinus Torvalds 43581da177e4SLinus Torvalds /* Send queued commands */ 43595a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 43605a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 43615a08ecceSAndrei Emeltchenko if (!skb) 43625a08ecceSAndrei Emeltchenko return; 43635a08ecceSAndrei Emeltchenko 43641da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 43651da177e4SLinus Torvalds 4366a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 436770f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 43681da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 436957d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 43707bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 437165cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 43727bdb8a5cSSzymon Janc else 437365cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 437465cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 43751da177e4SLinus Torvalds } else { 43761da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4377c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 43781da177e4SLinus Torvalds } 43791da177e4SLinus Torvalds } 43801da177e4SLinus Torvalds } 4381