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 159478c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 159578c04c0bSVinicius Costa Gomes 15961da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 15971da177e4SLinus Torvalds hci_req_lock(hdev); 15981da177e4SLinus Torvalds 15991da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 160065cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 16011da177e4SLinus Torvalds hci_req_unlock(hdev); 16021da177e4SLinus Torvalds return 0; 16031da177e4SLinus Torvalds } 16041da177e4SLinus Torvalds 16053eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 16063eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1607b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 16081da177e4SLinus Torvalds 160916ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 1610e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 161116ab91abSJohan Hedberg hdev->discov_timeout = 0; 16125e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 1613310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 161416ab91abSJohan Hedberg } 161516ab91abSJohan Hedberg 1616a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 16177d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 16187d78525dSJohan Hedberg 16197ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 16202d28cfe7SJakub Pawlowski cancel_delayed_work_sync(&hdev->le_scan_restart); 16214518bb0fSJohan Hedberg 16224518bb0fSJohan Hedberg if (test_bit(HCI_MGMT, &hdev->dev_flags)) 1623d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 16247ba8b4beSAndre Guedes 162576727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 162676727c02SJohan Hedberg * ensuring the workqueue is empty up front. 162776727c02SJohan Hedberg */ 162876727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 162976727c02SJohan Hedberg 163009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 16311aeb9c65SJohan Hedberg 16328f502f84SJohan Hedberg hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 16338f502f84SJohan Hedberg 16341aeb9c65SJohan Hedberg if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 16351aeb9c65SJohan Hedberg if (hdev->dev_type == HCI_BREDR) 16361aeb9c65SJohan Hedberg mgmt_powered(hdev, 0); 16371aeb9c65SJohan Hedberg } 16381aeb9c65SJohan Hedberg 16391f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 1640d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 1641f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 164209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 16431da177e4SLinus Torvalds 164464dae967SMarcel Holtmann smp_unregister(hdev); 164564dae967SMarcel Holtmann 16461da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 16471da177e4SLinus Torvalds 16481da177e4SLinus Torvalds if (hdev->flush) 16491da177e4SLinus Torvalds hdev->flush(hdev); 16501da177e4SLinus Torvalds 16511da177e4SLinus Torvalds /* Reset device */ 16521da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16531da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 16544a964404SMarcel Holtmann if (!test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 16554a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 1656a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 16571da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 165801178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 16591da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 16601da177e4SLinus Torvalds } 16611da177e4SLinus Torvalds 1662c347b765SGustavo F. Padovan /* flush cmd work */ 1663c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 16641da177e4SLinus Torvalds 16651da177e4SLinus Torvalds /* Drop queues */ 16661da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 16671da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16681da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 16691da177e4SLinus Torvalds 16701da177e4SLinus Torvalds /* Drop last sent command */ 16711da177e4SLinus Torvalds if (hdev->sent_cmd) { 167265cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 16731da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 16741da177e4SLinus Torvalds hdev->sent_cmd = NULL; 16751da177e4SLinus Torvalds } 16761da177e4SLinus Torvalds 1677b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 1678b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 1679b6ddb638SJohan Hedberg 16801da177e4SLinus Torvalds /* After this point our queues are empty 16811da177e4SLinus Torvalds * and no tasks are scheduled. */ 16821da177e4SLinus Torvalds hdev->close(hdev); 16831da177e4SLinus Torvalds 168435b973c9SJohan Hedberg /* Clear flags */ 1685fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 168635b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 168735b973c9SJohan Hedberg 1688ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1689536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1690ced5c338SAndrei Emeltchenko 1691e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 169209b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 16937a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 1694e59fda8dSJohan Hedberg 16951da177e4SLinus Torvalds hci_req_unlock(hdev); 16961da177e4SLinus Torvalds 16971da177e4SLinus Torvalds hci_dev_put(hdev); 16981da177e4SLinus Torvalds return 0; 16991da177e4SLinus Torvalds } 17001da177e4SLinus Torvalds 17011da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 17021da177e4SLinus Torvalds { 17031da177e4SLinus Torvalds struct hci_dev *hdev; 17041da177e4SLinus Torvalds int err; 17051da177e4SLinus Torvalds 170670f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 170770f23020SAndrei Emeltchenko if (!hdev) 17081da177e4SLinus Torvalds return -ENODEV; 17098ee56540SMarcel Holtmann 17100736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 17110736cfa8SMarcel Holtmann err = -EBUSY; 17120736cfa8SMarcel Holtmann goto done; 17130736cfa8SMarcel Holtmann } 17140736cfa8SMarcel Holtmann 17158ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 17168ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 17178ee56540SMarcel Holtmann 17181da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 17198ee56540SMarcel Holtmann 17200736cfa8SMarcel Holtmann done: 17211da177e4SLinus Torvalds hci_dev_put(hdev); 17221da177e4SLinus Torvalds return err; 17231da177e4SLinus Torvalds } 17241da177e4SLinus Torvalds 17255c912495SMarcel Holtmann static int hci_dev_do_reset(struct hci_dev *hdev) 17261da177e4SLinus Torvalds { 17275c912495SMarcel Holtmann int ret; 17281da177e4SLinus Torvalds 17295c912495SMarcel Holtmann BT_DBG("%s %p", hdev->name, hdev); 17301da177e4SLinus Torvalds 17311da177e4SLinus Torvalds hci_req_lock(hdev); 17321da177e4SLinus Torvalds 17331da177e4SLinus Torvalds /* Drop queues */ 17341da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 17351da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17361da177e4SLinus Torvalds 173776727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 173876727c02SJohan Hedberg * ensuring the workqueue is empty up front. 173976727c02SJohan Hedberg */ 174076727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 174176727c02SJohan Hedberg 174209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17431f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 17441da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 174509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17461da177e4SLinus Torvalds 17471da177e4SLinus Torvalds if (hdev->flush) 17481da177e4SLinus Torvalds hdev->flush(hdev); 17491da177e4SLinus Torvalds 17501da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 17516ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 17521da177e4SLinus Torvalds 175301178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 17541da177e4SLinus Torvalds 17551da177e4SLinus Torvalds hci_req_unlock(hdev); 17561da177e4SLinus Torvalds return ret; 17571da177e4SLinus Torvalds } 17581da177e4SLinus Torvalds 17595c912495SMarcel Holtmann int hci_dev_reset(__u16 dev) 17605c912495SMarcel Holtmann { 17615c912495SMarcel Holtmann struct hci_dev *hdev; 17625c912495SMarcel Holtmann int err; 17635c912495SMarcel Holtmann 17645c912495SMarcel Holtmann hdev = hci_dev_get(dev); 17655c912495SMarcel Holtmann if (!hdev) 17665c912495SMarcel Holtmann return -ENODEV; 17675c912495SMarcel Holtmann 17685c912495SMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 17695c912495SMarcel Holtmann err = -ENETDOWN; 17705c912495SMarcel Holtmann goto done; 17715c912495SMarcel Holtmann } 17725c912495SMarcel Holtmann 17735c912495SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 17745c912495SMarcel Holtmann err = -EBUSY; 17755c912495SMarcel Holtmann goto done; 17765c912495SMarcel Holtmann } 17775c912495SMarcel Holtmann 17785c912495SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 17795c912495SMarcel Holtmann err = -EOPNOTSUPP; 17805c912495SMarcel Holtmann goto done; 17815c912495SMarcel Holtmann } 17825c912495SMarcel Holtmann 17835c912495SMarcel Holtmann err = hci_dev_do_reset(hdev); 17845c912495SMarcel Holtmann 17855c912495SMarcel Holtmann done: 17865c912495SMarcel Holtmann hci_dev_put(hdev); 17875c912495SMarcel Holtmann return err; 17885c912495SMarcel Holtmann } 17895c912495SMarcel Holtmann 17901da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 17911da177e4SLinus Torvalds { 17921da177e4SLinus Torvalds struct hci_dev *hdev; 17931da177e4SLinus Torvalds int ret = 0; 17941da177e4SLinus Torvalds 179570f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 179670f23020SAndrei Emeltchenko if (!hdev) 17971da177e4SLinus Torvalds return -ENODEV; 17981da177e4SLinus Torvalds 17990736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 18000736cfa8SMarcel Holtmann ret = -EBUSY; 18010736cfa8SMarcel Holtmann goto done; 18020736cfa8SMarcel Holtmann } 18030736cfa8SMarcel Holtmann 18044a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 1805fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 1806fee746b0SMarcel Holtmann goto done; 1807fee746b0SMarcel Holtmann } 1808fee746b0SMarcel Holtmann 18091da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 18101da177e4SLinus Torvalds 18110736cfa8SMarcel Holtmann done: 18121da177e4SLinus Torvalds hci_dev_put(hdev); 18131da177e4SLinus Torvalds return ret; 18141da177e4SLinus Torvalds } 18151da177e4SLinus Torvalds 1816123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 1817123abc08SJohan Hedberg { 1818bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 1819123abc08SJohan Hedberg 1820123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 1821123abc08SJohan Hedberg 1822123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 1823123abc08SJohan Hedberg conn_changed = !test_and_set_bit(HCI_CONNECTABLE, 1824123abc08SJohan Hedberg &hdev->dev_flags); 1825123abc08SJohan Hedberg else 1826123abc08SJohan Hedberg conn_changed = test_and_clear_bit(HCI_CONNECTABLE, 1827123abc08SJohan Hedberg &hdev->dev_flags); 1828123abc08SJohan Hedberg 1829bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 1830bc6d2d04SJohan Hedberg discov_changed = !test_and_set_bit(HCI_DISCOVERABLE, 1831bc6d2d04SJohan Hedberg &hdev->dev_flags); 1832bc6d2d04SJohan Hedberg } else { 1833bc6d2d04SJohan Hedberg clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 1834bc6d2d04SJohan Hedberg discov_changed = test_and_clear_bit(HCI_DISCOVERABLE, 1835bc6d2d04SJohan Hedberg &hdev->dev_flags); 1836bc6d2d04SJohan Hedberg } 1837bc6d2d04SJohan Hedberg 1838123abc08SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 1839123abc08SJohan Hedberg return; 1840123abc08SJohan Hedberg 1841bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 1842bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 1843bc6d2d04SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 1844bc6d2d04SJohan Hedberg 1845bc6d2d04SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 1846bc6d2d04SJohan Hedberg mgmt_update_adv_data(hdev); 1847bc6d2d04SJohan Hedberg 1848123abc08SJohan Hedberg mgmt_new_settings(hdev); 1849123abc08SJohan Hedberg } 1850bc6d2d04SJohan Hedberg } 1851123abc08SJohan Hedberg 18521da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 18531da177e4SLinus Torvalds { 18541da177e4SLinus Torvalds struct hci_dev *hdev; 18551da177e4SLinus Torvalds struct hci_dev_req dr; 18561da177e4SLinus Torvalds int err = 0; 18571da177e4SLinus Torvalds 18581da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 18591da177e4SLinus Torvalds return -EFAULT; 18601da177e4SLinus Torvalds 186170f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 186270f23020SAndrei Emeltchenko if (!hdev) 18631da177e4SLinus Torvalds return -ENODEV; 18641da177e4SLinus Torvalds 18650736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 18660736cfa8SMarcel Holtmann err = -EBUSY; 18670736cfa8SMarcel Holtmann goto done; 18680736cfa8SMarcel Holtmann } 18690736cfa8SMarcel Holtmann 18704a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 1871fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1872fee746b0SMarcel Holtmann goto done; 1873fee746b0SMarcel Holtmann } 1874fee746b0SMarcel Holtmann 18755b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 18765b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 18775b69bef5SMarcel Holtmann goto done; 18785b69bef5SMarcel Holtmann } 18795b69bef5SMarcel Holtmann 188056f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 188156f87901SJohan Hedberg err = -EOPNOTSUPP; 188256f87901SJohan Hedberg goto done; 188356f87901SJohan Hedberg } 188456f87901SJohan Hedberg 18851da177e4SLinus Torvalds switch (cmd) { 18861da177e4SLinus Torvalds case HCISETAUTH: 188701178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 18885f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 18891da177e4SLinus Torvalds break; 18901da177e4SLinus Torvalds 18911da177e4SLinus Torvalds case HCISETENCRYPT: 18921da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 18931da177e4SLinus Torvalds err = -EOPNOTSUPP; 18941da177e4SLinus Torvalds break; 18951da177e4SLinus Torvalds } 18961da177e4SLinus Torvalds 18971da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 18981da177e4SLinus Torvalds /* Auth must be enabled first */ 189901178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 19005f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19011da177e4SLinus Torvalds if (err) 19021da177e4SLinus Torvalds break; 19031da177e4SLinus Torvalds } 19041da177e4SLinus Torvalds 190501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 19065f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19071da177e4SLinus Torvalds break; 19081da177e4SLinus Torvalds 19091da177e4SLinus Torvalds case HCISETSCAN: 191001178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 19115f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 191291a668b0SJohan Hedberg 1913bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 1914bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 191591a668b0SJohan Hedberg */ 1916123abc08SJohan Hedberg if (!err) 1917123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 19181da177e4SLinus Torvalds break; 19191da177e4SLinus Torvalds 19201da177e4SLinus Torvalds case HCISETLINKPOL: 192101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 19225f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19231da177e4SLinus Torvalds break; 19241da177e4SLinus Torvalds 19251da177e4SLinus Torvalds case HCISETLINKMODE: 1926e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 1927e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 1928e4e8e37cSMarcel Holtmann break; 1929e4e8e37cSMarcel Holtmann 1930e4e8e37cSMarcel Holtmann case HCISETPTYPE: 1931e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 19321da177e4SLinus Torvalds break; 19331da177e4SLinus Torvalds 19341da177e4SLinus Torvalds case HCISETACLMTU: 19351da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 19361da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 19371da177e4SLinus Torvalds break; 19381da177e4SLinus Torvalds 19391da177e4SLinus Torvalds case HCISETSCOMTU: 19401da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 19411da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 19421da177e4SLinus Torvalds break; 19431da177e4SLinus Torvalds 19441da177e4SLinus Torvalds default: 19451da177e4SLinus Torvalds err = -EINVAL; 19461da177e4SLinus Torvalds break; 19471da177e4SLinus Torvalds } 1948e4e8e37cSMarcel Holtmann 19490736cfa8SMarcel Holtmann done: 19501da177e4SLinus Torvalds hci_dev_put(hdev); 19511da177e4SLinus Torvalds return err; 19521da177e4SLinus Torvalds } 19531da177e4SLinus Torvalds 19541da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 19551da177e4SLinus Torvalds { 19568035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 19571da177e4SLinus Torvalds struct hci_dev_list_req *dl; 19581da177e4SLinus Torvalds struct hci_dev_req *dr; 19591da177e4SLinus Torvalds int n = 0, size, err; 19601da177e4SLinus Torvalds __u16 dev_num; 19611da177e4SLinus Torvalds 19621da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 19631da177e4SLinus Torvalds return -EFAULT; 19641da177e4SLinus Torvalds 19651da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 19661da177e4SLinus Torvalds return -EINVAL; 19671da177e4SLinus Torvalds 19681da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 19691da177e4SLinus Torvalds 197070f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 197170f23020SAndrei Emeltchenko if (!dl) 19721da177e4SLinus Torvalds return -ENOMEM; 19731da177e4SLinus Torvalds 19741da177e4SLinus Torvalds dr = dl->dev_req; 19751da177e4SLinus Torvalds 1976f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 19778035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 19782e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 1979c542a06cSJohan Hedberg 19802e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 19812e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 19822e84d8dbSMarcel Holtmann * device is actually down. 19832e84d8dbSMarcel Holtmann */ 19842e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 19852e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 1986c542a06cSJohan Hedberg 19871da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 19882e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 1989c542a06cSJohan Hedberg 19901da177e4SLinus Torvalds if (++n >= dev_num) 19911da177e4SLinus Torvalds break; 19921da177e4SLinus Torvalds } 1993f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 19941da177e4SLinus Torvalds 19951da177e4SLinus Torvalds dl->dev_num = n; 19961da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 19971da177e4SLinus Torvalds 19981da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 19991da177e4SLinus Torvalds kfree(dl); 20001da177e4SLinus Torvalds 20011da177e4SLinus Torvalds return err ? -EFAULT : 0; 20021da177e4SLinus Torvalds } 20031da177e4SLinus Torvalds 20041da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 20051da177e4SLinus Torvalds { 20061da177e4SLinus Torvalds struct hci_dev *hdev; 20071da177e4SLinus Torvalds struct hci_dev_info di; 20082e84d8dbSMarcel Holtmann unsigned long flags; 20091da177e4SLinus Torvalds int err = 0; 20101da177e4SLinus Torvalds 20111da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 20121da177e4SLinus Torvalds return -EFAULT; 20131da177e4SLinus Torvalds 201470f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 201570f23020SAndrei Emeltchenko if (!hdev) 20161da177e4SLinus Torvalds return -ENODEV; 20171da177e4SLinus Torvalds 20182e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 20192e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 20202e84d8dbSMarcel Holtmann * device is actually down. 20212e84d8dbSMarcel Holtmann */ 20222e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 20232e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 20242e84d8dbSMarcel Holtmann else 20252e84d8dbSMarcel Holtmann flags = hdev->flags; 2026c542a06cSJohan Hedberg 20271da177e4SLinus Torvalds strcpy(di.name, hdev->name); 20281da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 202960f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 20302e84d8dbSMarcel Holtmann di.flags = flags; 20311da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2032572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 20331da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 20341da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 20351da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 20361da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2037572c7f84SJohan Hedberg } else { 2038572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2039572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2040572c7f84SJohan Hedberg di.sco_mtu = 0; 2041572c7f84SJohan Hedberg di.sco_pkts = 0; 2042572c7f84SJohan Hedberg } 20431da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 20441da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 20451da177e4SLinus Torvalds 20461da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 20471da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 20481da177e4SLinus Torvalds 20491da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 20501da177e4SLinus Torvalds err = -EFAULT; 20511da177e4SLinus Torvalds 20521da177e4SLinus Torvalds hci_dev_put(hdev); 20531da177e4SLinus Torvalds 20541da177e4SLinus Torvalds return err; 20551da177e4SLinus Torvalds } 20561da177e4SLinus Torvalds 20571da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 20581da177e4SLinus Torvalds 2059611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2060611b30f7SMarcel Holtmann { 2061611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2062611b30f7SMarcel Holtmann 2063611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2064611b30f7SMarcel Holtmann 20650736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 20660736cfa8SMarcel Holtmann return -EBUSY; 20670736cfa8SMarcel Holtmann 20685e130367SJohan Hedberg if (blocked) { 20695e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 2070d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2071d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) 2072611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 20735e130367SJohan Hedberg } else { 20745e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 20755e130367SJohan Hedberg } 2076611b30f7SMarcel Holtmann 2077611b30f7SMarcel Holtmann return 0; 2078611b30f7SMarcel Holtmann } 2079611b30f7SMarcel Holtmann 2080611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2081611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2082611b30f7SMarcel Holtmann }; 2083611b30f7SMarcel Holtmann 2084ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2085ab81cbf9SJohan Hedberg { 2086ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 208796570ffcSJohan Hedberg int err; 2088ab81cbf9SJohan Hedberg 2089ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2090ab81cbf9SJohan Hedberg 2091cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 209296570ffcSJohan Hedberg if (err < 0) { 20933ad67582SJaganath Kanakkassery hci_dev_lock(hdev); 209496570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 20953ad67582SJaganath Kanakkassery hci_dev_unlock(hdev); 2096ab81cbf9SJohan Hedberg return; 209796570ffcSJohan Hedberg } 2098ab81cbf9SJohan Hedberg 2099a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2100a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2101a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2102a5c8f270SMarcel Holtmann */ 2103a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 21044a964404SMarcel Holtmann test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) || 2105a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 2106a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2107a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2108bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2109bf543036SJohan Hedberg hci_dev_do_close(hdev); 2110bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 211119202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 211219202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2113bf543036SJohan Hedberg } 2114ab81cbf9SJohan Hedberg 2115fee746b0SMarcel Holtmann if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) { 21164a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 21174a964404SMarcel Holtmann * so that userspace can easily identify them. 21184a964404SMarcel Holtmann */ 21194a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 21204a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 21210602a8adSMarcel Holtmann 21220602a8adSMarcel Holtmann /* For fully configured devices, this will send 21230602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 21240602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 21250602a8adSMarcel Holtmann * 21260602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 21270602a8adSMarcel Holtmann * and no event will be send. 21280602a8adSMarcel Holtmann */ 2129744cf19eSJohan Hedberg mgmt_index_added(hdev); 2130d603b76bSMarcel Holtmann } else if (test_and_clear_bit(HCI_CONFIG, &hdev->dev_flags)) { 21315ea234d3SMarcel Holtmann /* When the controller is now configured, then it 21325ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 21335ea234d3SMarcel Holtmann */ 21345ea234d3SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 21355ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 21365ea234d3SMarcel Holtmann 2137d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2138d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 2139d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 2140d603b76bSMarcel Holtmann */ 2141d603b76bSMarcel Holtmann mgmt_index_added(hdev); 2142ab81cbf9SJohan Hedberg } 2143ab81cbf9SJohan Hedberg } 2144ab81cbf9SJohan Hedberg 2145ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2146ab81cbf9SJohan Hedberg { 21473243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 21483243553fSJohan Hedberg power_off.work); 2149ab81cbf9SJohan Hedberg 2150ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2151ab81cbf9SJohan Hedberg 21528ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2153ab81cbf9SJohan Hedberg } 2154ab81cbf9SJohan Hedberg 2155c7741d16SMarcel Holtmann static void hci_error_reset(struct work_struct *work) 2156c7741d16SMarcel Holtmann { 2157c7741d16SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, error_reset); 2158c7741d16SMarcel Holtmann 2159c7741d16SMarcel Holtmann BT_DBG("%s", hdev->name); 2160c7741d16SMarcel Holtmann 2161c7741d16SMarcel Holtmann if (hdev->hw_error) 2162c7741d16SMarcel Holtmann hdev->hw_error(hdev, hdev->hw_error_code); 2163c7741d16SMarcel Holtmann else 2164c7741d16SMarcel Holtmann BT_ERR("%s hardware error 0x%2.2x", hdev->name, 2165c7741d16SMarcel Holtmann hdev->hw_error_code); 2166c7741d16SMarcel Holtmann 2167c7741d16SMarcel Holtmann if (hci_dev_do_close(hdev)) 2168c7741d16SMarcel Holtmann return; 2169c7741d16SMarcel Holtmann 2170c7741d16SMarcel Holtmann hci_dev_do_open(hdev); 2171c7741d16SMarcel Holtmann } 2172c7741d16SMarcel Holtmann 217316ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 217416ab91abSJohan Hedberg { 217516ab91abSJohan Hedberg struct hci_dev *hdev; 217616ab91abSJohan Hedberg 217716ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 217816ab91abSJohan Hedberg 217916ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 218016ab91abSJohan Hedberg 2181d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 218216ab91abSJohan Hedberg } 218316ab91abSJohan Hedberg 218435f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 21852aeb9a1aSJohan Hedberg { 21864821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 21872aeb9a1aSJohan Hedberg 21884821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 21894821002cSJohan Hedberg list_del(&uuid->list); 21902aeb9a1aSJohan Hedberg kfree(uuid); 21912aeb9a1aSJohan Hedberg } 21922aeb9a1aSJohan Hedberg } 21932aeb9a1aSJohan Hedberg 219435f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 219555ed8ca1SJohan Hedberg { 219655ed8ca1SJohan Hedberg struct link_key *key; 219755ed8ca1SJohan Hedberg 21980378b597SJohan Hedberg list_for_each_entry_rcu(key, &hdev->link_keys, list) { 21990378b597SJohan Hedberg list_del_rcu(&key->list); 22000378b597SJohan Hedberg kfree_rcu(key, rcu); 220155ed8ca1SJohan Hedberg } 220255ed8ca1SJohan Hedberg } 220355ed8ca1SJohan Hedberg 220435f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 2205b899efafSVinicius Costa Gomes { 2206970d0f1bSJohan Hedberg struct smp_ltk *k; 2207b899efafSVinicius Costa Gomes 2208970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2209970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2210970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2211b899efafSVinicius Costa Gomes } 2212b899efafSVinicius Costa Gomes } 2213b899efafSVinicius Costa Gomes 2214970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 2215970c4e46SJohan Hedberg { 2216adae20cbSJohan Hedberg struct smp_irk *k; 2217970c4e46SJohan Hedberg 2218adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2219adae20cbSJohan Hedberg list_del_rcu(&k->list); 2220adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2221970c4e46SJohan Hedberg } 2222970c4e46SJohan Hedberg } 2223970c4e46SJohan Hedberg 222455ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 222555ed8ca1SJohan Hedberg { 222655ed8ca1SJohan Hedberg struct link_key *k; 222755ed8ca1SJohan Hedberg 22280378b597SJohan Hedberg rcu_read_lock(); 22290378b597SJohan Hedberg list_for_each_entry_rcu(k, &hdev->link_keys, list) { 22300378b597SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) { 22310378b597SJohan Hedberg rcu_read_unlock(); 223255ed8ca1SJohan Hedberg return k; 22330378b597SJohan Hedberg } 22340378b597SJohan Hedberg } 22350378b597SJohan Hedberg rcu_read_unlock(); 223655ed8ca1SJohan Hedberg 223755ed8ca1SJohan Hedberg return NULL; 223855ed8ca1SJohan Hedberg } 223955ed8ca1SJohan Hedberg 2240745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2241d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2242d25e28abSJohan Hedberg { 2243d25e28abSJohan Hedberg /* Legacy key */ 2244d25e28abSJohan Hedberg if (key_type < 0x03) 2245745c0ce3SVishal Agarwal return true; 2246d25e28abSJohan Hedberg 2247d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2248d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2249745c0ce3SVishal Agarwal return false; 2250d25e28abSJohan Hedberg 2251d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2252d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2253745c0ce3SVishal Agarwal return false; 2254d25e28abSJohan Hedberg 2255d25e28abSJohan Hedberg /* Security mode 3 case */ 2256d25e28abSJohan Hedberg if (!conn) 2257745c0ce3SVishal Agarwal return true; 2258d25e28abSJohan Hedberg 2259e3befab9SJohan Hedberg /* BR/EDR key derived using SC from an LE link */ 2260e3befab9SJohan Hedberg if (conn->type == LE_LINK) 2261e3befab9SJohan Hedberg return true; 2262e3befab9SJohan Hedberg 2263d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2264d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2265745c0ce3SVishal Agarwal return true; 2266d25e28abSJohan Hedberg 2267d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2268d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2269745c0ce3SVishal Agarwal return true; 2270d25e28abSJohan Hedberg 2271d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2272d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2273745c0ce3SVishal Agarwal return true; 2274d25e28abSJohan Hedberg 2275d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2276d25e28abSJohan Hedberg * persistently */ 2277745c0ce3SVishal Agarwal return false; 2278d25e28abSJohan Hedberg } 2279d25e28abSJohan Hedberg 2280e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 228198a0b845SJohan Hedberg { 2282e804d25dSJohan Hedberg if (type == SMP_LTK) 2283e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 228498a0b845SJohan Hedberg 2285e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 228698a0b845SJohan Hedberg } 228798a0b845SJohan Hedberg 2288f3a73d97SJohan Hedberg struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2289e804d25dSJohan Hedberg u8 addr_type, u8 role) 229075d262c2SVinicius Costa Gomes { 2291c9839a11SVinicius Costa Gomes struct smp_ltk *k; 229275d262c2SVinicius Costa Gomes 2293970d0f1bSJohan Hedberg rcu_read_lock(); 2294970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 22955378bc56SJohan Hedberg if (addr_type != k->bdaddr_type || bacmp(bdaddr, &k->bdaddr)) 22965378bc56SJohan Hedberg continue; 22975378bc56SJohan Hedberg 2298923e2414SJohan Hedberg if (smp_ltk_is_sc(k) || ltk_role(k->type) == role) { 2299970d0f1bSJohan Hedberg rcu_read_unlock(); 230075d262c2SVinicius Costa Gomes return k; 2301970d0f1bSJohan Hedberg } 2302970d0f1bSJohan Hedberg } 2303970d0f1bSJohan Hedberg rcu_read_unlock(); 230475d262c2SVinicius Costa Gomes 230575d262c2SVinicius Costa Gomes return NULL; 230675d262c2SVinicius Costa Gomes } 230775d262c2SVinicius Costa Gomes 2308970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 2309970c4e46SJohan Hedberg { 2310970c4e46SJohan Hedberg struct smp_irk *irk; 2311970c4e46SJohan Hedberg 2312adae20cbSJohan Hedberg rcu_read_lock(); 2313adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2314adae20cbSJohan Hedberg if (!bacmp(&irk->rpa, rpa)) { 2315adae20cbSJohan Hedberg rcu_read_unlock(); 2316970c4e46SJohan Hedberg return irk; 2317970c4e46SJohan Hedberg } 2318adae20cbSJohan Hedberg } 2319970c4e46SJohan Hedberg 2320adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2321defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 2322970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2323adae20cbSJohan Hedberg rcu_read_unlock(); 2324970c4e46SJohan Hedberg return irk; 2325970c4e46SJohan Hedberg } 2326970c4e46SJohan Hedberg } 2327adae20cbSJohan Hedberg rcu_read_unlock(); 2328970c4e46SJohan Hedberg 2329970c4e46SJohan Hedberg return NULL; 2330970c4e46SJohan Hedberg } 2331970c4e46SJohan Hedberg 2332970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2333970c4e46SJohan Hedberg u8 addr_type) 2334970c4e46SJohan Hedberg { 2335970c4e46SJohan Hedberg struct smp_irk *irk; 2336970c4e46SJohan Hedberg 23376cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 23386cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 23396cfc9988SJohan Hedberg return NULL; 23406cfc9988SJohan Hedberg 2341adae20cbSJohan Hedberg rcu_read_lock(); 2342adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2343970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 2344adae20cbSJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) { 2345adae20cbSJohan Hedberg rcu_read_unlock(); 2346970c4e46SJohan Hedberg return irk; 2347970c4e46SJohan Hedberg } 2348adae20cbSJohan Hedberg } 2349adae20cbSJohan Hedberg rcu_read_unlock(); 2350970c4e46SJohan Hedberg 2351970c4e46SJohan Hedberg return NULL; 2352970c4e46SJohan Hedberg } 2353970c4e46SJohan Hedberg 2354567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 23557652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 23567652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 235755ed8ca1SJohan Hedberg { 235855ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2359745c0ce3SVishal Agarwal u8 old_key_type; 236055ed8ca1SJohan Hedberg 236155ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 236255ed8ca1SJohan Hedberg if (old_key) { 236355ed8ca1SJohan Hedberg old_key_type = old_key->type; 236455ed8ca1SJohan Hedberg key = old_key; 236555ed8ca1SJohan Hedberg } else { 236612adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 23670a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 236855ed8ca1SJohan Hedberg if (!key) 2369567fa2aaSJohan Hedberg return NULL; 23700378b597SJohan Hedberg list_add_rcu(&key->list, &hdev->link_keys); 237155ed8ca1SJohan Hedberg } 237255ed8ca1SJohan Hedberg 23736ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 237455ed8ca1SJohan Hedberg 2375d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2376d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2377d25e28abSJohan Hedberg * previous key */ 2378d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2379a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2380d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2381655fe6ecSJohan Hedberg if (conn) 2382655fe6ecSJohan Hedberg conn->key_type = type; 2383655fe6ecSJohan Hedberg } 2384d25e28abSJohan Hedberg 238555ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 23869b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 238755ed8ca1SJohan Hedberg key->pin_len = pin_len; 238855ed8ca1SJohan Hedberg 2389b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 239055ed8ca1SJohan Hedberg key->type = old_key_type; 23914748fed2SJohan Hedberg else 23924748fed2SJohan Hedberg key->type = type; 23934748fed2SJohan Hedberg 23947652ff6aSJohan Hedberg if (persistent) 23957652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 23967652ff6aSJohan Hedberg old_key_type); 23974df378a1SJohan Hedberg 2398567fa2aaSJohan Hedberg return key; 239955ed8ca1SJohan Hedberg } 240055ed8ca1SJohan Hedberg 2401ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 240235d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 2403fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 240475d262c2SVinicius Costa Gomes { 2405c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 2406e804d25dSJohan Hedberg u8 role = ltk_role(type); 240775d262c2SVinicius Costa Gomes 2408f3a73d97SJohan Hedberg old_key = hci_find_ltk(hdev, bdaddr, addr_type, role); 2409c9839a11SVinicius Costa Gomes if (old_key) 241075d262c2SVinicius Costa Gomes key = old_key; 2411c9839a11SVinicius Costa Gomes else { 24120a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 241375d262c2SVinicius Costa Gomes if (!key) 2414ca9142b8SJohan Hedberg return NULL; 2415970d0f1bSJohan Hedberg list_add_rcu(&key->list, &hdev->long_term_keys); 241675d262c2SVinicius Costa Gomes } 241775d262c2SVinicius Costa Gomes 241875d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2419c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2420c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2421c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2422c9839a11SVinicius Costa Gomes key->ediv = ediv; 2423fe39c7b2SMarcel Holtmann key->rand = rand; 2424c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2425c9839a11SVinicius Costa Gomes key->type = type; 242675d262c2SVinicius Costa Gomes 2427ca9142b8SJohan Hedberg return key; 242875d262c2SVinicius Costa Gomes } 242975d262c2SVinicius Costa Gomes 2430ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2431ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 2432970c4e46SJohan Hedberg { 2433970c4e46SJohan Hedberg struct smp_irk *irk; 2434970c4e46SJohan Hedberg 2435970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 2436970c4e46SJohan Hedberg if (!irk) { 2437970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 2438970c4e46SJohan Hedberg if (!irk) 2439ca9142b8SJohan Hedberg return NULL; 2440970c4e46SJohan Hedberg 2441970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 2442970c4e46SJohan Hedberg irk->addr_type = addr_type; 2443970c4e46SJohan Hedberg 2444adae20cbSJohan Hedberg list_add_rcu(&irk->list, &hdev->identity_resolving_keys); 2445970c4e46SJohan Hedberg } 2446970c4e46SJohan Hedberg 2447970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 2448970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2449970c4e46SJohan Hedberg 2450ca9142b8SJohan Hedberg return irk; 2451970c4e46SJohan Hedberg } 2452970c4e46SJohan Hedberg 245355ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 245455ed8ca1SJohan Hedberg { 245555ed8ca1SJohan Hedberg struct link_key *key; 245655ed8ca1SJohan Hedberg 245755ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 245855ed8ca1SJohan Hedberg if (!key) 245955ed8ca1SJohan Hedberg return -ENOENT; 246055ed8ca1SJohan Hedberg 24616ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 246255ed8ca1SJohan Hedberg 24630378b597SJohan Hedberg list_del_rcu(&key->list); 24640378b597SJohan Hedberg kfree_rcu(key, rcu); 246555ed8ca1SJohan Hedberg 246655ed8ca1SJohan Hedberg return 0; 246755ed8ca1SJohan Hedberg } 246855ed8ca1SJohan Hedberg 2469e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 2470b899efafSVinicius Costa Gomes { 2471970d0f1bSJohan Hedberg struct smp_ltk *k; 2472c51ffa0bSJohan Hedberg int removed = 0; 2473b899efafSVinicius Costa Gomes 2474970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2475e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 2476b899efafSVinicius Costa Gomes continue; 2477b899efafSVinicius Costa Gomes 24786ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2479b899efafSVinicius Costa Gomes 2480970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2481970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2482c51ffa0bSJohan Hedberg removed++; 2483b899efafSVinicius Costa Gomes } 2484b899efafSVinicius Costa Gomes 2485c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 2486b899efafSVinicius Costa Gomes } 2487b899efafSVinicius Costa Gomes 2488a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 2489a7ec7338SJohan Hedberg { 2490adae20cbSJohan Hedberg struct smp_irk *k; 2491a7ec7338SJohan Hedberg 2492adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2493a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 2494a7ec7338SJohan Hedberg continue; 2495a7ec7338SJohan Hedberg 2496a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2497a7ec7338SJohan Hedberg 2498adae20cbSJohan Hedberg list_del_rcu(&k->list); 2499adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2500a7ec7338SJohan Hedberg } 2501a7ec7338SJohan Hedberg } 2502a7ec7338SJohan Hedberg 25036bd32326SVille Tervo /* HCI command timer function */ 250465cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 25056bd32326SVille Tervo { 250665cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 250765cc2b49SMarcel Holtmann cmd_timer.work); 25086bd32326SVille Tervo 2509bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2510bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2511bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2512bda4f23aSAndrei Emeltchenko 2513bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 2514bda4f23aSAndrei Emeltchenko } else { 25156bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 2516bda4f23aSAndrei Emeltchenko } 2517bda4f23aSAndrei Emeltchenko 25186bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2519c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 25206bd32326SVille Tervo } 25216bd32326SVille Tervo 25222763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 25236928a924SJohan Hedberg bdaddr_t *bdaddr, u8 bdaddr_type) 25242763eda6SSzymon Janc { 25252763eda6SSzymon Janc struct oob_data *data; 25262763eda6SSzymon Janc 25276928a924SJohan Hedberg list_for_each_entry(data, &hdev->remote_oob_data, list) { 25286928a924SJohan Hedberg if (bacmp(bdaddr, &data->bdaddr) != 0) 25296928a924SJohan Hedberg continue; 25306928a924SJohan Hedberg if (data->bdaddr_type != bdaddr_type) 25316928a924SJohan Hedberg continue; 25322763eda6SSzymon Janc return data; 25336928a924SJohan Hedberg } 25342763eda6SSzymon Janc 25352763eda6SSzymon Janc return NULL; 25362763eda6SSzymon Janc } 25372763eda6SSzymon Janc 25386928a924SJohan Hedberg int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 25396928a924SJohan Hedberg u8 bdaddr_type) 25402763eda6SSzymon Janc { 25412763eda6SSzymon Janc struct oob_data *data; 25422763eda6SSzymon Janc 25436928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 25442763eda6SSzymon Janc if (!data) 25452763eda6SSzymon Janc return -ENOENT; 25462763eda6SSzymon Janc 25476928a924SJohan Hedberg BT_DBG("%s removing %pMR (%u)", hdev->name, bdaddr, bdaddr_type); 25482763eda6SSzymon Janc 25492763eda6SSzymon Janc list_del(&data->list); 25502763eda6SSzymon Janc kfree(data); 25512763eda6SSzymon Janc 25522763eda6SSzymon Janc return 0; 25532763eda6SSzymon Janc } 25542763eda6SSzymon Janc 255535f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 25562763eda6SSzymon Janc { 25572763eda6SSzymon Janc struct oob_data *data, *n; 25582763eda6SSzymon Janc 25592763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 25602763eda6SSzymon Janc list_del(&data->list); 25612763eda6SSzymon Janc kfree(data); 25622763eda6SSzymon Janc } 25632763eda6SSzymon Janc } 25642763eda6SSzymon Janc 25650798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 25666928a924SJohan Hedberg u8 bdaddr_type, u8 *hash192, u8 *rand192, 256738da1703SJohan Hedberg u8 *hash256, u8 *rand256) 25680798872eSMarcel Holtmann { 25690798872eSMarcel Holtmann struct oob_data *data; 25700798872eSMarcel Holtmann 25716928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 25720798872eSMarcel Holtmann if (!data) { 25730a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 25740798872eSMarcel Holtmann if (!data) 25750798872eSMarcel Holtmann return -ENOMEM; 25760798872eSMarcel Holtmann 25770798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 25786928a924SJohan Hedberg data->bdaddr_type = bdaddr_type; 25790798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 25800798872eSMarcel Holtmann } 25810798872eSMarcel Holtmann 258281328d5cSJohan Hedberg if (hash192 && rand192) { 25830798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 258438da1703SJohan Hedberg memcpy(data->rand192, rand192, sizeof(data->rand192)); 2585f7697b16SMarcel Holtmann if (hash256 && rand256) 2586f7697b16SMarcel Holtmann data->present = 0x03; 258781328d5cSJohan Hedberg } else { 258881328d5cSJohan Hedberg memset(data->hash192, 0, sizeof(data->hash192)); 258981328d5cSJohan Hedberg memset(data->rand192, 0, sizeof(data->rand192)); 2590f7697b16SMarcel Holtmann if (hash256 && rand256) 2591f7697b16SMarcel Holtmann data->present = 0x02; 2592f7697b16SMarcel Holtmann else 2593f7697b16SMarcel Holtmann data->present = 0x00; 259481328d5cSJohan Hedberg } 25950798872eSMarcel Holtmann 259681328d5cSJohan Hedberg if (hash256 && rand256) { 25970798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 259838da1703SJohan Hedberg memcpy(data->rand256, rand256, sizeof(data->rand256)); 259981328d5cSJohan Hedberg } else { 260081328d5cSJohan Hedberg memset(data->hash256, 0, sizeof(data->hash256)); 260181328d5cSJohan Hedberg memset(data->rand256, 0, sizeof(data->rand256)); 2602f7697b16SMarcel Holtmann if (hash192 && rand192) 2603f7697b16SMarcel Holtmann data->present = 0x01; 260481328d5cSJohan Hedberg } 26050798872eSMarcel Holtmann 26066ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 26072763eda6SSzymon Janc 26082763eda6SSzymon Janc return 0; 26092763eda6SSzymon Janc } 26102763eda6SSzymon Janc 2611dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 2612b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2613b2a66aadSAntti Julku { 2614b2a66aadSAntti Julku struct bdaddr_list *b; 2615b2a66aadSAntti Julku 2616dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 2617b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2618b2a66aadSAntti Julku return b; 2619b9ee0a78SMarcel Holtmann } 2620b2a66aadSAntti Julku 2621b2a66aadSAntti Julku return NULL; 2622b2a66aadSAntti Julku } 2623b2a66aadSAntti Julku 2624dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 2625b2a66aadSAntti Julku { 2626b2a66aadSAntti Julku struct list_head *p, *n; 2627b2a66aadSAntti Julku 2628dcc36c16SJohan Hedberg list_for_each_safe(p, n, bdaddr_list) { 2629b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 2630b2a66aadSAntti Julku 2631b2a66aadSAntti Julku list_del(p); 2632b2a66aadSAntti Julku kfree(b); 2633b2a66aadSAntti Julku } 2634b2a66aadSAntti Julku } 2635b2a66aadSAntti Julku 2636dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2637b2a66aadSAntti Julku { 2638b2a66aadSAntti Julku struct bdaddr_list *entry; 2639b2a66aadSAntti Julku 2640b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2641b2a66aadSAntti Julku return -EBADF; 2642b2a66aadSAntti Julku 2643dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 26445e762444SAntti Julku return -EEXIST; 2645b2a66aadSAntti Julku 264627f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 26475e762444SAntti Julku if (!entry) 26485e762444SAntti Julku return -ENOMEM; 2649b2a66aadSAntti Julku 2650b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2651b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2652b2a66aadSAntti Julku 2653dcc36c16SJohan Hedberg list_add(&entry->list, list); 2654b2a66aadSAntti Julku 26552a8357f2SJohan Hedberg return 0; 2656b2a66aadSAntti Julku } 2657b2a66aadSAntti Julku 2658dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2659b2a66aadSAntti Julku { 2660b2a66aadSAntti Julku struct bdaddr_list *entry; 2661b2a66aadSAntti Julku 266235f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 2663dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 266435f7498aSJohan Hedberg return 0; 266535f7498aSJohan Hedberg } 2666b2a66aadSAntti Julku 2667dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 2668d2ab0ac1SMarcel Holtmann if (!entry) 2669d2ab0ac1SMarcel Holtmann return -ENOENT; 2670d2ab0ac1SMarcel Holtmann 2671d2ab0ac1SMarcel Holtmann list_del(&entry->list); 2672d2ab0ac1SMarcel Holtmann kfree(entry); 2673d2ab0ac1SMarcel Holtmann 2674d2ab0ac1SMarcel Holtmann return 0; 2675d2ab0ac1SMarcel Holtmann } 2676d2ab0ac1SMarcel Holtmann 267715819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 267815819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 267915819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 268015819a70SAndre Guedes { 268115819a70SAndre Guedes struct hci_conn_params *params; 268215819a70SAndre Guedes 2683738f6185SJohan Hedberg /* The conn params list only contains identity addresses */ 2684738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 2685738f6185SJohan Hedberg return NULL; 2686738f6185SJohan Hedberg 268715819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 268815819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 268915819a70SAndre Guedes params->addr_type == addr_type) { 269015819a70SAndre Guedes return params; 269115819a70SAndre Guedes } 269215819a70SAndre Guedes } 269315819a70SAndre Guedes 269415819a70SAndre Guedes return NULL; 269515819a70SAndre Guedes } 269615819a70SAndre Guedes 269715819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 2698501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 26994b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 270015819a70SAndre Guedes { 2701912b42efSJohan Hedberg struct hci_conn_params *param; 270215819a70SAndre Guedes 2703738f6185SJohan Hedberg /* The list only contains identity addresses */ 2704738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 2705738f6185SJohan Hedberg return NULL; 270615819a70SAndre Guedes 2707501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 2708912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 2709912b42efSJohan Hedberg param->addr_type == addr_type) 2710912b42efSJohan Hedberg return param; 27114b10966fSMarcel Holtmann } 27124b10966fSMarcel Holtmann 27134b10966fSMarcel Holtmann return NULL; 271415819a70SAndre Guedes } 271515819a70SAndre Guedes 271615819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 271751d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 271851d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 271915819a70SAndre Guedes { 272015819a70SAndre Guedes struct hci_conn_params *params; 272115819a70SAndre Guedes 2722c46245b3SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 272351d167c0SMarcel Holtmann return NULL; 2724a9b0a04cSAndre Guedes 272515819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 2726cef952ceSAndre Guedes if (params) 272751d167c0SMarcel Holtmann return params; 272815819a70SAndre Guedes 272915819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 273015819a70SAndre Guedes if (!params) { 273115819a70SAndre Guedes BT_ERR("Out of memory"); 273251d167c0SMarcel Holtmann return NULL; 273315819a70SAndre Guedes } 273415819a70SAndre Guedes 273515819a70SAndre Guedes bacpy(¶ms->addr, addr); 273615819a70SAndre Guedes params->addr_type = addr_type; 2737cef952ceSAndre Guedes 2738cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 273993450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 2740cef952ceSAndre Guedes 2741bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 2742bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 2743bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 2744bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 2745bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 2746bf5b3c8bSMarcel Holtmann 2747bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 2748bf5b3c8bSMarcel Holtmann 274951d167c0SMarcel Holtmann return params; 2750bf5b3c8bSMarcel Holtmann } 2751bf5b3c8bSMarcel Holtmann 2752f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 2753f6c63249SJohan Hedberg { 2754f6c63249SJohan Hedberg if (params->conn) { 2755f6c63249SJohan Hedberg hci_conn_drop(params->conn); 2756f6c63249SJohan Hedberg hci_conn_put(params->conn); 2757f6c63249SJohan Hedberg } 2758f6c63249SJohan Hedberg 2759f6c63249SJohan Hedberg list_del(¶ms->action); 2760f6c63249SJohan Hedberg list_del(¶ms->list); 2761f6c63249SJohan Hedberg kfree(params); 2762f6c63249SJohan Hedberg } 2763f6c63249SJohan Hedberg 276415819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 276515819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 276615819a70SAndre Guedes { 276715819a70SAndre Guedes struct hci_conn_params *params; 276815819a70SAndre Guedes 276915819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 277015819a70SAndre Guedes if (!params) 277115819a70SAndre Guedes return; 277215819a70SAndre Guedes 2773f6c63249SJohan Hedberg hci_conn_params_free(params); 277415819a70SAndre Guedes 277595305baaSJohan Hedberg hci_update_background_scan(hdev); 277695305baaSJohan Hedberg 277715819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 277815819a70SAndre Guedes } 277915819a70SAndre Guedes 278015819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 278155af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 278215819a70SAndre Guedes { 278315819a70SAndre Guedes struct hci_conn_params *params, *tmp; 278415819a70SAndre Guedes 278515819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 278655af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 278755af49a8SJohan Hedberg continue; 278815819a70SAndre Guedes list_del(¶ms->list); 278915819a70SAndre Guedes kfree(params); 279015819a70SAndre Guedes } 279115819a70SAndre Guedes 279255af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 279355af49a8SJohan Hedberg } 279455af49a8SJohan Hedberg 279555af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 2796373110c5SJohan Hedberg void hci_conn_params_clear_all(struct hci_dev *hdev) 279715819a70SAndre Guedes { 279815819a70SAndre Guedes struct hci_conn_params *params, *tmp; 279915819a70SAndre Guedes 2800f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 2801f6c63249SJohan Hedberg hci_conn_params_free(params); 280215819a70SAndre Guedes 2803a2f41a8fSJohan Hedberg hci_update_background_scan(hdev); 28041089b67dSMarcel Holtmann 280515819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 280615819a70SAndre Guedes } 280715819a70SAndre Guedes 28081904a853SMarcel Holtmann static void inquiry_complete(struct hci_dev *hdev, u8 status, u16 opcode) 28097ba8b4beSAndre Guedes { 28104c87eaabSAndre Guedes if (status) { 28114c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 28127ba8b4beSAndre Guedes 28134c87eaabSAndre Guedes hci_dev_lock(hdev); 28144c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 28154c87eaabSAndre Guedes hci_dev_unlock(hdev); 28164c87eaabSAndre Guedes return; 28174c87eaabSAndre Guedes } 28187ba8b4beSAndre Guedes } 28197ba8b4beSAndre Guedes 28201904a853SMarcel Holtmann static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status, 28211904a853SMarcel Holtmann u16 opcode) 28227ba8b4beSAndre Guedes { 28234c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 28244c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 28254c87eaabSAndre Guedes struct hci_request req; 28264c87eaabSAndre Guedes struct hci_cp_inquiry cp; 28277ba8b4beSAndre Guedes int err; 28287ba8b4beSAndre Guedes 28294c87eaabSAndre Guedes if (status) { 28304c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 28314c87eaabSAndre Guedes return; 28327ba8b4beSAndre Guedes } 28337ba8b4beSAndre Guedes 28342d28cfe7SJakub Pawlowski hdev->discovery.scan_start = 0; 28352d28cfe7SJakub Pawlowski 28364c87eaabSAndre Guedes switch (hdev->discovery.type) { 28374c87eaabSAndre Guedes case DISCOV_TYPE_LE: 28384c87eaabSAndre Guedes hci_dev_lock(hdev); 28394c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 28404c87eaabSAndre Guedes hci_dev_unlock(hdev); 28414c87eaabSAndre Guedes break; 28427dbfac1dSAndre Guedes 28434c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 28444c87eaabSAndre Guedes hci_req_init(&req, hdev); 28457dbfac1dSAndre Guedes 28467dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 28474c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 28484c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 28494c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 28504c87eaabSAndre Guedes 28514c87eaabSAndre Guedes hci_dev_lock(hdev); 28524c87eaabSAndre Guedes 28534c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 28544c87eaabSAndre Guedes 28554c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 28564c87eaabSAndre Guedes if (err) { 28574c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 28584c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 28597dbfac1dSAndre Guedes } 28607dbfac1dSAndre Guedes 28614c87eaabSAndre Guedes hci_dev_unlock(hdev); 28624c87eaabSAndre Guedes break; 28634c87eaabSAndre Guedes } 28647dbfac1dSAndre Guedes } 28657dbfac1dSAndre Guedes 28667ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 28677ba8b4beSAndre Guedes { 28687ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 28697ba8b4beSAndre Guedes le_scan_disable.work); 28704c87eaabSAndre Guedes struct hci_request req; 28714c87eaabSAndre Guedes int err; 28727ba8b4beSAndre Guedes 28737ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 28747ba8b4beSAndre Guedes 28752d28cfe7SJakub Pawlowski cancel_delayed_work_sync(&hdev->le_scan_restart); 28762d28cfe7SJakub Pawlowski 28774c87eaabSAndre Guedes hci_req_init(&req, hdev); 28787ba8b4beSAndre Guedes 2879b1efcc28SAndre Guedes hci_req_add_le_scan_disable(&req); 28807ba8b4beSAndre Guedes 28814c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 28824c87eaabSAndre Guedes if (err) 28834c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 288428b75a89SAndre Guedes } 288528b75a89SAndre Guedes 28862d28cfe7SJakub Pawlowski static void le_scan_restart_work_complete(struct hci_dev *hdev, u8 status, 28872d28cfe7SJakub Pawlowski u16 opcode) 28882d28cfe7SJakub Pawlowski { 28892d28cfe7SJakub Pawlowski unsigned long timeout, duration, scan_start, now; 28902d28cfe7SJakub Pawlowski 28912d28cfe7SJakub Pawlowski BT_DBG("%s", hdev->name); 28922d28cfe7SJakub Pawlowski 28932d28cfe7SJakub Pawlowski if (status) { 28942d28cfe7SJakub Pawlowski BT_ERR("Failed to restart LE scan: status %d", status); 28952d28cfe7SJakub Pawlowski return; 28962d28cfe7SJakub Pawlowski } 28972d28cfe7SJakub Pawlowski 28982d28cfe7SJakub Pawlowski if (!test_bit(HCI_QUIRK_STRICT_DUPLICATE_FILTER, &hdev->quirks) || 28992d28cfe7SJakub Pawlowski !hdev->discovery.scan_start) 29002d28cfe7SJakub Pawlowski return; 29012d28cfe7SJakub Pawlowski 29022d28cfe7SJakub Pawlowski /* When the scan was started, hdev->le_scan_disable has been queued 29032d28cfe7SJakub Pawlowski * after duration from scan_start. During scan restart this job 29042d28cfe7SJakub Pawlowski * has been canceled, and we need to queue it again after proper 29052d28cfe7SJakub Pawlowski * timeout, to make sure that scan does not run indefinitely. 29062d28cfe7SJakub Pawlowski */ 29072d28cfe7SJakub Pawlowski duration = hdev->discovery.scan_duration; 29082d28cfe7SJakub Pawlowski scan_start = hdev->discovery.scan_start; 29092d28cfe7SJakub Pawlowski now = jiffies; 29102d28cfe7SJakub Pawlowski if (now - scan_start <= duration) { 29112d28cfe7SJakub Pawlowski int elapsed; 29122d28cfe7SJakub Pawlowski 29132d28cfe7SJakub Pawlowski if (now >= scan_start) 29142d28cfe7SJakub Pawlowski elapsed = now - scan_start; 29152d28cfe7SJakub Pawlowski else 29162d28cfe7SJakub Pawlowski elapsed = ULONG_MAX - scan_start + now; 29172d28cfe7SJakub Pawlowski 29182d28cfe7SJakub Pawlowski timeout = duration - elapsed; 29192d28cfe7SJakub Pawlowski } else { 29202d28cfe7SJakub Pawlowski timeout = 0; 29212d28cfe7SJakub Pawlowski } 29222d28cfe7SJakub Pawlowski queue_delayed_work(hdev->workqueue, 29232d28cfe7SJakub Pawlowski &hdev->le_scan_disable, timeout); 29242d28cfe7SJakub Pawlowski } 29252d28cfe7SJakub Pawlowski 29262d28cfe7SJakub Pawlowski static void le_scan_restart_work(struct work_struct *work) 29272d28cfe7SJakub Pawlowski { 29282d28cfe7SJakub Pawlowski struct hci_dev *hdev = container_of(work, struct hci_dev, 29292d28cfe7SJakub Pawlowski le_scan_restart.work); 29302d28cfe7SJakub Pawlowski struct hci_request req; 29312d28cfe7SJakub Pawlowski struct hci_cp_le_set_scan_enable cp; 29322d28cfe7SJakub Pawlowski int err; 29332d28cfe7SJakub Pawlowski 29342d28cfe7SJakub Pawlowski BT_DBG("%s", hdev->name); 29352d28cfe7SJakub Pawlowski 29362d28cfe7SJakub Pawlowski /* If controller is not scanning we are done. */ 29372d28cfe7SJakub Pawlowski if (!test_bit(HCI_LE_SCAN, &hdev->dev_flags)) 29382d28cfe7SJakub Pawlowski return; 29392d28cfe7SJakub Pawlowski 29402d28cfe7SJakub Pawlowski hci_req_init(&req, hdev); 29412d28cfe7SJakub Pawlowski 29422d28cfe7SJakub Pawlowski hci_req_add_le_scan_disable(&req); 29432d28cfe7SJakub Pawlowski 29442d28cfe7SJakub Pawlowski memset(&cp, 0, sizeof(cp)); 29452d28cfe7SJakub Pawlowski cp.enable = LE_SCAN_ENABLE; 29462d28cfe7SJakub Pawlowski cp.filter_dup = LE_SCAN_FILTER_DUP_ENABLE; 29472d28cfe7SJakub Pawlowski hci_req_add(&req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 29482d28cfe7SJakub Pawlowski 29492d28cfe7SJakub Pawlowski err = hci_req_run(&req, le_scan_restart_work_complete); 29502d28cfe7SJakub Pawlowski if (err) 29512d28cfe7SJakub Pawlowski BT_ERR("Restart LE scan request failed: err %d", err); 29522d28cfe7SJakub Pawlowski } 29532d28cfe7SJakub Pawlowski 2954a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 2955a1f4c318SJohan Hedberg * 2956a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 2957a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 2958a1f4c318SJohan Hedberg * the static random address. 2959a1f4c318SJohan Hedberg * 2960a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 2961a1f4c318SJohan Hedberg * public address to use the static random address instead. 296250b5b952SMarcel Holtmann * 296350b5b952SMarcel Holtmann * In case BR/EDR has been disabled on a dual-mode controller and 296450b5b952SMarcel Holtmann * userspace has configured a static address, then that address 296550b5b952SMarcel Holtmann * becomes the identity address instead of the public BR/EDR address. 2966a1f4c318SJohan Hedberg */ 2967a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 2968a1f4c318SJohan Hedberg u8 *bdaddr_type) 2969a1f4c318SJohan Hedberg { 2970111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 297150b5b952SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) || 297250b5b952SMarcel Holtmann (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags) && 297350b5b952SMarcel Holtmann bacmp(&hdev->static_addr, BDADDR_ANY))) { 2974a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 2975a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 2976a1f4c318SJohan Hedberg } else { 2977a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 2978a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 2979a1f4c318SJohan Hedberg } 2980a1f4c318SJohan Hedberg } 2981a1f4c318SJohan Hedberg 29829be0dab7SDavid Herrmann /* Alloc HCI device */ 29839be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 29849be0dab7SDavid Herrmann { 29859be0dab7SDavid Herrmann struct hci_dev *hdev; 29869be0dab7SDavid Herrmann 298727f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 29889be0dab7SDavid Herrmann if (!hdev) 29899be0dab7SDavid Herrmann return NULL; 29909be0dab7SDavid Herrmann 2991b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 2992b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 2993b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 2994b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 2995b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 299696c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 2997bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 2998bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 2999b1b813d4SDavid Herrmann 3000b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 3001b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 3002b1b813d4SDavid Herrmann 30033f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 3004628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 3005628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 3006bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 3007bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 30084e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 30094e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 301004fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 301104fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 3012a8e1bfaaSMarcel Holtmann hdev->le_def_tx_len = 0x001b; 3013a8e1bfaaSMarcel Holtmann hdev->le_def_tx_time = 0x0148; 3014a8e1bfaaSMarcel Holtmann hdev->le_max_tx_len = 0x001b; 3015a8e1bfaaSMarcel Holtmann hdev->le_max_tx_time = 0x0148; 3016a8e1bfaaSMarcel Holtmann hdev->le_max_rx_len = 0x001b; 3017a8e1bfaaSMarcel Holtmann hdev->le_max_rx_time = 0x0148; 3018bef64738SMarcel Holtmann 3019d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 3020b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 302131ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 302231ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 3023d6bfd59cSJohan Hedberg 3024b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 3025b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 3026b1b813d4SDavid Herrmann 3027b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 3028b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 30296659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 3030b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 3031b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 3032b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 3033970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 3034b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 3035d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 303615819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 303777a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 303866f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 30396b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 3040b1b813d4SDavid Herrmann 3041b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 3042b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 3043b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 3044b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 3045c7741d16SMarcel Holtmann INIT_WORK(&hdev->error_reset, hci_error_reset); 3046b1b813d4SDavid Herrmann 3047b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 3048b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 3049b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 30502d28cfe7SJakub Pawlowski INIT_DELAYED_WORK(&hdev->le_scan_restart, le_scan_restart_work); 3051b1b813d4SDavid Herrmann 3052b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 3053b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 3054b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 3055b1b813d4SDavid Herrmann 3056b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 3057b1b813d4SDavid Herrmann 305865cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 3059b1b813d4SDavid Herrmann 3060b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 3061b1b813d4SDavid Herrmann discovery_init(hdev); 30629be0dab7SDavid Herrmann 30639be0dab7SDavid Herrmann return hdev; 30649be0dab7SDavid Herrmann } 30659be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 30669be0dab7SDavid Herrmann 30679be0dab7SDavid Herrmann /* Free HCI device */ 30689be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 30699be0dab7SDavid Herrmann { 30709be0dab7SDavid Herrmann /* will free via device release */ 30719be0dab7SDavid Herrmann put_device(&hdev->dev); 30729be0dab7SDavid Herrmann } 30739be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 30749be0dab7SDavid Herrmann 30751da177e4SLinus Torvalds /* Register HCI device */ 30761da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 30771da177e4SLinus Torvalds { 3078b1b813d4SDavid Herrmann int id, error; 30791da177e4SLinus Torvalds 308074292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 30811da177e4SLinus Torvalds return -EINVAL; 30821da177e4SLinus Torvalds 308308add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 308408add513SMat Martineau * so the index can be used as the AMP controller ID. 308508add513SMat Martineau */ 30863df92b31SSasha Levin switch (hdev->dev_type) { 30873df92b31SSasha Levin case HCI_BREDR: 30883df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 30891da177e4SLinus Torvalds break; 30903df92b31SSasha Levin case HCI_AMP: 30913df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 30923df92b31SSasha Levin break; 30933df92b31SSasha Levin default: 30943df92b31SSasha Levin return -EINVAL; 30951da177e4SLinus Torvalds } 30961da177e4SLinus Torvalds 30973df92b31SSasha Levin if (id < 0) 30983df92b31SSasha Levin return id; 30993df92b31SSasha Levin 31001da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 31011da177e4SLinus Torvalds hdev->id = id; 31022d8b3a11SAndrei Emeltchenko 31032d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 31042d8b3a11SAndrei Emeltchenko 3105d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3106d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 310733ca954dSDavid Herrmann if (!hdev->workqueue) { 310833ca954dSDavid Herrmann error = -ENOMEM; 310933ca954dSDavid Herrmann goto err; 311033ca954dSDavid Herrmann } 3111f48fd9c8SMarcel Holtmann 3112d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 3113d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 31146ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 31156ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 31166ead1bbcSJohan Hedberg error = -ENOMEM; 31176ead1bbcSJohan Hedberg goto err; 31186ead1bbcSJohan Hedberg } 31196ead1bbcSJohan Hedberg 31200153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 31210153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 31220153e2ecSMarcel Holtmann 3123bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 3124bdc3e0f1SMarcel Holtmann 3125bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 312633ca954dSDavid Herrmann if (error < 0) 312754506918SJohan Hedberg goto err_wqueue; 31281da177e4SLinus Torvalds 3129611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 3130a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 3131a8c5fb1aSGustavo Padovan hdev); 3132611b30f7SMarcel Holtmann if (hdev->rfkill) { 3133611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 3134611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3135611b30f7SMarcel Holtmann hdev->rfkill = NULL; 3136611b30f7SMarcel Holtmann } 3137611b30f7SMarcel Holtmann } 3138611b30f7SMarcel Holtmann 31395e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 31405e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 31415e130367SJohan Hedberg 3142a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 3143004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 3144ce2be9acSAndrei Emeltchenko 314501cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 314656f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 314756f87901SJohan Hedberg * through reading supported features during init. 314856f87901SJohan Hedberg */ 314956f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 315056f87901SJohan Hedberg } 3151ce2be9acSAndrei Emeltchenko 3152fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 3153fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 3154fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3155fcee3377SGustavo Padovan 31564a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 31574a964404SMarcel Holtmann * and should not be included in normal operation. 3158fee746b0SMarcel Holtmann */ 3159fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 31604a964404SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 3161fee746b0SMarcel Holtmann 31621da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 3163dc946bd8SDavid Herrmann hci_dev_hold(hdev); 31641da177e4SLinus Torvalds 316519202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3166fbe96d6fSMarcel Holtmann 31671da177e4SLinus Torvalds return id; 3168f48fd9c8SMarcel Holtmann 316933ca954dSDavid Herrmann err_wqueue: 317033ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 31716ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 317233ca954dSDavid Herrmann err: 31733df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3174f48fd9c8SMarcel Holtmann 317533ca954dSDavid Herrmann return error; 31761da177e4SLinus Torvalds } 31771da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 31781da177e4SLinus Torvalds 31791da177e4SLinus Torvalds /* Unregister HCI device */ 318059735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 31811da177e4SLinus Torvalds { 31823df92b31SSasha Levin int i, id; 3183ef222013SMarcel Holtmann 3184c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 31851da177e4SLinus Torvalds 318694324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 318794324962SJohan Hovold 31883df92b31SSasha Levin id = hdev->id; 31893df92b31SSasha Levin 3190f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 31911da177e4SLinus Torvalds list_del(&hdev->list); 3192f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 31931da177e4SLinus Torvalds 31941da177e4SLinus Torvalds hci_dev_do_close(hdev); 31951da177e4SLinus Torvalds 3196cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 3197ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 3198ef222013SMarcel Holtmann 3199b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3200b9b5ef18SGustavo Padovan 3201ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3202d603b76bSMarcel Holtmann !test_bit(HCI_SETUP, &hdev->dev_flags) && 3203d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 320409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3205744cf19eSJohan Hedberg mgmt_index_removed(hdev); 320609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 320756e5cb86SJohan Hedberg } 3208ab81cbf9SJohan Hedberg 32092e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 32102e58ef3eSJohan Hedberg * pending list */ 32112e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 32122e58ef3eSJohan Hedberg 32131da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 32141da177e4SLinus Torvalds 3215611b30f7SMarcel Holtmann if (hdev->rfkill) { 3216611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3217611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3218611b30f7SMarcel Holtmann } 3219611b30f7SMarcel Holtmann 3220bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 3221147e2d59SDave Young 32220153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 32230153e2ecSMarcel Holtmann 3224f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 32256ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 3226f48fd9c8SMarcel Holtmann 322709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3228dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 32296659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 32302aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 323155ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 3232b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 3233970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 32342763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 3235dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 3236373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 323722078800SMarcel Holtmann hci_discovery_filter_clear(hdev); 323809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 3239e2e0cacbSJohan Hedberg 3240dc946bd8SDavid Herrmann hci_dev_put(hdev); 32413df92b31SSasha Levin 32423df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 32431da177e4SLinus Torvalds } 32441da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 32451da177e4SLinus Torvalds 32461da177e4SLinus Torvalds /* Suspend HCI device */ 32471da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 32481da177e4SLinus Torvalds { 32491da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 32501da177e4SLinus Torvalds return 0; 32511da177e4SLinus Torvalds } 32521da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 32531da177e4SLinus Torvalds 32541da177e4SLinus Torvalds /* Resume HCI device */ 32551da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 32561da177e4SLinus Torvalds { 32571da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 32581da177e4SLinus Torvalds return 0; 32591da177e4SLinus Torvalds } 32601da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 32611da177e4SLinus Torvalds 326275e0569fSMarcel Holtmann /* Reset HCI device */ 326375e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 326475e0569fSMarcel Holtmann { 326575e0569fSMarcel Holtmann const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 326675e0569fSMarcel Holtmann struct sk_buff *skb; 326775e0569fSMarcel Holtmann 326875e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 326975e0569fSMarcel Holtmann if (!skb) 327075e0569fSMarcel Holtmann return -ENOMEM; 327175e0569fSMarcel Holtmann 327275e0569fSMarcel Holtmann bt_cb(skb)->pkt_type = HCI_EVENT_PKT; 327375e0569fSMarcel Holtmann memcpy(skb_put(skb, 3), hw_err, 3); 327475e0569fSMarcel Holtmann 327575e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 327675e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 327775e0569fSMarcel Holtmann } 327875e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 327975e0569fSMarcel Holtmann 328076bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 3281e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 328276bca880SMarcel Holtmann { 328376bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 328476bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 328576bca880SMarcel Holtmann kfree_skb(skb); 328676bca880SMarcel Holtmann return -ENXIO; 328776bca880SMarcel Holtmann } 328876bca880SMarcel Holtmann 3289d82603c6SJorrit Schippers /* Incoming skb */ 329076bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 329176bca880SMarcel Holtmann 329276bca880SMarcel Holtmann /* Time stamp */ 329376bca880SMarcel Holtmann __net_timestamp(skb); 329476bca880SMarcel Holtmann 329576bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3296b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3297c78ae283SMarcel Holtmann 329876bca880SMarcel Holtmann return 0; 329976bca880SMarcel Holtmann } 330076bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 330176bca880SMarcel Holtmann 330233e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 33031e429f38SGustavo F. Padovan int count, __u8 index) 330433e882a5SSuraj Sumangala { 330533e882a5SSuraj Sumangala int len = 0; 330633e882a5SSuraj Sumangala int hlen = 0; 330733e882a5SSuraj Sumangala int remain = count; 330833e882a5SSuraj Sumangala struct sk_buff *skb; 330933e882a5SSuraj Sumangala struct bt_skb_cb *scb; 331033e882a5SSuraj Sumangala 331133e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 331233e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 331333e882a5SSuraj Sumangala return -EILSEQ; 331433e882a5SSuraj Sumangala 331533e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 331633e882a5SSuraj Sumangala 331733e882a5SSuraj Sumangala if (!skb) { 331833e882a5SSuraj Sumangala switch (type) { 331933e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 332033e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 332133e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 332233e882a5SSuraj Sumangala break; 332333e882a5SSuraj Sumangala case HCI_EVENT_PKT: 332433e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 332533e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 332633e882a5SSuraj Sumangala break; 332733e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 332833e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 332933e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 333033e882a5SSuraj Sumangala break; 333133e882a5SSuraj Sumangala } 333233e882a5SSuraj Sumangala 33331e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 333433e882a5SSuraj Sumangala if (!skb) 333533e882a5SSuraj Sumangala return -ENOMEM; 333633e882a5SSuraj Sumangala 333733e882a5SSuraj Sumangala scb = (void *) skb->cb; 333833e882a5SSuraj Sumangala scb->expect = hlen; 333933e882a5SSuraj Sumangala scb->pkt_type = type; 334033e882a5SSuraj Sumangala 334133e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 334233e882a5SSuraj Sumangala } 334333e882a5SSuraj Sumangala 334433e882a5SSuraj Sumangala while (count) { 334533e882a5SSuraj Sumangala scb = (void *) skb->cb; 334689bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 334733e882a5SSuraj Sumangala 334833e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 334933e882a5SSuraj Sumangala 335033e882a5SSuraj Sumangala count -= len; 335133e882a5SSuraj Sumangala data += len; 335233e882a5SSuraj Sumangala scb->expect -= len; 335333e882a5SSuraj Sumangala remain = count; 335433e882a5SSuraj Sumangala 335533e882a5SSuraj Sumangala switch (type) { 335633e882a5SSuraj Sumangala case HCI_EVENT_PKT: 335733e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 335833e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 335933e882a5SSuraj Sumangala scb->expect = h->plen; 336033e882a5SSuraj Sumangala 336133e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 336233e882a5SSuraj Sumangala kfree_skb(skb); 336333e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 336433e882a5SSuraj Sumangala return -ENOMEM; 336533e882a5SSuraj Sumangala } 336633e882a5SSuraj Sumangala } 336733e882a5SSuraj Sumangala break; 336833e882a5SSuraj Sumangala 336933e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 337033e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 337133e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 337233e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 337333e882a5SSuraj Sumangala 337433e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 337533e882a5SSuraj Sumangala kfree_skb(skb); 337633e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 337733e882a5SSuraj Sumangala return -ENOMEM; 337833e882a5SSuraj Sumangala } 337933e882a5SSuraj Sumangala } 338033e882a5SSuraj Sumangala break; 338133e882a5SSuraj Sumangala 338233e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 338333e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 338433e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 338533e882a5SSuraj Sumangala scb->expect = h->dlen; 338633e882a5SSuraj Sumangala 338733e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 338833e882a5SSuraj Sumangala kfree_skb(skb); 338933e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 339033e882a5SSuraj Sumangala return -ENOMEM; 339133e882a5SSuraj Sumangala } 339233e882a5SSuraj Sumangala } 339333e882a5SSuraj Sumangala break; 339433e882a5SSuraj Sumangala } 339533e882a5SSuraj Sumangala 339633e882a5SSuraj Sumangala if (scb->expect == 0) { 339733e882a5SSuraj Sumangala /* Complete frame */ 339833e882a5SSuraj Sumangala 339933e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 3400e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 340133e882a5SSuraj Sumangala 340233e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 340333e882a5SSuraj Sumangala return remain; 340433e882a5SSuraj Sumangala } 340533e882a5SSuraj Sumangala } 340633e882a5SSuraj Sumangala 340733e882a5SSuraj Sumangala return remain; 340833e882a5SSuraj Sumangala } 340933e882a5SSuraj Sumangala 341099811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 341199811510SSuraj Sumangala 341299811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 341399811510SSuraj Sumangala { 341499811510SSuraj Sumangala int type; 341599811510SSuraj Sumangala int rem = 0; 341699811510SSuraj Sumangala 3417da5f6c37SGustavo F. Padovan while (count) { 341899811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 341999811510SSuraj Sumangala 342099811510SSuraj Sumangala if (!skb) { 342199811510SSuraj Sumangala struct { char type; } *pkt; 342299811510SSuraj Sumangala 342399811510SSuraj Sumangala /* Start of the frame */ 342499811510SSuraj Sumangala pkt = data; 342599811510SSuraj Sumangala type = pkt->type; 342699811510SSuraj Sumangala 342799811510SSuraj Sumangala data++; 342899811510SSuraj Sumangala count--; 342999811510SSuraj Sumangala } else 343099811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 343199811510SSuraj Sumangala 34321e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 34331e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 343499811510SSuraj Sumangala if (rem < 0) 343599811510SSuraj Sumangala return rem; 343699811510SSuraj Sumangala 343799811510SSuraj Sumangala data += (count - rem); 343899811510SSuraj Sumangala count = rem; 3439f81c6224SJoe Perches } 344099811510SSuraj Sumangala 344199811510SSuraj Sumangala return rem; 344299811510SSuraj Sumangala } 344399811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 344499811510SSuraj Sumangala 34451da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 34461da177e4SLinus Torvalds 34471da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 34481da177e4SLinus Torvalds { 34491da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 34501da177e4SLinus Torvalds 3451f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 34521da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 3453f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 34541da177e4SLinus Torvalds 34551da177e4SLinus Torvalds return 0; 34561da177e4SLinus Torvalds } 34571da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 34581da177e4SLinus Torvalds 34591da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 34601da177e4SLinus Torvalds { 34611da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 34621da177e4SLinus Torvalds 3463f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 34641da177e4SLinus Torvalds list_del(&cb->list); 3465f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 34661da177e4SLinus Torvalds 34671da177e4SLinus Torvalds return 0; 34681da177e4SLinus Torvalds } 34691da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 34701da177e4SLinus Torvalds 347151086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 34721da177e4SLinus Torvalds { 3473cdc52faaSMarcel Holtmann int err; 3474cdc52faaSMarcel Holtmann 34750d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 34761da177e4SLinus Torvalds 34771da177e4SLinus Torvalds /* Time stamp */ 3478a61bbcf2SPatrick McHardy __net_timestamp(skb); 34791da177e4SLinus Torvalds 3480cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3481cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3482cd82e61cSMarcel Holtmann 3483cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3484cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3485470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 34861da177e4SLinus Torvalds } 34871da177e4SLinus Torvalds 34881da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 34891da177e4SLinus Torvalds skb_orphan(skb); 34901da177e4SLinus Torvalds 3491cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 3492cdc52faaSMarcel Holtmann if (err < 0) { 3493cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 3494cdc52faaSMarcel Holtmann kfree_skb(skb); 3495cdc52faaSMarcel Holtmann } 34961da177e4SLinus Torvalds } 34971da177e4SLinus Torvalds 3498899de765SMarcel Holtmann bool hci_req_pending(struct hci_dev *hdev) 3499899de765SMarcel Holtmann { 3500899de765SMarcel Holtmann return (hdev->req_status == HCI_REQ_PEND); 3501899de765SMarcel Holtmann } 3502899de765SMarcel Holtmann 35031ca3a9d0SJohan Hedberg /* Send HCI command */ 350407dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 350507dc93ddSJohan Hedberg const void *param) 35061ca3a9d0SJohan Hedberg { 35071ca3a9d0SJohan Hedberg struct sk_buff *skb; 35081ca3a9d0SJohan Hedberg 35091ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 35101ca3a9d0SJohan Hedberg 35111ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 35121ca3a9d0SJohan Hedberg if (!skb) { 35131ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 35141ca3a9d0SJohan Hedberg return -ENOMEM; 35151ca3a9d0SJohan Hedberg } 35161ca3a9d0SJohan Hedberg 351749c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 351811714b3dSJohan Hedberg * single-command requests. 351911714b3dSJohan Hedberg */ 352011714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 352111714b3dSJohan Hedberg 35221da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3523c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 35241da177e4SLinus Torvalds 35251da177e4SLinus Torvalds return 0; 35261da177e4SLinus Torvalds } 35271da177e4SLinus Torvalds 35281da177e4SLinus Torvalds /* Get data from the previously sent command */ 3529a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 35301da177e4SLinus Torvalds { 35311da177e4SLinus Torvalds struct hci_command_hdr *hdr; 35321da177e4SLinus Torvalds 35331da177e4SLinus Torvalds if (!hdev->sent_cmd) 35341da177e4SLinus Torvalds return NULL; 35351da177e4SLinus Torvalds 35361da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 35371da177e4SLinus Torvalds 3538a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 35391da177e4SLinus Torvalds return NULL; 35401da177e4SLinus Torvalds 3541f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 35421da177e4SLinus Torvalds 35431da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 35441da177e4SLinus Torvalds } 35451da177e4SLinus Torvalds 35461da177e4SLinus Torvalds /* Send ACL data */ 35471da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 35481da177e4SLinus Torvalds { 35491da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 35501da177e4SLinus Torvalds int len = skb->len; 35511da177e4SLinus Torvalds 3552badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3553badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 35549c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3555aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3556aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 35571da177e4SLinus Torvalds } 35581da177e4SLinus Torvalds 3559ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 356073d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 35611da177e4SLinus Torvalds { 3562ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 35631da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 35641da177e4SLinus Torvalds struct sk_buff *list; 35651da177e4SLinus Torvalds 3566087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3567087bfd99SGustavo Padovan skb->data_len = 0; 3568087bfd99SGustavo Padovan 3569087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3570204a6e54SAndrei Emeltchenko 3571204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3572204a6e54SAndrei Emeltchenko case HCI_BREDR: 3573087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3574204a6e54SAndrei Emeltchenko break; 3575204a6e54SAndrei Emeltchenko case HCI_AMP: 3576204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3577204a6e54SAndrei Emeltchenko break; 3578204a6e54SAndrei Emeltchenko default: 3579204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 3580204a6e54SAndrei Emeltchenko return; 3581204a6e54SAndrei Emeltchenko } 3582087bfd99SGustavo Padovan 358370f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 358470f23020SAndrei Emeltchenko if (!list) { 35851da177e4SLinus Torvalds /* Non fragmented */ 35861da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 35871da177e4SLinus Torvalds 358873d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 35891da177e4SLinus Torvalds } else { 35901da177e4SLinus Torvalds /* Fragmented */ 35911da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 35921da177e4SLinus Torvalds 35931da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 35941da177e4SLinus Torvalds 35959cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 35969cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 35979cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 35989cfd5a23SJukka Rissanen * deadlocks. 35999cfd5a23SJukka Rissanen */ 36009cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 36011da177e4SLinus Torvalds 360273d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3603e702112fSAndrei Emeltchenko 3604e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3605e702112fSAndrei Emeltchenko flags |= ACL_CONT; 36061da177e4SLinus Torvalds do { 36071da177e4SLinus Torvalds skb = list; list = list->next; 36081da177e4SLinus Torvalds 36090d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3610e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 36111da177e4SLinus Torvalds 36121da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 36131da177e4SLinus Torvalds 361473d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 36151da177e4SLinus Torvalds } while (list); 36161da177e4SLinus Torvalds 36179cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 36181da177e4SLinus Torvalds } 361973d80debSLuiz Augusto von Dentz } 362073d80debSLuiz Augusto von Dentz 362173d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 362273d80debSLuiz Augusto von Dentz { 3623ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 362473d80debSLuiz Augusto von Dentz 3625f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 362673d80debSLuiz Augusto von Dentz 3627ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 36281da177e4SLinus Torvalds 36293eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 36301da177e4SLinus Torvalds } 36311da177e4SLinus Torvalds 36321da177e4SLinus Torvalds /* Send SCO data */ 36330d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 36341da177e4SLinus Torvalds { 36351da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 36361da177e4SLinus Torvalds struct hci_sco_hdr hdr; 36371da177e4SLinus Torvalds 36381da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 36391da177e4SLinus Torvalds 3640aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 36411da177e4SLinus Torvalds hdr.dlen = skb->len; 36421da177e4SLinus Torvalds 3643badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3644badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 36459c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 36461da177e4SLinus Torvalds 36470d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 3648c78ae283SMarcel Holtmann 36491da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 36503eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 36511da177e4SLinus Torvalds } 36521da177e4SLinus Torvalds 36531da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 36541da177e4SLinus Torvalds 36551da177e4SLinus Torvalds /* HCI Connection scheduler */ 36566039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3657a8c5fb1aSGustavo Padovan int *quote) 36581da177e4SLinus Torvalds { 36591da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 36608035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3661abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 36621da177e4SLinus Torvalds 36631da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 36641da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3665bf4c6325SGustavo F. Padovan 3666bf4c6325SGustavo F. Padovan rcu_read_lock(); 3667bf4c6325SGustavo F. Padovan 3668bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3669769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 36701da177e4SLinus Torvalds continue; 3671769be974SMarcel Holtmann 3672769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3673769be974SMarcel Holtmann continue; 3674769be974SMarcel Holtmann 36751da177e4SLinus Torvalds num++; 36761da177e4SLinus Torvalds 36771da177e4SLinus Torvalds if (c->sent < min) { 36781da177e4SLinus Torvalds min = c->sent; 36791da177e4SLinus Torvalds conn = c; 36801da177e4SLinus Torvalds } 368152087a79SLuiz Augusto von Dentz 368252087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 368352087a79SLuiz Augusto von Dentz break; 36841da177e4SLinus Torvalds } 36851da177e4SLinus Torvalds 3686bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3687bf4c6325SGustavo F. Padovan 36881da177e4SLinus Torvalds if (conn) { 36896ed58ec5SVille Tervo int cnt, q; 36906ed58ec5SVille Tervo 36916ed58ec5SVille Tervo switch (conn->type) { 36926ed58ec5SVille Tervo case ACL_LINK: 36936ed58ec5SVille Tervo cnt = hdev->acl_cnt; 36946ed58ec5SVille Tervo break; 36956ed58ec5SVille Tervo case SCO_LINK: 36966ed58ec5SVille Tervo case ESCO_LINK: 36976ed58ec5SVille Tervo cnt = hdev->sco_cnt; 36986ed58ec5SVille Tervo break; 36996ed58ec5SVille Tervo case LE_LINK: 37006ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 37016ed58ec5SVille Tervo break; 37026ed58ec5SVille Tervo default: 37036ed58ec5SVille Tervo cnt = 0; 37046ed58ec5SVille Tervo BT_ERR("Unknown link type"); 37056ed58ec5SVille Tervo } 37066ed58ec5SVille Tervo 37076ed58ec5SVille Tervo q = cnt / num; 37081da177e4SLinus Torvalds *quote = q ? q : 1; 37091da177e4SLinus Torvalds } else 37101da177e4SLinus Torvalds *quote = 0; 37111da177e4SLinus Torvalds 37121da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 37131da177e4SLinus Torvalds return conn; 37141da177e4SLinus Torvalds } 37151da177e4SLinus Torvalds 37166039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 37171da177e4SLinus Torvalds { 37181da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 37191da177e4SLinus Torvalds struct hci_conn *c; 37201da177e4SLinus Torvalds 3721bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 37221da177e4SLinus Torvalds 3723bf4c6325SGustavo F. Padovan rcu_read_lock(); 3724bf4c6325SGustavo F. Padovan 37251da177e4SLinus Torvalds /* Kill stalled connections */ 3726bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3727bae1f5d9SVille Tervo if (c->type == type && c->sent) { 37286ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 37296ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 3730bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 37311da177e4SLinus Torvalds } 37321da177e4SLinus Torvalds } 3733bf4c6325SGustavo F. Padovan 3734bf4c6325SGustavo F. Padovan rcu_read_unlock(); 37351da177e4SLinus Torvalds } 37361da177e4SLinus Torvalds 37376039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 373873d80debSLuiz Augusto von Dentz int *quote) 373973d80debSLuiz Augusto von Dentz { 374073d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 374173d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3742abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 374373d80debSLuiz Augusto von Dentz struct hci_conn *conn; 374473d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 374573d80debSLuiz Augusto von Dentz 374673d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 374773d80debSLuiz Augusto von Dentz 3748bf4c6325SGustavo F. Padovan rcu_read_lock(); 3749bf4c6325SGustavo F. Padovan 3750bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 375173d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 375273d80debSLuiz Augusto von Dentz 375373d80debSLuiz Augusto von Dentz if (conn->type != type) 375473d80debSLuiz Augusto von Dentz continue; 375573d80debSLuiz Augusto von Dentz 375673d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 375773d80debSLuiz Augusto von Dentz continue; 375873d80debSLuiz Augusto von Dentz 375973d80debSLuiz Augusto von Dentz conn_num++; 376073d80debSLuiz Augusto von Dentz 37618192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 376273d80debSLuiz Augusto von Dentz struct sk_buff *skb; 376373d80debSLuiz Augusto von Dentz 376473d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 376573d80debSLuiz Augusto von Dentz continue; 376673d80debSLuiz Augusto von Dentz 376773d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 376873d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 376973d80debSLuiz Augusto von Dentz continue; 377073d80debSLuiz Augusto von Dentz 377173d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 377273d80debSLuiz Augusto von Dentz num = 0; 377373d80debSLuiz Augusto von Dentz min = ~0; 377473d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 377573d80debSLuiz Augusto von Dentz } 377673d80debSLuiz Augusto von Dentz 377773d80debSLuiz Augusto von Dentz num++; 377873d80debSLuiz Augusto von Dentz 377973d80debSLuiz Augusto von Dentz if (conn->sent < min) { 378073d80debSLuiz Augusto von Dentz min = conn->sent; 378173d80debSLuiz Augusto von Dentz chan = tmp; 378273d80debSLuiz Augusto von Dentz } 378373d80debSLuiz Augusto von Dentz } 378473d80debSLuiz Augusto von Dentz 378573d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 378673d80debSLuiz Augusto von Dentz break; 378773d80debSLuiz Augusto von Dentz } 378873d80debSLuiz Augusto von Dentz 3789bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3790bf4c6325SGustavo F. Padovan 379173d80debSLuiz Augusto von Dentz if (!chan) 379273d80debSLuiz Augusto von Dentz return NULL; 379373d80debSLuiz Augusto von Dentz 379473d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 379573d80debSLuiz Augusto von Dentz case ACL_LINK: 379673d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 379773d80debSLuiz Augusto von Dentz break; 3798bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3799bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3800bd1eb66bSAndrei Emeltchenko break; 380173d80debSLuiz Augusto von Dentz case SCO_LINK: 380273d80debSLuiz Augusto von Dentz case ESCO_LINK: 380373d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 380473d80debSLuiz Augusto von Dentz break; 380573d80debSLuiz Augusto von Dentz case LE_LINK: 380673d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 380773d80debSLuiz Augusto von Dentz break; 380873d80debSLuiz Augusto von Dentz default: 380973d80debSLuiz Augusto von Dentz cnt = 0; 381073d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 381173d80debSLuiz Augusto von Dentz } 381273d80debSLuiz Augusto von Dentz 381373d80debSLuiz Augusto von Dentz q = cnt / num; 381473d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 381573d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 381673d80debSLuiz Augusto von Dentz return chan; 381773d80debSLuiz Augusto von Dentz } 381873d80debSLuiz Augusto von Dentz 381902b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 382002b20f0bSLuiz Augusto von Dentz { 382102b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 382202b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 382302b20f0bSLuiz Augusto von Dentz int num = 0; 382402b20f0bSLuiz Augusto von Dentz 382502b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 382602b20f0bSLuiz Augusto von Dentz 3827bf4c6325SGustavo F. Padovan rcu_read_lock(); 3828bf4c6325SGustavo F. Padovan 3829bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 383002b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 383102b20f0bSLuiz Augusto von Dentz 383202b20f0bSLuiz Augusto von Dentz if (conn->type != type) 383302b20f0bSLuiz Augusto von Dentz continue; 383402b20f0bSLuiz Augusto von Dentz 383502b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 383602b20f0bSLuiz Augusto von Dentz continue; 383702b20f0bSLuiz Augusto von Dentz 383802b20f0bSLuiz Augusto von Dentz num++; 383902b20f0bSLuiz Augusto von Dentz 38408192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 384102b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 384202b20f0bSLuiz Augusto von Dentz 384302b20f0bSLuiz Augusto von Dentz if (chan->sent) { 384402b20f0bSLuiz Augusto von Dentz chan->sent = 0; 384502b20f0bSLuiz Augusto von Dentz continue; 384602b20f0bSLuiz Augusto von Dentz } 384702b20f0bSLuiz Augusto von Dentz 384802b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 384902b20f0bSLuiz Augusto von Dentz continue; 385002b20f0bSLuiz Augusto von Dentz 385102b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 385202b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 385302b20f0bSLuiz Augusto von Dentz continue; 385402b20f0bSLuiz Augusto von Dentz 385502b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 385602b20f0bSLuiz Augusto von Dentz 385702b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 385802b20f0bSLuiz Augusto von Dentz skb->priority); 385902b20f0bSLuiz Augusto von Dentz } 386002b20f0bSLuiz Augusto von Dentz 386102b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 386202b20f0bSLuiz Augusto von Dentz break; 386302b20f0bSLuiz Augusto von Dentz } 3864bf4c6325SGustavo F. Padovan 3865bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3866bf4c6325SGustavo F. Padovan 386702b20f0bSLuiz Augusto von Dentz } 386802b20f0bSLuiz Augusto von Dentz 3869b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 3870b71d385aSAndrei Emeltchenko { 3871b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 3872b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 3873b71d385aSAndrei Emeltchenko } 3874b71d385aSAndrei Emeltchenko 38756039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 38761da177e4SLinus Torvalds { 38774a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 38781da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 38791da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 388063d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 38815f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 3882bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 38831da177e4SLinus Torvalds } 388463d2bc1bSAndrei Emeltchenko } 38851da177e4SLinus Torvalds 38866039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 388763d2bc1bSAndrei Emeltchenko { 388863d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 388963d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 389063d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 389163d2bc1bSAndrei Emeltchenko int quote; 389263d2bc1bSAndrei Emeltchenko 389363d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 389404837f64SMarcel Holtmann 389573d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 389673d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 3897ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3898ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 389973d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 390073d80debSLuiz Augusto von Dentz skb->len, skb->priority); 390173d80debSLuiz Augusto von Dentz 3902ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3903ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3904ec1cce24SLuiz Augusto von Dentz break; 3905ec1cce24SLuiz Augusto von Dentz 3906ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3907ec1cce24SLuiz Augusto von Dentz 390873d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 390973d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 391004837f64SMarcel Holtmann 391157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 39121da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 39131da177e4SLinus Torvalds 39141da177e4SLinus Torvalds hdev->acl_cnt--; 391573d80debSLuiz Augusto von Dentz chan->sent++; 391673d80debSLuiz Augusto von Dentz chan->conn->sent++; 39171da177e4SLinus Torvalds } 39181da177e4SLinus Torvalds } 391902b20f0bSLuiz Augusto von Dentz 392002b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 392102b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 39221da177e4SLinus Torvalds } 39231da177e4SLinus Torvalds 39246039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 3925b71d385aSAndrei Emeltchenko { 392663d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 3927b71d385aSAndrei Emeltchenko struct hci_chan *chan; 3928b71d385aSAndrei Emeltchenko struct sk_buff *skb; 3929b71d385aSAndrei Emeltchenko int quote; 3930bd1eb66bSAndrei Emeltchenko u8 type; 3931b71d385aSAndrei Emeltchenko 393263d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 3933b71d385aSAndrei Emeltchenko 3934bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3935bd1eb66bSAndrei Emeltchenko 3936bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 3937bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 3938bd1eb66bSAndrei Emeltchenko else 3939bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 3940bd1eb66bSAndrei Emeltchenko 3941b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 3942bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 3943b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 3944b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 3945b71d385aSAndrei Emeltchenko int blocks; 3946b71d385aSAndrei Emeltchenko 3947b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 3948b71d385aSAndrei Emeltchenko skb->len, skb->priority); 3949b71d385aSAndrei Emeltchenko 3950b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 3951b71d385aSAndrei Emeltchenko if (skb->priority < priority) 3952b71d385aSAndrei Emeltchenko break; 3953b71d385aSAndrei Emeltchenko 3954b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 3955b71d385aSAndrei Emeltchenko 3956b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 3957b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 3958b71d385aSAndrei Emeltchenko return; 3959b71d385aSAndrei Emeltchenko 3960b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 3961b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 3962b71d385aSAndrei Emeltchenko 396357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3964b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 3965b71d385aSAndrei Emeltchenko 3966b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 3967b71d385aSAndrei Emeltchenko quote -= blocks; 3968b71d385aSAndrei Emeltchenko 3969b71d385aSAndrei Emeltchenko chan->sent += blocks; 3970b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 3971b71d385aSAndrei Emeltchenko } 3972b71d385aSAndrei Emeltchenko } 3973b71d385aSAndrei Emeltchenko 3974b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 3975bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 3976b71d385aSAndrei Emeltchenko } 3977b71d385aSAndrei Emeltchenko 39786039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 3979b71d385aSAndrei Emeltchenko { 3980b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3981b71d385aSAndrei Emeltchenko 3982bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 3983bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 3984bd1eb66bSAndrei Emeltchenko return; 3985bd1eb66bSAndrei Emeltchenko 3986bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 3987bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 3988b71d385aSAndrei Emeltchenko return; 3989b71d385aSAndrei Emeltchenko 3990b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 3991b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 3992b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 3993b71d385aSAndrei Emeltchenko break; 3994b71d385aSAndrei Emeltchenko 3995b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 3996b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 3997b71d385aSAndrei Emeltchenko break; 3998b71d385aSAndrei Emeltchenko } 3999b71d385aSAndrei Emeltchenko } 4000b71d385aSAndrei Emeltchenko 40011da177e4SLinus Torvalds /* Schedule SCO */ 40026039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 40031da177e4SLinus Torvalds { 40041da177e4SLinus Torvalds struct hci_conn *conn; 40051da177e4SLinus Torvalds struct sk_buff *skb; 40061da177e4SLinus Torvalds int quote; 40071da177e4SLinus Torvalds 40081da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 40091da177e4SLinus Torvalds 401052087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 401152087a79SLuiz Augusto von Dentz return; 401252087a79SLuiz Augusto von Dentz 40131da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 40141da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 40151da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 401657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40171da177e4SLinus Torvalds 40181da177e4SLinus Torvalds conn->sent++; 40191da177e4SLinus Torvalds if (conn->sent == ~0) 40201da177e4SLinus Torvalds conn->sent = 0; 40211da177e4SLinus Torvalds } 40221da177e4SLinus Torvalds } 40231da177e4SLinus Torvalds } 40241da177e4SLinus Torvalds 40256039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 4026b6a0dc82SMarcel Holtmann { 4027b6a0dc82SMarcel Holtmann struct hci_conn *conn; 4028b6a0dc82SMarcel Holtmann struct sk_buff *skb; 4029b6a0dc82SMarcel Holtmann int quote; 4030b6a0dc82SMarcel Holtmann 4031b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 4032b6a0dc82SMarcel Holtmann 403352087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 403452087a79SLuiz Augusto von Dentz return; 403552087a79SLuiz Augusto von Dentz 40368fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 40378fc9ced3SGustavo Padovan "e))) { 4038b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 4039b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 404057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 4041b6a0dc82SMarcel Holtmann 4042b6a0dc82SMarcel Holtmann conn->sent++; 4043b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 4044b6a0dc82SMarcel Holtmann conn->sent = 0; 4045b6a0dc82SMarcel Holtmann } 4046b6a0dc82SMarcel Holtmann } 4047b6a0dc82SMarcel Holtmann } 4048b6a0dc82SMarcel Holtmann 40496039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 40506ed58ec5SVille Tervo { 405173d80debSLuiz Augusto von Dentz struct hci_chan *chan; 40526ed58ec5SVille Tervo struct sk_buff *skb; 405302b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 40546ed58ec5SVille Tervo 40556ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 40566ed58ec5SVille Tervo 405752087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 405852087a79SLuiz Augusto von Dentz return; 405952087a79SLuiz Augusto von Dentz 40604a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 40616ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 40626ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 4063bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 40646ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 4065bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 40666ed58ec5SVille Tervo } 40676ed58ec5SVille Tervo 40686ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 406902b20f0bSLuiz Augusto von Dentz tmp = cnt; 407073d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 4071ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 4072ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 407373d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 407473d80debSLuiz Augusto von Dentz skb->len, skb->priority); 40756ed58ec5SVille Tervo 4076ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 4077ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 4078ec1cce24SLuiz Augusto von Dentz break; 4079ec1cce24SLuiz Augusto von Dentz 4080ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 4081ec1cce24SLuiz Augusto von Dentz 408257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40836ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 40846ed58ec5SVille Tervo 40856ed58ec5SVille Tervo cnt--; 408673d80debSLuiz Augusto von Dentz chan->sent++; 408773d80debSLuiz Augusto von Dentz chan->conn->sent++; 40886ed58ec5SVille Tervo } 40896ed58ec5SVille Tervo } 409073d80debSLuiz Augusto von Dentz 40916ed58ec5SVille Tervo if (hdev->le_pkts) 40926ed58ec5SVille Tervo hdev->le_cnt = cnt; 40936ed58ec5SVille Tervo else 40946ed58ec5SVille Tervo hdev->acl_cnt = cnt; 409502b20f0bSLuiz Augusto von Dentz 409602b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 409702b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 40986ed58ec5SVille Tervo } 40996ed58ec5SVille Tervo 41003eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 41011da177e4SLinus Torvalds { 41023eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 41031da177e4SLinus Torvalds struct sk_buff *skb; 41041da177e4SLinus Torvalds 41056ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 41066ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 41071da177e4SLinus Torvalds 410852de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 41091da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 41101da177e4SLinus Torvalds hci_sched_acl(hdev); 41111da177e4SLinus Torvalds hci_sched_sco(hdev); 4112b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 41136ed58ec5SVille Tervo hci_sched_le(hdev); 411452de599eSMarcel Holtmann } 41156ed58ec5SVille Tervo 41161da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 41171da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 411857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 41191da177e4SLinus Torvalds } 41201da177e4SLinus Torvalds 412125985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 41221da177e4SLinus Torvalds 41231da177e4SLinus Torvalds /* ACL data packet */ 41246039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 41251da177e4SLinus Torvalds { 41261da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 41271da177e4SLinus Torvalds struct hci_conn *conn; 41281da177e4SLinus Torvalds __u16 handle, flags; 41291da177e4SLinus Torvalds 41301da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 41311da177e4SLinus Torvalds 41321da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 41331da177e4SLinus Torvalds flags = hci_flags(handle); 41341da177e4SLinus Torvalds handle = hci_handle(handle); 41351da177e4SLinus Torvalds 4136f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4137a8c5fb1aSGustavo Padovan handle, flags); 41381da177e4SLinus Torvalds 41391da177e4SLinus Torvalds hdev->stat.acl_rx++; 41401da177e4SLinus Torvalds 41411da177e4SLinus Torvalds hci_dev_lock(hdev); 41421da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 41431da177e4SLinus Torvalds hci_dev_unlock(hdev); 41441da177e4SLinus Torvalds 41451da177e4SLinus Torvalds if (conn) { 414665983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 414704837f64SMarcel Holtmann 41481da177e4SLinus Torvalds /* Send to upper protocol */ 4149686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 41501da177e4SLinus Torvalds return; 41511da177e4SLinus Torvalds } else { 41521da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 41531da177e4SLinus Torvalds hdev->name, handle); 41541da177e4SLinus Torvalds } 41551da177e4SLinus Torvalds 41561da177e4SLinus Torvalds kfree_skb(skb); 41571da177e4SLinus Torvalds } 41581da177e4SLinus Torvalds 41591da177e4SLinus Torvalds /* SCO data packet */ 41606039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 41611da177e4SLinus Torvalds { 41621da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 41631da177e4SLinus Torvalds struct hci_conn *conn; 41641da177e4SLinus Torvalds __u16 handle; 41651da177e4SLinus Torvalds 41661da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 41671da177e4SLinus Torvalds 41681da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 41691da177e4SLinus Torvalds 4170f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 41711da177e4SLinus Torvalds 41721da177e4SLinus Torvalds hdev->stat.sco_rx++; 41731da177e4SLinus Torvalds 41741da177e4SLinus Torvalds hci_dev_lock(hdev); 41751da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 41761da177e4SLinus Torvalds hci_dev_unlock(hdev); 41771da177e4SLinus Torvalds 41781da177e4SLinus Torvalds if (conn) { 41791da177e4SLinus Torvalds /* Send to upper protocol */ 4180686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 41811da177e4SLinus Torvalds return; 41821da177e4SLinus Torvalds } else { 41831da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 41841da177e4SLinus Torvalds hdev->name, handle); 41851da177e4SLinus Torvalds } 41861da177e4SLinus Torvalds 41871da177e4SLinus Torvalds kfree_skb(skb); 41881da177e4SLinus Torvalds } 41891da177e4SLinus Torvalds 41909238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 41919238f36aSJohan Hedberg { 41929238f36aSJohan Hedberg struct sk_buff *skb; 41939238f36aSJohan Hedberg 41949238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 41959238f36aSJohan Hedberg if (!skb) 41969238f36aSJohan Hedberg return true; 41979238f36aSJohan Hedberg 41989238f36aSJohan Hedberg return bt_cb(skb)->req.start; 41999238f36aSJohan Hedberg } 42009238f36aSJohan Hedberg 420142c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 420242c6b129SJohan Hedberg { 420342c6b129SJohan Hedberg struct hci_command_hdr *sent; 420442c6b129SJohan Hedberg struct sk_buff *skb; 420542c6b129SJohan Hedberg u16 opcode; 420642c6b129SJohan Hedberg 420742c6b129SJohan Hedberg if (!hdev->sent_cmd) 420842c6b129SJohan Hedberg return; 420942c6b129SJohan Hedberg 421042c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 421142c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 421242c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 421342c6b129SJohan Hedberg return; 421442c6b129SJohan Hedberg 421542c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 421642c6b129SJohan Hedberg if (!skb) 421742c6b129SJohan Hedberg return; 421842c6b129SJohan Hedberg 421942c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 422042c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 422142c6b129SJohan Hedberg } 422242c6b129SJohan Hedberg 42239238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 42249238f36aSJohan Hedberg { 42259238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 42269238f36aSJohan Hedberg struct sk_buff *skb; 42279238f36aSJohan Hedberg unsigned long flags; 42289238f36aSJohan Hedberg 42299238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 42309238f36aSJohan Hedberg 423142c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 423242c6b129SJohan Hedberg * sent we need to do special handling of it. 42339238f36aSJohan Hedberg */ 423442c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 423542c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 423642c6b129SJohan Hedberg * reset complete event during init and any pending 423742c6b129SJohan Hedberg * command will never be completed. In such a case we 423842c6b129SJohan Hedberg * need to resend whatever was the last sent 423942c6b129SJohan Hedberg * command. 424042c6b129SJohan Hedberg */ 424142c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 424242c6b129SJohan Hedberg hci_resend_last(hdev); 424342c6b129SJohan Hedberg 42449238f36aSJohan Hedberg return; 424542c6b129SJohan Hedberg } 42469238f36aSJohan Hedberg 42479238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 42489238f36aSJohan Hedberg * this request the request is not yet complete. 42499238f36aSJohan Hedberg */ 42509238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 42519238f36aSJohan Hedberg return; 42529238f36aSJohan Hedberg 42539238f36aSJohan Hedberg /* If this was the last command in a request the complete 42549238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 42559238f36aSJohan Hedberg * command queue (hdev->cmd_q). 42569238f36aSJohan Hedberg */ 42579238f36aSJohan Hedberg if (hdev->sent_cmd) { 42589238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 425953e21fbcSJohan Hedberg 426053e21fbcSJohan Hedberg if (req_complete) { 426153e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 426253e21fbcSJohan Hedberg * avoid calling the callback more than once if 426353e21fbcSJohan Hedberg * this function gets called again. 426453e21fbcSJohan Hedberg */ 426553e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 426653e21fbcSJohan Hedberg 42679238f36aSJohan Hedberg goto call_complete; 42689238f36aSJohan Hedberg } 426953e21fbcSJohan Hedberg } 42709238f36aSJohan Hedberg 42719238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 42729238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 42739238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 42749238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 42759238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 42769238f36aSJohan Hedberg break; 42779238f36aSJohan Hedberg } 42789238f36aSJohan Hedberg 42799238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 42809238f36aSJohan Hedberg kfree_skb(skb); 42819238f36aSJohan Hedberg } 42829238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 42839238f36aSJohan Hedberg 42849238f36aSJohan Hedberg call_complete: 42859238f36aSJohan Hedberg if (req_complete) 42861904a853SMarcel Holtmann req_complete(hdev, status, status ? opcode : HCI_OP_NOP); 42879238f36aSJohan Hedberg } 42889238f36aSJohan Hedberg 4289b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 42901da177e4SLinus Torvalds { 4291b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 42921da177e4SLinus Torvalds struct sk_buff *skb; 42931da177e4SLinus Torvalds 42941da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 42951da177e4SLinus Torvalds 42961da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4297cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4298cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4299cd82e61cSMarcel Holtmann 43001da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 43011da177e4SLinus Torvalds /* Send copy to the sockets */ 4302470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 43031da177e4SLinus Torvalds } 43041da177e4SLinus Torvalds 4305fee746b0SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 43061da177e4SLinus Torvalds kfree_skb(skb); 43071da177e4SLinus Torvalds continue; 43081da177e4SLinus Torvalds } 43091da177e4SLinus Torvalds 43101da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 43111da177e4SLinus Torvalds /* Don't process data packets in this states. */ 43120d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 43131da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 43141da177e4SLinus Torvalds case HCI_SCODATA_PKT: 43151da177e4SLinus Torvalds kfree_skb(skb); 43161da177e4SLinus Torvalds continue; 43173ff50b79SStephen Hemminger } 43181da177e4SLinus Torvalds } 43191da177e4SLinus Torvalds 43201da177e4SLinus Torvalds /* Process frame */ 43210d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 43221da177e4SLinus Torvalds case HCI_EVENT_PKT: 4323b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 43241da177e4SLinus Torvalds hci_event_packet(hdev, skb); 43251da177e4SLinus Torvalds break; 43261da177e4SLinus Torvalds 43271da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 43281da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 43291da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 43301da177e4SLinus Torvalds break; 43311da177e4SLinus Torvalds 43321da177e4SLinus Torvalds case HCI_SCODATA_PKT: 43331da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 43341da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 43351da177e4SLinus Torvalds break; 43361da177e4SLinus Torvalds 43371da177e4SLinus Torvalds default: 43381da177e4SLinus Torvalds kfree_skb(skb); 43391da177e4SLinus Torvalds break; 43401da177e4SLinus Torvalds } 43411da177e4SLinus Torvalds } 43421da177e4SLinus Torvalds } 43431da177e4SLinus Torvalds 4344c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 43451da177e4SLinus Torvalds { 4346c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 43471da177e4SLinus Torvalds struct sk_buff *skb; 43481da177e4SLinus Torvalds 43492104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 43502104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 43511da177e4SLinus Torvalds 43521da177e4SLinus Torvalds /* Send queued commands */ 43535a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 43545a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 43555a08ecceSAndrei Emeltchenko if (!skb) 43565a08ecceSAndrei Emeltchenko return; 43575a08ecceSAndrei Emeltchenko 43581da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 43591da177e4SLinus Torvalds 4360a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 436170f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 43621da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 436357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 43647bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 436565cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 43667bdb8a5cSSzymon Janc else 436765cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 436865cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 43691da177e4SLinus Torvalds } else { 43701da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4371c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 43721da177e4SLinus Torvalds } 43731da177e4SLinus Torvalds } 43741da177e4SLinus Torvalds } 4375