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; 61242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 6132177bab5SJohan Hedberg sizeof(mode), &mode); 6142177bab5SJohan Hedberg } else { 6152177bab5SJohan Hedberg struct hci_cp_write_eir cp; 6162177bab5SJohan Hedberg 6172177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 6182177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 6192177bab5SJohan Hedberg 62042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 6212177bab5SJohan Hedberg } 6222177bab5SJohan Hedberg } 6232177bab5SJohan Hedberg 624043ec9bfSMarcel Holtmann if (lmp_inq_rssi_capable(hdev) || 625043ec9bfSMarcel Holtmann test_bit(HCI_QUIRK_FIXUP_INQUIRY_MODE, &hdev->quirks)) { 62604422da9SMarcel Holtmann u8 mode; 62704422da9SMarcel Holtmann 62804422da9SMarcel Holtmann /* If Extended Inquiry Result events are supported, then 62904422da9SMarcel Holtmann * they are clearly preferred over Inquiry Result with RSSI 63004422da9SMarcel Holtmann * events. 63104422da9SMarcel Holtmann */ 63204422da9SMarcel Holtmann mode = lmp_ext_inq_capable(hdev) ? 0x02 : 0x01; 63304422da9SMarcel Holtmann 63404422da9SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 63504422da9SMarcel Holtmann } 6362177bab5SJohan Hedberg 6372177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 63842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 6392177bab5SJohan Hedberg 6402177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 6412177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 6422177bab5SJohan Hedberg 6432177bab5SJohan Hedberg cp.page = 0x01; 64442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 64542c6b129SJohan Hedberg sizeof(cp), &cp); 6462177bab5SJohan Hedberg } 6472177bab5SJohan Hedberg 6482177bab5SJohan Hedberg if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) { 6492177bab5SJohan Hedberg u8 enable = 1; 65042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 6512177bab5SJohan Hedberg &enable); 6522177bab5SJohan Hedberg } 6532177bab5SJohan Hedberg } 6542177bab5SJohan Hedberg 65542c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 6562177bab5SJohan Hedberg { 65742c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 6582177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 6592177bab5SJohan Hedberg u16 link_policy = 0; 6602177bab5SJohan Hedberg 6612177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 6622177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 6632177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 6642177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 6652177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 6662177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 6672177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 6682177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 6692177bab5SJohan Hedberg 6702177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 67142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 6722177bab5SJohan Hedberg } 6732177bab5SJohan Hedberg 67442c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 6752177bab5SJohan Hedberg { 67642c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 6772177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 6782177bab5SJohan Hedberg 679c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 680c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 681c73eee91SJohan Hedberg return; 682c73eee91SJohan Hedberg 6832177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 6842177bab5SJohan Hedberg 6852177bab5SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) { 6862177bab5SJohan Hedberg cp.le = 0x01; 68732226e4fSMarcel Holtmann cp.simul = 0x00; 6882177bab5SJohan Hedberg } 6892177bab5SJohan Hedberg 6902177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 69142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 6922177bab5SJohan Hedberg &cp); 6932177bab5SJohan Hedberg } 6942177bab5SJohan Hedberg 695d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 696d62e6d67SJohan Hedberg { 697d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 698d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 699d62e6d67SJohan Hedberg 700d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 701d62e6d67SJohan Hedberg * enable all necessary events for it. 702d62e6d67SJohan Hedberg */ 70353b834d2SMarcel Holtmann if (lmp_csb_master_capable(hdev)) { 704d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 705d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 706d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 707d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 708d62e6d67SJohan Hedberg } 709d62e6d67SJohan Hedberg 710d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 711d62e6d67SJohan Hedberg * enable all necessary events for it. 712d62e6d67SJohan Hedberg */ 71353b834d2SMarcel Holtmann if (lmp_csb_slave_capable(hdev)) { 714d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 715d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 716d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 717d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 718d62e6d67SJohan Hedberg } 719d62e6d67SJohan Hedberg 72040c59fcbSMarcel Holtmann /* Enable Authenticated Payload Timeout Expired event if supported */ 721cd7ca0ecSMarcel Holtmann if (lmp_ping_capable(hdev) || hdev->le_features[0] & HCI_LE_PING) 72240c59fcbSMarcel Holtmann events[2] |= 0x80; 72340c59fcbSMarcel Holtmann 724d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 725d62e6d67SJohan Hedberg } 726d62e6d67SJohan Hedberg 72742c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 7282177bab5SJohan Hedberg { 72942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 730d2c5d77fSJohan Hedberg u8 p; 73142c6b129SJohan Hedberg 7320da71f1bSMarcel Holtmann hci_setup_event_mask(req); 7330da71f1bSMarcel Holtmann 73448ce62c4SMarcel Holtmann if (hdev->commands[6] & 0x20) { 73548ce62c4SMarcel Holtmann struct hci_cp_read_stored_link_key cp; 73648ce62c4SMarcel Holtmann 73748ce62c4SMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 73848ce62c4SMarcel Holtmann cp.read_all = 0x01; 73948ce62c4SMarcel Holtmann hci_req_add(req, HCI_OP_READ_STORED_LINK_KEY, sizeof(cp), &cp); 74048ce62c4SMarcel Holtmann } 74148ce62c4SMarcel Holtmann 7422177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 74342c6b129SJohan Hedberg hci_setup_link_policy(req); 7442177bab5SJohan Hedberg 745417287deSMarcel Holtmann if (hdev->commands[8] & 0x01) 746417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 747417287deSMarcel Holtmann 748417287deSMarcel Holtmann /* Some older Broadcom based Bluetooth 1.2 controllers do not 749417287deSMarcel Holtmann * support the Read Page Scan Type command. Check support for 750417287deSMarcel Holtmann * this command in the bit mask of supported commands. 751417287deSMarcel Holtmann */ 752417287deSMarcel Holtmann if (hdev->commands[13] & 0x01) 753417287deSMarcel Holtmann hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 754417287deSMarcel Holtmann 7559193c6e8SAndre Guedes if (lmp_le_capable(hdev)) { 7569193c6e8SAndre Guedes u8 events[8]; 7579193c6e8SAndre Guedes 7589193c6e8SAndre Guedes memset(events, 0, sizeof(events)); 7594d6c705bSMarcel Holtmann events[0] = 0x0f; 7604d6c705bSMarcel Holtmann 7614d6c705bSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_ENCRYPTION) 7624d6c705bSMarcel Holtmann events[0] |= 0x10; /* LE Long Term Key Request */ 763662bc2e6SAndre Guedes 764662bc2e6SAndre Guedes /* If controller supports the Connection Parameters Request 765662bc2e6SAndre Guedes * Link Layer Procedure, enable the corresponding event. 766662bc2e6SAndre Guedes */ 767662bc2e6SAndre Guedes if (hdev->le_features[0] & HCI_LE_CONN_PARAM_REQ_PROC) 768662bc2e6SAndre Guedes events[0] |= 0x20; /* LE Remote Connection 769662bc2e6SAndre Guedes * Parameter Request 770662bc2e6SAndre Guedes */ 771662bc2e6SAndre Guedes 772a9f6068eSMarcel Holtmann /* If the controller supports the Data Length Extension 773a9f6068eSMarcel Holtmann * feature, enable the corresponding event. 774a9f6068eSMarcel Holtmann */ 775a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) 776a9f6068eSMarcel Holtmann events[0] |= 0x40; /* LE Data Length Change */ 777a9f6068eSMarcel Holtmann 7784b71bba4SMarcel Holtmann /* If the controller supports Extended Scanner Filter 7794b71bba4SMarcel Holtmann * Policies, enable the correspondig event. 7804b71bba4SMarcel Holtmann */ 7814b71bba4SMarcel Holtmann if (hdev->le_features[0] & HCI_LE_EXT_SCAN_POLICY) 7824b71bba4SMarcel Holtmann events[1] |= 0x04; /* LE Direct Advertising 7834b71bba4SMarcel Holtmann * Report 7844b71bba4SMarcel Holtmann */ 7854b71bba4SMarcel Holtmann 7865a34bd5fSMarcel Holtmann /* If the controller supports the LE Read Local P-256 7875a34bd5fSMarcel Holtmann * Public Key command, enable the corresponding event. 7885a34bd5fSMarcel Holtmann */ 7895a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x02) 7905a34bd5fSMarcel Holtmann events[0] |= 0x80; /* LE Read Local P-256 7915a34bd5fSMarcel Holtmann * Public Key Complete 7925a34bd5fSMarcel Holtmann */ 7935a34bd5fSMarcel Holtmann 7945a34bd5fSMarcel Holtmann /* If the controller supports the LE Generate DHKey 7955a34bd5fSMarcel Holtmann * command, enable the corresponding event. 7965a34bd5fSMarcel Holtmann */ 7975a34bd5fSMarcel Holtmann if (hdev->commands[34] & 0x04) 7985a34bd5fSMarcel Holtmann events[1] |= 0x01; /* LE Generate DHKey Complete */ 7995a34bd5fSMarcel Holtmann 8009193c6e8SAndre Guedes hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, sizeof(events), 8019193c6e8SAndre Guedes events); 8029193c6e8SAndre Guedes 80315a49ccaSMarcel Holtmann if (hdev->commands[25] & 0x40) { 80415a49ccaSMarcel Holtmann /* Read LE Advertising Channel TX Power */ 80515a49ccaSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 80615a49ccaSMarcel Holtmann } 80715a49ccaSMarcel Holtmann 808a9f6068eSMarcel Holtmann if (hdev->le_features[0] & HCI_LE_DATA_LEN_EXT) { 809a9f6068eSMarcel Holtmann /* Read LE Maximum Data Length */ 810a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_MAX_DATA_LEN, 0, NULL); 811a9f6068eSMarcel Holtmann 812a9f6068eSMarcel Holtmann /* Read LE Suggested Default Data Length */ 813a9f6068eSMarcel Holtmann hci_req_add(req, HCI_OP_LE_READ_DEF_DATA_LEN, 0, NULL); 814a9f6068eSMarcel Holtmann } 815a9f6068eSMarcel Holtmann 81642c6b129SJohan Hedberg hci_set_le_support(req); 8179193c6e8SAndre Guedes } 818d2c5d77fSJohan Hedberg 819d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 820d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 821d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 822d2c5d77fSJohan Hedberg 823d2c5d77fSJohan Hedberg cp.page = p; 824d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 825d2c5d77fSJohan Hedberg sizeof(cp), &cp); 826d2c5d77fSJohan Hedberg } 8272177bab5SJohan Hedberg } 8282177bab5SJohan Hedberg 8295d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 8305d4e7e8dSJohan Hedberg { 8315d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 8325d4e7e8dSJohan Hedberg 83336f260ceSMarcel Holtmann /* Some Broadcom based Bluetooth controllers do not support the 83436f260ceSMarcel Holtmann * Delete Stored Link Key command. They are clearly indicating its 83536f260ceSMarcel Holtmann * absence in the bit mask of supported commands. 83636f260ceSMarcel Holtmann * 83736f260ceSMarcel Holtmann * Check the supported commands and only if the the command is marked 83836f260ceSMarcel Holtmann * as supported send it. If not supported assume that the controller 83936f260ceSMarcel Holtmann * does not have actual support for stored link keys which makes this 84036f260ceSMarcel Holtmann * command redundant anyway. 84136f260ceSMarcel Holtmann * 84236f260ceSMarcel Holtmann * Some controllers indicate that they support handling deleting 84336f260ceSMarcel Holtmann * stored link keys, but they don't. The quirk lets a driver 84436f260ceSMarcel Holtmann * just disable this command. 84536f260ceSMarcel Holtmann */ 84636f260ceSMarcel Holtmann if (hdev->commands[6] & 0x80 && 84736f260ceSMarcel Holtmann !test_bit(HCI_QUIRK_BROKEN_STORED_LINK_KEY, &hdev->quirks)) { 84836f260ceSMarcel Holtmann struct hci_cp_delete_stored_link_key cp; 84936f260ceSMarcel Holtmann 85036f260ceSMarcel Holtmann bacpy(&cp.bdaddr, BDADDR_ANY); 85136f260ceSMarcel Holtmann cp.delete_all = 0x01; 85236f260ceSMarcel Holtmann hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 85336f260ceSMarcel Holtmann sizeof(cp), &cp); 85436f260ceSMarcel Holtmann } 85536f260ceSMarcel Holtmann 856d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 857d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 858d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 859d62e6d67SJohan Hedberg 860109e3191SMarcel Holtmann /* Read local codec list if the HCI command is supported */ 861109e3191SMarcel Holtmann if (hdev->commands[29] & 0x20) 862109e3191SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_CODECS, 0, NULL); 863109e3191SMarcel Holtmann 864f4fe73edSMarcel Holtmann /* Get MWS transport configuration if the HCI command is supported */ 865f4fe73edSMarcel Holtmann if (hdev->commands[30] & 0x08) 866f4fe73edSMarcel Holtmann hci_req_add(req, HCI_OP_GET_MWS_TRANSPORT_CONFIG, 0, NULL); 867f4fe73edSMarcel Holtmann 8685d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 86953b834d2SMarcel Holtmann if (lmp_sync_train_capable(hdev)) 8705d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 871a6d0d690SMarcel Holtmann 872a6d0d690SMarcel Holtmann /* Enable Secure Connections if supported and configured */ 873710f11c0SJohan Hedberg if (bredr_sc_enabled(hdev)) { 874a6d0d690SMarcel Holtmann u8 support = 0x01; 875a6d0d690SMarcel Holtmann hci_req_add(req, HCI_OP_WRITE_SC_SUPPORT, 876a6d0d690SMarcel Holtmann sizeof(support), &support); 877a6d0d690SMarcel Holtmann } 8785d4e7e8dSJohan Hedberg } 8795d4e7e8dSJohan Hedberg 8802177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 8812177bab5SJohan Hedberg { 8822177bab5SJohan Hedberg int err; 8832177bab5SJohan Hedberg 8842177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 8852177bab5SJohan Hedberg if (err < 0) 8862177bab5SJohan Hedberg return err; 8872177bab5SJohan Hedberg 8884b4148e9SMarcel Holtmann /* The Device Under Test (DUT) mode is special and available for 8894b4148e9SMarcel Holtmann * all controller types. So just create it early on. 8904b4148e9SMarcel Holtmann */ 8914b4148e9SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 8924b4148e9SMarcel Holtmann debugfs_create_file("dut_mode", 0644, hdev->debugfs, hdev, 8934b4148e9SMarcel Holtmann &dut_mode_fops); 8944b4148e9SMarcel Holtmann } 8954b4148e9SMarcel Holtmann 8962177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 8972177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 8982177bab5SJohan Hedberg * first stage init. 8992177bab5SJohan Hedberg */ 9002177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 9012177bab5SJohan Hedberg return 0; 9022177bab5SJohan Hedberg 9032177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 9042177bab5SJohan Hedberg if (err < 0) 9052177bab5SJohan Hedberg return err; 9062177bab5SJohan Hedberg 9075d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 9085d4e7e8dSJohan Hedberg if (err < 0) 9095d4e7e8dSJohan Hedberg return err; 9105d4e7e8dSJohan Hedberg 911baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 912baf27f6eSMarcel Holtmann if (err < 0) 913baf27f6eSMarcel Holtmann return err; 914baf27f6eSMarcel Holtmann 915ec6cef9cSMarcel Holtmann /* This function is only called when the controller is actually in 916ec6cef9cSMarcel Holtmann * configured state. When the controller is marked as unconfigured, 917ec6cef9cSMarcel Holtmann * this initialization procedure is not run. 918ec6cef9cSMarcel Holtmann * 919ec6cef9cSMarcel Holtmann * It means that it is possible that a controller runs through its 920ec6cef9cSMarcel Holtmann * setup phase and then discovers missing settings. If that is the 921ec6cef9cSMarcel Holtmann * case, then this function will not be called. It then will only 922ec6cef9cSMarcel Holtmann * be called during the config phase. 923ec6cef9cSMarcel Holtmann * 924ec6cef9cSMarcel Holtmann * So only when in setup phase or config phase, create the debugfs 925ec6cef9cSMarcel Holtmann * entries and register the SMP channels. 926baf27f6eSMarcel Holtmann */ 927ec6cef9cSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 928ec6cef9cSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) 929baf27f6eSMarcel Holtmann return 0; 930baf27f6eSMarcel Holtmann 93160c5f5fbSMarcel Holtmann hci_debugfs_create_common(hdev); 93260c5f5fbSMarcel Holtmann 93371c3b60eSMarcel Holtmann if (lmp_bredr_capable(hdev)) 93460c5f5fbSMarcel Holtmann hci_debugfs_create_bredr(hdev); 9352bfa3531SMarcel Holtmann 936d0f729b8SMarcel Holtmann if (lmp_le_capable(hdev)) { 93760c5f5fbSMarcel Holtmann hci_debugfs_create_le(hdev); 938711eafe3SJohan Hedberg smp_register(hdev); 939d0f729b8SMarcel Holtmann } 940e7b8fc92SMarcel Holtmann 941baf27f6eSMarcel Holtmann return 0; 9422177bab5SJohan Hedberg } 9432177bab5SJohan Hedberg 9440ebca7d6SMarcel Holtmann static void hci_init0_req(struct hci_request *req, unsigned long opt) 9450ebca7d6SMarcel Holtmann { 9460ebca7d6SMarcel Holtmann struct hci_dev *hdev = req->hdev; 9470ebca7d6SMarcel Holtmann 9480ebca7d6SMarcel Holtmann BT_DBG("%s %ld", hdev->name, opt); 9490ebca7d6SMarcel Holtmann 9500ebca7d6SMarcel Holtmann /* Reset */ 9510ebca7d6SMarcel Holtmann if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 9520ebca7d6SMarcel Holtmann hci_reset_req(req, 0); 9530ebca7d6SMarcel Holtmann 9540ebca7d6SMarcel Holtmann /* Read Local Version */ 9550ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 9560ebca7d6SMarcel Holtmann 9570ebca7d6SMarcel Holtmann /* Read BD Address */ 9580ebca7d6SMarcel Holtmann if (hdev->set_bdaddr) 9590ebca7d6SMarcel Holtmann hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 9600ebca7d6SMarcel Holtmann } 9610ebca7d6SMarcel Holtmann 9620ebca7d6SMarcel Holtmann static int __hci_unconf_init(struct hci_dev *hdev) 9630ebca7d6SMarcel Holtmann { 9640ebca7d6SMarcel Holtmann int err; 9650ebca7d6SMarcel Holtmann 966cc78b44bSMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 967cc78b44bSMarcel Holtmann return 0; 968cc78b44bSMarcel Holtmann 9690ebca7d6SMarcel Holtmann err = __hci_req_sync(hdev, hci_init0_req, 0, HCI_INIT_TIMEOUT); 9700ebca7d6SMarcel Holtmann if (err < 0) 9710ebca7d6SMarcel Holtmann return err; 9720ebca7d6SMarcel Holtmann 9730ebca7d6SMarcel Holtmann return 0; 9740ebca7d6SMarcel Holtmann } 9750ebca7d6SMarcel Holtmann 97642c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 9771da177e4SLinus Torvalds { 9781da177e4SLinus Torvalds __u8 scan = opt; 9791da177e4SLinus Torvalds 98042c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 9811da177e4SLinus Torvalds 9821da177e4SLinus Torvalds /* Inquiry and Page scans */ 98342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 9841da177e4SLinus Torvalds } 9851da177e4SLinus Torvalds 98642c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 9871da177e4SLinus Torvalds { 9881da177e4SLinus Torvalds __u8 auth = opt; 9891da177e4SLinus Torvalds 99042c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 9911da177e4SLinus Torvalds 9921da177e4SLinus Torvalds /* Authentication */ 99342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 9941da177e4SLinus Torvalds } 9951da177e4SLinus Torvalds 99642c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 9971da177e4SLinus Torvalds { 9981da177e4SLinus Torvalds __u8 encrypt = opt; 9991da177e4SLinus Torvalds 100042c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 10011da177e4SLinus Torvalds 1002e4e8e37cSMarcel Holtmann /* Encryption */ 100342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 10041da177e4SLinus Torvalds } 10051da177e4SLinus Torvalds 100642c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 1007e4e8e37cSMarcel Holtmann { 1008e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 1009e4e8e37cSMarcel Holtmann 101042c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 1011e4e8e37cSMarcel Holtmann 1012e4e8e37cSMarcel Holtmann /* Default link policy */ 101342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 1014e4e8e37cSMarcel Holtmann } 1015e4e8e37cSMarcel Holtmann 10161da177e4SLinus Torvalds /* Get HCI device by index. 10171da177e4SLinus Torvalds * Device is held on return. */ 10181da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 10191da177e4SLinus Torvalds { 10208035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 10211da177e4SLinus Torvalds 10221da177e4SLinus Torvalds BT_DBG("%d", index); 10231da177e4SLinus Torvalds 10241da177e4SLinus Torvalds if (index < 0) 10251da177e4SLinus Torvalds return NULL; 10261da177e4SLinus Torvalds 10271da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 10288035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 10291da177e4SLinus Torvalds if (d->id == index) { 10301da177e4SLinus Torvalds hdev = hci_dev_hold(d); 10311da177e4SLinus Torvalds break; 10321da177e4SLinus Torvalds } 10331da177e4SLinus Torvalds } 10341da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 10351da177e4SLinus Torvalds return hdev; 10361da177e4SLinus Torvalds } 10371da177e4SLinus Torvalds 10381da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 1039ff9ef578SJohan Hedberg 104030dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 104130dc78e1SJohan Hedberg { 104230dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 104330dc78e1SJohan Hedberg 10446fbe195dSAndre Guedes switch (discov->state) { 1045343f935bSAndre Guedes case DISCOVERY_FINDING: 10466fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 104730dc78e1SJohan Hedberg return true; 104830dc78e1SJohan Hedberg 10496fbe195dSAndre Guedes default: 105030dc78e1SJohan Hedberg return false; 105130dc78e1SJohan Hedberg } 10526fbe195dSAndre Guedes } 105330dc78e1SJohan Hedberg 1054ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 1055ff9ef578SJohan Hedberg { 1056bb3e0a33SJohan Hedberg int old_state = hdev->discovery.state; 1057bb3e0a33SJohan Hedberg 1058ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 1059ff9ef578SJohan Hedberg 1060bb3e0a33SJohan Hedberg if (old_state == state) 1061ff9ef578SJohan Hedberg return; 1062ff9ef578SJohan Hedberg 1063bb3e0a33SJohan Hedberg hdev->discovery.state = state; 1064bb3e0a33SJohan Hedberg 1065ff9ef578SJohan Hedberg switch (state) { 1066ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 1067c54c3860SAndre Guedes hci_update_background_scan(hdev); 1068c54c3860SAndre Guedes 1069bb3e0a33SJohan Hedberg if (old_state != DISCOVERY_STARTING) 1070ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 1071ff9ef578SJohan Hedberg break; 1072ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 1073ff9ef578SJohan Hedberg break; 1074343f935bSAndre Guedes case DISCOVERY_FINDING: 1075ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 1076ff9ef578SJohan Hedberg break; 107730dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 107830dc78e1SJohan Hedberg break; 1079ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 1080ff9ef578SJohan Hedberg break; 1081ff9ef578SJohan Hedberg } 1082ff9ef578SJohan Hedberg } 1083ff9ef578SJohan Hedberg 10841f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 10851da177e4SLinus Torvalds { 108630883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1087b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 10881da177e4SLinus Torvalds 1089561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1090561aafbcSJohan Hedberg list_del(&p->all); 1091b57c1a56SJohan Hedberg kfree(p); 10921da177e4SLinus Torvalds } 1093561aafbcSJohan Hedberg 1094561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1095561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 10961da177e4SLinus Torvalds } 10971da177e4SLinus Torvalds 1098a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1099a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 11001da177e4SLinus Torvalds { 110130883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 11021da177e4SLinus Torvalds struct inquiry_entry *e; 11031da177e4SLinus Torvalds 11046ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 11051da177e4SLinus Torvalds 1106561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 11071da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 11081da177e4SLinus Torvalds return e; 11091da177e4SLinus Torvalds } 11101da177e4SLinus Torvalds 1111b57c1a56SJohan Hedberg return NULL; 1112b57c1a56SJohan Hedberg } 1113b57c1a56SJohan Hedberg 1114561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1115561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1116561aafbcSJohan Hedberg { 111730883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1118561aafbcSJohan Hedberg struct inquiry_entry *e; 1119561aafbcSJohan Hedberg 11206ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1121561aafbcSJohan Hedberg 1122561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1123561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1124561aafbcSJohan Hedberg return e; 1125561aafbcSJohan Hedberg } 1126561aafbcSJohan Hedberg 1127561aafbcSJohan Hedberg return NULL; 1128561aafbcSJohan Hedberg } 1129561aafbcSJohan Hedberg 113030dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 113130dc78e1SJohan Hedberg bdaddr_t *bdaddr, 113230dc78e1SJohan Hedberg int state) 113330dc78e1SJohan Hedberg { 113430dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 113530dc78e1SJohan Hedberg struct inquiry_entry *e; 113630dc78e1SJohan Hedberg 11376ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 113830dc78e1SJohan Hedberg 113930dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 114030dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 114130dc78e1SJohan Hedberg return e; 114230dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 114330dc78e1SJohan Hedberg return e; 114430dc78e1SJohan Hedberg } 114530dc78e1SJohan Hedberg 114630dc78e1SJohan Hedberg return NULL; 114730dc78e1SJohan Hedberg } 114830dc78e1SJohan Hedberg 1149a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1150a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1151a3d4e20aSJohan Hedberg { 1152a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1153a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1154a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1155a3d4e20aSJohan Hedberg 1156a3d4e20aSJohan Hedberg list_del(&ie->list); 1157a3d4e20aSJohan Hedberg 1158a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1159a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1160a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1161a3d4e20aSJohan Hedberg break; 1162a3d4e20aSJohan Hedberg pos = &p->list; 1163a3d4e20aSJohan Hedberg } 1164a3d4e20aSJohan Hedberg 1165a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1166a3d4e20aSJohan Hedberg } 1167a3d4e20aSJohan Hedberg 1168af58925cSMarcel Holtmann u32 hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1169af58925cSMarcel Holtmann bool name_known) 11701da177e4SLinus Torvalds { 117130883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 117270f23020SAndrei Emeltchenko struct inquiry_entry *ie; 1173af58925cSMarcel Holtmann u32 flags = 0; 11741da177e4SLinus Torvalds 11756ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 11761da177e4SLinus Torvalds 11776928a924SJohan Hedberg hci_remove_remote_oob_data(hdev, &data->bdaddr, BDADDR_BREDR); 11782b2fec4dSSzymon Janc 1179af58925cSMarcel Holtmann if (!data->ssp_mode) 1180af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1181388fc8faSJohan Hedberg 118270f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1183a3d4e20aSJohan Hedberg if (ie) { 1184af58925cSMarcel Holtmann if (!ie->data.ssp_mode) 1185af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_LEGACY_PAIRING; 1186388fc8faSJohan Hedberg 1187a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1188a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1189a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1190a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1191a3d4e20aSJohan Hedberg } 1192a3d4e20aSJohan Hedberg 1193561aafbcSJohan Hedberg goto update; 1194a3d4e20aSJohan Hedberg } 1195561aafbcSJohan Hedberg 11961da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 119727f70f3eSJohan Hedberg ie = kzalloc(sizeof(*ie), GFP_KERNEL); 1198af58925cSMarcel Holtmann if (!ie) { 1199af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 1200af58925cSMarcel Holtmann goto done; 1201af58925cSMarcel Holtmann } 120270f23020SAndrei Emeltchenko 1203561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1204561aafbcSJohan Hedberg 1205561aafbcSJohan Hedberg if (name_known) { 1206561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1207561aafbcSJohan Hedberg } else { 1208561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1209561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1210561aafbcSJohan Hedberg } 1211561aafbcSJohan Hedberg 1212561aafbcSJohan Hedberg update: 1213561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1214561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1215561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1216561aafbcSJohan Hedberg list_del(&ie->list); 12171da177e4SLinus Torvalds } 12181da177e4SLinus Torvalds 121970f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 122070f23020SAndrei Emeltchenko ie->timestamp = jiffies; 12211da177e4SLinus Torvalds cache->timestamp = jiffies; 12223175405bSJohan Hedberg 12233175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 1224af58925cSMarcel Holtmann flags |= MGMT_DEV_FOUND_CONFIRM_NAME; 12253175405bSJohan Hedberg 1226af58925cSMarcel Holtmann done: 1227af58925cSMarcel Holtmann return flags; 12281da177e4SLinus Torvalds } 12291da177e4SLinus Torvalds 12301da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 12311da177e4SLinus Torvalds { 123230883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 12331da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 12341da177e4SLinus Torvalds struct inquiry_entry *e; 12351da177e4SLinus Torvalds int copied = 0; 12361da177e4SLinus Torvalds 1237561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 12381da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1239b57c1a56SJohan Hedberg 1240b57c1a56SJohan Hedberg if (copied >= num) 1241b57c1a56SJohan Hedberg break; 1242b57c1a56SJohan Hedberg 12431da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 12441da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 12451da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 12461da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 12471da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 12481da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1249b57c1a56SJohan Hedberg 12501da177e4SLinus Torvalds info++; 1251b57c1a56SJohan Hedberg copied++; 12521da177e4SLinus Torvalds } 12531da177e4SLinus Torvalds 12541da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 12551da177e4SLinus Torvalds return copied; 12561da177e4SLinus Torvalds } 12571da177e4SLinus Torvalds 125842c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 12591da177e4SLinus Torvalds { 12601da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 126142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 12621da177e4SLinus Torvalds struct hci_cp_inquiry cp; 12631da177e4SLinus Torvalds 12641da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 12651da177e4SLinus Torvalds 12661da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 12671da177e4SLinus Torvalds return; 12681da177e4SLinus Torvalds 12691da177e4SLinus Torvalds /* Start Inquiry */ 12701da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 12711da177e4SLinus Torvalds cp.length = ir->length; 12721da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 127342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 12741da177e4SLinus Torvalds } 12751da177e4SLinus Torvalds 12761da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 12771da177e4SLinus Torvalds { 12781da177e4SLinus Torvalds __u8 __user *ptr = arg; 12791da177e4SLinus Torvalds struct hci_inquiry_req ir; 12801da177e4SLinus Torvalds struct hci_dev *hdev; 12811da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 12821da177e4SLinus Torvalds long timeo; 12831da177e4SLinus Torvalds __u8 *buf; 12841da177e4SLinus Torvalds 12851da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 12861da177e4SLinus Torvalds return -EFAULT; 12871da177e4SLinus Torvalds 12885a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 12895a08ecceSAndrei Emeltchenko if (!hdev) 12901da177e4SLinus Torvalds return -ENODEV; 12911da177e4SLinus Torvalds 12920736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 12930736cfa8SMarcel Holtmann err = -EBUSY; 12940736cfa8SMarcel Holtmann goto done; 12950736cfa8SMarcel Holtmann } 12960736cfa8SMarcel Holtmann 12974a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 1298fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1299fee746b0SMarcel Holtmann goto done; 1300fee746b0SMarcel Holtmann } 1301fee746b0SMarcel Holtmann 13025b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 13035b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 13045b69bef5SMarcel Holtmann goto done; 13055b69bef5SMarcel Holtmann } 13065b69bef5SMarcel Holtmann 130756f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 130856f87901SJohan Hedberg err = -EOPNOTSUPP; 130956f87901SJohan Hedberg goto done; 131056f87901SJohan Hedberg } 131156f87901SJohan Hedberg 131209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13131da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1314a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 13151f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 13161da177e4SLinus Torvalds do_inquiry = 1; 13171da177e4SLinus Torvalds } 131809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13191da177e4SLinus Torvalds 132004837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 132170f23020SAndrei Emeltchenko 132270f23020SAndrei Emeltchenko if (do_inquiry) { 132301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 132401178cd4SJohan Hedberg timeo); 132570f23020SAndrei Emeltchenko if (err < 0) 13261da177e4SLinus Torvalds goto done; 13273e13fa1eSAndre Guedes 13283e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 13293e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 13303e13fa1eSAndre Guedes */ 133174316201SNeilBrown if (wait_on_bit(&hdev->flags, HCI_INQUIRY, 13323e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 13333e13fa1eSAndre Guedes return -EINTR; 133470f23020SAndrei Emeltchenko } 13351da177e4SLinus Torvalds 13368fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 13378fc9ced3SGustavo Padovan * 255 entries 13388fc9ced3SGustavo Padovan */ 13391da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 13401da177e4SLinus Torvalds 13411da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 13421da177e4SLinus Torvalds * copy it to the user space. 13431da177e4SLinus Torvalds */ 134470f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 134570f23020SAndrei Emeltchenko if (!buf) { 13461da177e4SLinus Torvalds err = -ENOMEM; 13471da177e4SLinus Torvalds goto done; 13481da177e4SLinus Torvalds } 13491da177e4SLinus Torvalds 135009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 13511da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 135209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 13531da177e4SLinus Torvalds 13541da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 13551da177e4SLinus Torvalds 13561da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 13571da177e4SLinus Torvalds ptr += sizeof(ir); 13581da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 13591da177e4SLinus Torvalds ir.num_rsp)) 13601da177e4SLinus Torvalds err = -EFAULT; 13611da177e4SLinus Torvalds } else 13621da177e4SLinus Torvalds err = -EFAULT; 13631da177e4SLinus Torvalds 13641da177e4SLinus Torvalds kfree(buf); 13651da177e4SLinus Torvalds 13661da177e4SLinus Torvalds done: 13671da177e4SLinus Torvalds hci_dev_put(hdev); 13681da177e4SLinus Torvalds return err; 13691da177e4SLinus Torvalds } 13701da177e4SLinus Torvalds 1371cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 13721da177e4SLinus Torvalds { 13731da177e4SLinus Torvalds int ret = 0; 13741da177e4SLinus Torvalds 13751da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 13761da177e4SLinus Torvalds 13771da177e4SLinus Torvalds hci_req_lock(hdev); 13781da177e4SLinus Torvalds 137994324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 138094324962SJohan Hovold ret = -ENODEV; 138194324962SJohan Hovold goto done; 138294324962SJohan Hovold } 138394324962SJohan Hovold 1384d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 1385d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 1386a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1387a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1388bf543036SJohan Hedberg */ 1389a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 1390611b30f7SMarcel Holtmann ret = -ERFKILL; 1391611b30f7SMarcel Holtmann goto done; 1392611b30f7SMarcel Holtmann } 1393611b30f7SMarcel Holtmann 1394a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1395a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1396a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1397a5c8f270SMarcel Holtmann * or not. 1398a5c8f270SMarcel Holtmann * 1399c6beca0eSMarcel Holtmann * In case of user channel usage, it is not important 1400c6beca0eSMarcel Holtmann * if a public address or static random address is 1401c6beca0eSMarcel Holtmann * available. 1402c6beca0eSMarcel Holtmann * 1403a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1404a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1405a5c8f270SMarcel Holtmann */ 1406c6beca0eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 1407c6beca0eSMarcel Holtmann hdev->dev_type == HCI_BREDR && 1408a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1409a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1410a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1411a5c8f270SMarcel Holtmann goto done; 1412a5c8f270SMarcel Holtmann } 1413a5c8f270SMarcel Holtmann } 1414a5c8f270SMarcel Holtmann 14151da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 14161da177e4SLinus Torvalds ret = -EALREADY; 14171da177e4SLinus Torvalds goto done; 14181da177e4SLinus Torvalds } 14191da177e4SLinus Torvalds 14201da177e4SLinus Torvalds if (hdev->open(hdev)) { 14211da177e4SLinus Torvalds ret = -EIO; 14221da177e4SLinus Torvalds goto done; 14231da177e4SLinus Torvalds } 14241da177e4SLinus Torvalds 14251da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 14261da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1427f41c70c4SMarcel Holtmann 1428af202f84SMarcel Holtmann if (test_bit(HCI_SETUP, &hdev->dev_flags)) { 1429af202f84SMarcel Holtmann if (hdev->setup) 1430f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1431f41c70c4SMarcel Holtmann 1432af202f84SMarcel Holtmann /* The transport driver can set these quirks before 1433af202f84SMarcel Holtmann * creating the HCI device or in its setup callback. 1434af202f84SMarcel Holtmann * 1435af202f84SMarcel Holtmann * In case any of them is set, the controller has to 1436af202f84SMarcel Holtmann * start up as unconfigured. 1437af202f84SMarcel Holtmann */ 1438eb1904f4SMarcel Holtmann if (test_bit(HCI_QUIRK_EXTERNAL_CONFIG, &hdev->quirks) || 1439eb1904f4SMarcel Holtmann test_bit(HCI_QUIRK_INVALID_BDADDR, &hdev->quirks)) 144089bc22d2SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 1441f41c70c4SMarcel Holtmann 14420ebca7d6SMarcel Holtmann /* For an unconfigured controller it is required to 14430ebca7d6SMarcel Holtmann * read at least the version information provided by 14440ebca7d6SMarcel Holtmann * the Read Local Version Information command. 14450ebca7d6SMarcel Holtmann * 14460ebca7d6SMarcel Holtmann * If the set_bdaddr driver callback is provided, then 14470ebca7d6SMarcel Holtmann * also the original Bluetooth public device address 14480ebca7d6SMarcel Holtmann * will be read using the Read BD Address command. 14490ebca7d6SMarcel Holtmann */ 14500ebca7d6SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 14510ebca7d6SMarcel Holtmann ret = __hci_unconf_init(hdev); 145289bc22d2SMarcel Holtmann } 145389bc22d2SMarcel Holtmann 14549713c17bSMarcel Holtmann if (test_bit(HCI_CONFIG, &hdev->dev_flags)) { 14559713c17bSMarcel Holtmann /* If public address change is configured, ensure that 14569713c17bSMarcel Holtmann * the address gets programmed. If the driver does not 14579713c17bSMarcel Holtmann * support changing the public address, fail the power 14589713c17bSMarcel Holtmann * on procedure. 145924c457e2SMarcel Holtmann */ 14609713c17bSMarcel Holtmann if (bacmp(&hdev->public_addr, BDADDR_ANY) && 14619713c17bSMarcel Holtmann hdev->set_bdaddr) 146224c457e2SMarcel Holtmann ret = hdev->set_bdaddr(hdev, &hdev->public_addr); 146324c457e2SMarcel Holtmann else 146424c457e2SMarcel Holtmann ret = -EADDRNOTAVAIL; 146524c457e2SMarcel Holtmann } 146624c457e2SMarcel Holtmann 1467f41c70c4SMarcel Holtmann if (!ret) { 14684a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 14690736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 14702177bab5SJohan Hedberg ret = __hci_init(hdev); 14711da177e4SLinus Torvalds } 14721da177e4SLinus Torvalds 1473f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1474f41c70c4SMarcel Holtmann 14751da177e4SLinus Torvalds if (!ret) { 14761da177e4SLinus Torvalds hci_dev_hold(hdev); 1477d6bfd59cSJohan Hedberg set_bit(HCI_RPA_EXPIRED, &hdev->dev_flags); 14781da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 14791da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 1480bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 1481d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags) && 14824a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 14830736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 14841514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 148509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1486744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 148709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 148856e5cb86SJohan Hedberg } 14891da177e4SLinus Torvalds } else { 14901da177e4SLinus Torvalds /* Init failed, cleanup */ 14913eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1492c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1493b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 14941da177e4SLinus Torvalds 14951da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 14961da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 14971da177e4SLinus Torvalds 14981da177e4SLinus Torvalds if (hdev->flush) 14991da177e4SLinus Torvalds hdev->flush(hdev); 15001da177e4SLinus Torvalds 15011da177e4SLinus Torvalds if (hdev->sent_cmd) { 15021da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 15031da177e4SLinus Torvalds hdev->sent_cmd = NULL; 15041da177e4SLinus Torvalds } 15051da177e4SLinus Torvalds 15061da177e4SLinus Torvalds hdev->close(hdev); 1507fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 15081da177e4SLinus Torvalds } 15091da177e4SLinus Torvalds 15101da177e4SLinus Torvalds done: 15111da177e4SLinus Torvalds hci_req_unlock(hdev); 15121da177e4SLinus Torvalds return ret; 15131da177e4SLinus Torvalds } 15141da177e4SLinus Torvalds 1515cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1516cbed0ca1SJohan Hedberg 1517cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1518cbed0ca1SJohan Hedberg { 1519cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1520cbed0ca1SJohan Hedberg int err; 1521cbed0ca1SJohan Hedberg 1522cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1523cbed0ca1SJohan Hedberg if (!hdev) 1524cbed0ca1SJohan Hedberg return -ENODEV; 1525cbed0ca1SJohan Hedberg 15264a964404SMarcel Holtmann /* Devices that are marked as unconfigured can only be powered 1527fee746b0SMarcel Holtmann * up as user channel. Trying to bring them up as normal devices 1528fee746b0SMarcel Holtmann * will result into a failure. Only user channel operation is 1529fee746b0SMarcel Holtmann * possible. 1530fee746b0SMarcel Holtmann * 1531fee746b0SMarcel Holtmann * When this function is called for a user channel, the flag 1532fee746b0SMarcel Holtmann * HCI_USER_CHANNEL will be set first before attempting to 1533fee746b0SMarcel Holtmann * open the device. 1534fee746b0SMarcel Holtmann */ 15354a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 1536fee746b0SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 1537fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1538fee746b0SMarcel Holtmann goto done; 1539fee746b0SMarcel Holtmann } 1540fee746b0SMarcel Holtmann 1541e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1542e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1543e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1544e1d08f40SJohan Hedberg * completed. 1545e1d08f40SJohan Hedberg */ 1546e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 1547e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1548e1d08f40SJohan Hedberg 1549a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1550a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1551a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1552a5c8f270SMarcel Holtmann */ 1553e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1554e1d08f40SJohan Hedberg 155512aa4f0aSMarcel Holtmann /* For controllers not using the management interface and that 1556b6ae8457SJohan Hedberg * are brought up using legacy ioctl, set the HCI_BONDABLE bit 155712aa4f0aSMarcel Holtmann * so that pairing works for them. Once the management interface 155812aa4f0aSMarcel Holtmann * is in use this bit will be cleared again and userspace has 155912aa4f0aSMarcel Holtmann * to explicitly enable it. 156012aa4f0aSMarcel Holtmann */ 156112aa4f0aSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 156212aa4f0aSMarcel Holtmann !test_bit(HCI_MGMT, &hdev->dev_flags)) 1563b6ae8457SJohan Hedberg set_bit(HCI_BONDABLE, &hdev->dev_flags); 156412aa4f0aSMarcel Holtmann 1565cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1566cbed0ca1SJohan Hedberg 1567fee746b0SMarcel Holtmann done: 1568cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1569cbed0ca1SJohan Hedberg return err; 1570cbed0ca1SJohan Hedberg } 1571cbed0ca1SJohan Hedberg 1572d7347f3cSJohan Hedberg /* This function requires the caller holds hdev->lock */ 1573d7347f3cSJohan Hedberg static void hci_pend_le_actions_clear(struct hci_dev *hdev) 1574d7347f3cSJohan Hedberg { 1575d7347f3cSJohan Hedberg struct hci_conn_params *p; 1576d7347f3cSJohan Hedberg 1577f161dd41SJohan Hedberg list_for_each_entry(p, &hdev->le_conn_params, list) { 1578f161dd41SJohan Hedberg if (p->conn) { 1579f161dd41SJohan Hedberg hci_conn_drop(p->conn); 1580f8aaf9b6SJohan Hedberg hci_conn_put(p->conn); 1581f161dd41SJohan Hedberg p->conn = NULL; 1582f161dd41SJohan Hedberg } 1583d7347f3cSJohan Hedberg list_del_init(&p->action); 1584f161dd41SJohan Hedberg } 1585d7347f3cSJohan Hedberg 1586d7347f3cSJohan Hedberg BT_DBG("All LE pending actions cleared"); 1587d7347f3cSJohan Hedberg } 1588d7347f3cSJohan Hedberg 15891da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 15901da177e4SLinus Torvalds { 15911da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 15921da177e4SLinus Torvalds 159378c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 159478c04c0bSVinicius Costa Gomes 15951da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 15961da177e4SLinus Torvalds hci_req_lock(hdev); 15971da177e4SLinus Torvalds 15981da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 159965cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 16001da177e4SLinus Torvalds hci_req_unlock(hdev); 16011da177e4SLinus Torvalds return 0; 16021da177e4SLinus Torvalds } 16031da177e4SLinus Torvalds 16043eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 16053eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1606b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 16071da177e4SLinus Torvalds 160816ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 1609e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 161016ab91abSJohan Hedberg hdev->discov_timeout = 0; 16115e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 1612310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 161316ab91abSJohan Hedberg } 161416ab91abSJohan Hedberg 1615a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 16167d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 16177d78525dSJohan Hedberg 16187ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 16194518bb0fSJohan Hedberg 16204518bb0fSJohan Hedberg if (test_bit(HCI_MGMT, &hdev->dev_flags)) 1621d6bfd59cSJohan Hedberg cancel_delayed_work_sync(&hdev->rpa_expired); 16227ba8b4beSAndre Guedes 162376727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 162476727c02SJohan Hedberg * ensuring the workqueue is empty up front. 162576727c02SJohan Hedberg */ 162676727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 162776727c02SJohan Hedberg 162809fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 16291aeb9c65SJohan Hedberg 16301aeb9c65SJohan Hedberg if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 16311aeb9c65SJohan Hedberg if (hdev->dev_type == HCI_BREDR) 16321aeb9c65SJohan Hedberg mgmt_powered(hdev, 0); 16331aeb9c65SJohan Hedberg } 16341aeb9c65SJohan Hedberg 16351f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 1636d7347f3cSJohan Hedberg hci_pend_le_actions_clear(hdev); 1637f161dd41SJohan Hedberg hci_conn_hash_flush(hdev); 163809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 16391da177e4SLinus Torvalds 16401da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 16411da177e4SLinus Torvalds 16421da177e4SLinus Torvalds if (hdev->flush) 16431da177e4SLinus Torvalds hdev->flush(hdev); 16441da177e4SLinus Torvalds 16451da177e4SLinus Torvalds /* Reset device */ 16461da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16471da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 16484a964404SMarcel Holtmann if (!test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 16494a964404SMarcel Holtmann !test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) && 1650a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 16511da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 165201178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 16531da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 16541da177e4SLinus Torvalds } 16551da177e4SLinus Torvalds 1656c347b765SGustavo F. Padovan /* flush cmd work */ 1657c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 16581da177e4SLinus Torvalds 16591da177e4SLinus Torvalds /* Drop queues */ 16601da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 16611da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 16621da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 16631da177e4SLinus Torvalds 16641da177e4SLinus Torvalds /* Drop last sent command */ 16651da177e4SLinus Torvalds if (hdev->sent_cmd) { 166665cc2b49SMarcel Holtmann cancel_delayed_work_sync(&hdev->cmd_timer); 16671da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 16681da177e4SLinus Torvalds hdev->sent_cmd = NULL; 16691da177e4SLinus Torvalds } 16701da177e4SLinus Torvalds 1671b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 1672b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 1673b6ddb638SJohan Hedberg 16741da177e4SLinus Torvalds /* After this point our queues are empty 16751da177e4SLinus Torvalds * and no tasks are scheduled. */ 16761da177e4SLinus Torvalds hdev->close(hdev); 16771da177e4SLinus Torvalds 167835b973c9SJohan Hedberg /* Clear flags */ 1679fee746b0SMarcel Holtmann hdev->flags &= BIT(HCI_RAW); 168035b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 168135b973c9SJohan Hedberg 1682ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1683536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1684ced5c338SAndrei Emeltchenko 1685e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 168609b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 16877a4cd51dSMarcel Holtmann bacpy(&hdev->random_addr, BDADDR_ANY); 1688e59fda8dSJohan Hedberg 16891da177e4SLinus Torvalds hci_req_unlock(hdev); 16901da177e4SLinus Torvalds 16911da177e4SLinus Torvalds hci_dev_put(hdev); 16921da177e4SLinus Torvalds return 0; 16931da177e4SLinus Torvalds } 16941da177e4SLinus Torvalds 16951da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 16961da177e4SLinus Torvalds { 16971da177e4SLinus Torvalds struct hci_dev *hdev; 16981da177e4SLinus Torvalds int err; 16991da177e4SLinus Torvalds 170070f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 170170f23020SAndrei Emeltchenko if (!hdev) 17021da177e4SLinus Torvalds return -ENODEV; 17038ee56540SMarcel Holtmann 17040736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 17050736cfa8SMarcel Holtmann err = -EBUSY; 17060736cfa8SMarcel Holtmann goto done; 17070736cfa8SMarcel Holtmann } 17080736cfa8SMarcel Holtmann 17098ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 17108ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 17118ee56540SMarcel Holtmann 17121da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 17138ee56540SMarcel Holtmann 17140736cfa8SMarcel Holtmann done: 17151da177e4SLinus Torvalds hci_dev_put(hdev); 17161da177e4SLinus Torvalds return err; 17171da177e4SLinus Torvalds } 17181da177e4SLinus Torvalds 17191da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 17201da177e4SLinus Torvalds { 17211da177e4SLinus Torvalds struct hci_dev *hdev; 17221da177e4SLinus Torvalds int ret = 0; 17231da177e4SLinus Torvalds 172470f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 172570f23020SAndrei Emeltchenko if (!hdev) 17261da177e4SLinus Torvalds return -ENODEV; 17271da177e4SLinus Torvalds 17281da177e4SLinus Torvalds hci_req_lock(hdev); 17291da177e4SLinus Torvalds 1730808a049eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 1731808a049eSMarcel Holtmann ret = -ENETDOWN; 17321da177e4SLinus Torvalds goto done; 1733808a049eSMarcel Holtmann } 17341da177e4SLinus Torvalds 17350736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 17360736cfa8SMarcel Holtmann ret = -EBUSY; 17370736cfa8SMarcel Holtmann goto done; 17380736cfa8SMarcel Holtmann } 17390736cfa8SMarcel Holtmann 17404a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 1741fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 1742fee746b0SMarcel Holtmann goto done; 1743fee746b0SMarcel Holtmann } 1744fee746b0SMarcel Holtmann 17451da177e4SLinus Torvalds /* Drop queues */ 17461da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 17471da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 17481da177e4SLinus Torvalds 174976727c02SJohan Hedberg /* Avoid potential lockdep warnings from the *_flush() calls by 175076727c02SJohan Hedberg * ensuring the workqueue is empty up front. 175176727c02SJohan Hedberg */ 175276727c02SJohan Hedberg drain_workqueue(hdev->workqueue); 175376727c02SJohan Hedberg 175409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 17551f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 17561da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 175709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 17581da177e4SLinus Torvalds 17591da177e4SLinus Torvalds if (hdev->flush) 17601da177e4SLinus Torvalds hdev->flush(hdev); 17611da177e4SLinus Torvalds 17621da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 17636ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 17641da177e4SLinus Torvalds 176501178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 17661da177e4SLinus Torvalds 17671da177e4SLinus Torvalds done: 17681da177e4SLinus Torvalds hci_req_unlock(hdev); 17691da177e4SLinus Torvalds hci_dev_put(hdev); 17701da177e4SLinus Torvalds return ret; 17711da177e4SLinus Torvalds } 17721da177e4SLinus Torvalds 17731da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 17741da177e4SLinus Torvalds { 17751da177e4SLinus Torvalds struct hci_dev *hdev; 17761da177e4SLinus Torvalds int ret = 0; 17771da177e4SLinus Torvalds 177870f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 177970f23020SAndrei Emeltchenko if (!hdev) 17801da177e4SLinus Torvalds return -ENODEV; 17811da177e4SLinus Torvalds 17820736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 17830736cfa8SMarcel Holtmann ret = -EBUSY; 17840736cfa8SMarcel Holtmann goto done; 17850736cfa8SMarcel Holtmann } 17860736cfa8SMarcel Holtmann 17874a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 1788fee746b0SMarcel Holtmann ret = -EOPNOTSUPP; 1789fee746b0SMarcel Holtmann goto done; 1790fee746b0SMarcel Holtmann } 1791fee746b0SMarcel Holtmann 17921da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 17931da177e4SLinus Torvalds 17940736cfa8SMarcel Holtmann done: 17951da177e4SLinus Torvalds hci_dev_put(hdev); 17961da177e4SLinus Torvalds return ret; 17971da177e4SLinus Torvalds } 17981da177e4SLinus Torvalds 1799123abc08SJohan Hedberg static void hci_update_scan_state(struct hci_dev *hdev, u8 scan) 1800123abc08SJohan Hedberg { 1801bc6d2d04SJohan Hedberg bool conn_changed, discov_changed; 1802123abc08SJohan Hedberg 1803123abc08SJohan Hedberg BT_DBG("%s scan 0x%02x", hdev->name, scan); 1804123abc08SJohan Hedberg 1805123abc08SJohan Hedberg if ((scan & SCAN_PAGE)) 1806123abc08SJohan Hedberg conn_changed = !test_and_set_bit(HCI_CONNECTABLE, 1807123abc08SJohan Hedberg &hdev->dev_flags); 1808123abc08SJohan Hedberg else 1809123abc08SJohan Hedberg conn_changed = test_and_clear_bit(HCI_CONNECTABLE, 1810123abc08SJohan Hedberg &hdev->dev_flags); 1811123abc08SJohan Hedberg 1812bc6d2d04SJohan Hedberg if ((scan & SCAN_INQUIRY)) { 1813bc6d2d04SJohan Hedberg discov_changed = !test_and_set_bit(HCI_DISCOVERABLE, 1814bc6d2d04SJohan Hedberg &hdev->dev_flags); 1815bc6d2d04SJohan Hedberg } else { 1816bc6d2d04SJohan Hedberg clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 1817bc6d2d04SJohan Hedberg discov_changed = test_and_clear_bit(HCI_DISCOVERABLE, 1818bc6d2d04SJohan Hedberg &hdev->dev_flags); 1819bc6d2d04SJohan Hedberg } 1820bc6d2d04SJohan Hedberg 1821123abc08SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 1822123abc08SJohan Hedberg return; 1823123abc08SJohan Hedberg 1824bc6d2d04SJohan Hedberg if (conn_changed || discov_changed) { 1825bc6d2d04SJohan Hedberg /* In case this was disabled through mgmt */ 1826bc6d2d04SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 1827bc6d2d04SJohan Hedberg 1828bc6d2d04SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) 1829bc6d2d04SJohan Hedberg mgmt_update_adv_data(hdev); 1830bc6d2d04SJohan Hedberg 1831123abc08SJohan Hedberg mgmt_new_settings(hdev); 1832123abc08SJohan Hedberg } 1833bc6d2d04SJohan Hedberg } 1834123abc08SJohan Hedberg 18351da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 18361da177e4SLinus Torvalds { 18371da177e4SLinus Torvalds struct hci_dev *hdev; 18381da177e4SLinus Torvalds struct hci_dev_req dr; 18391da177e4SLinus Torvalds int err = 0; 18401da177e4SLinus Torvalds 18411da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 18421da177e4SLinus Torvalds return -EFAULT; 18431da177e4SLinus Torvalds 184470f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 184570f23020SAndrei Emeltchenko if (!hdev) 18461da177e4SLinus Torvalds return -ENODEV; 18471da177e4SLinus Torvalds 18480736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 18490736cfa8SMarcel Holtmann err = -EBUSY; 18500736cfa8SMarcel Holtmann goto done; 18510736cfa8SMarcel Holtmann } 18520736cfa8SMarcel Holtmann 18534a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 1854fee746b0SMarcel Holtmann err = -EOPNOTSUPP; 1855fee746b0SMarcel Holtmann goto done; 1856fee746b0SMarcel Holtmann } 1857fee746b0SMarcel Holtmann 18585b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 18595b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 18605b69bef5SMarcel Holtmann goto done; 18615b69bef5SMarcel Holtmann } 18625b69bef5SMarcel Holtmann 186356f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 186456f87901SJohan Hedberg err = -EOPNOTSUPP; 186556f87901SJohan Hedberg goto done; 186656f87901SJohan Hedberg } 186756f87901SJohan Hedberg 18681da177e4SLinus Torvalds switch (cmd) { 18691da177e4SLinus Torvalds case HCISETAUTH: 187001178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 18715f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 18721da177e4SLinus Torvalds break; 18731da177e4SLinus Torvalds 18741da177e4SLinus Torvalds case HCISETENCRYPT: 18751da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 18761da177e4SLinus Torvalds err = -EOPNOTSUPP; 18771da177e4SLinus Torvalds break; 18781da177e4SLinus Torvalds } 18791da177e4SLinus Torvalds 18801da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 18811da177e4SLinus Torvalds /* Auth must be enabled first */ 188201178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 18835f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 18841da177e4SLinus Torvalds if (err) 18851da177e4SLinus Torvalds break; 18861da177e4SLinus Torvalds } 18871da177e4SLinus Torvalds 188801178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 18895f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 18901da177e4SLinus Torvalds break; 18911da177e4SLinus Torvalds 18921da177e4SLinus Torvalds case HCISETSCAN: 189301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 18945f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 189591a668b0SJohan Hedberg 1896bc6d2d04SJohan Hedberg /* Ensure that the connectable and discoverable states 1897bc6d2d04SJohan Hedberg * get correctly modified as this was a non-mgmt change. 189891a668b0SJohan Hedberg */ 1899123abc08SJohan Hedberg if (!err) 1900123abc08SJohan Hedberg hci_update_scan_state(hdev, dr.dev_opt); 19011da177e4SLinus Torvalds break; 19021da177e4SLinus Torvalds 19031da177e4SLinus Torvalds case HCISETLINKPOL: 190401178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 19055f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 19061da177e4SLinus Torvalds break; 19071da177e4SLinus Torvalds 19081da177e4SLinus Torvalds case HCISETLINKMODE: 1909e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 1910e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 1911e4e8e37cSMarcel Holtmann break; 1912e4e8e37cSMarcel Holtmann 1913e4e8e37cSMarcel Holtmann case HCISETPTYPE: 1914e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 19151da177e4SLinus Torvalds break; 19161da177e4SLinus Torvalds 19171da177e4SLinus Torvalds case HCISETACLMTU: 19181da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 19191da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 19201da177e4SLinus Torvalds break; 19211da177e4SLinus Torvalds 19221da177e4SLinus Torvalds case HCISETSCOMTU: 19231da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 19241da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 19251da177e4SLinus Torvalds break; 19261da177e4SLinus Torvalds 19271da177e4SLinus Torvalds default: 19281da177e4SLinus Torvalds err = -EINVAL; 19291da177e4SLinus Torvalds break; 19301da177e4SLinus Torvalds } 1931e4e8e37cSMarcel Holtmann 19320736cfa8SMarcel Holtmann done: 19331da177e4SLinus Torvalds hci_dev_put(hdev); 19341da177e4SLinus Torvalds return err; 19351da177e4SLinus Torvalds } 19361da177e4SLinus Torvalds 19371da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 19381da177e4SLinus Torvalds { 19398035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 19401da177e4SLinus Torvalds struct hci_dev_list_req *dl; 19411da177e4SLinus Torvalds struct hci_dev_req *dr; 19421da177e4SLinus Torvalds int n = 0, size, err; 19431da177e4SLinus Torvalds __u16 dev_num; 19441da177e4SLinus Torvalds 19451da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 19461da177e4SLinus Torvalds return -EFAULT; 19471da177e4SLinus Torvalds 19481da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 19491da177e4SLinus Torvalds return -EINVAL; 19501da177e4SLinus Torvalds 19511da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 19521da177e4SLinus Torvalds 195370f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 195470f23020SAndrei Emeltchenko if (!dl) 19551da177e4SLinus Torvalds return -ENOMEM; 19561da177e4SLinus Torvalds 19571da177e4SLinus Torvalds dr = dl->dev_req; 19581da177e4SLinus Torvalds 1959f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 19608035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 19612e84d8dbSMarcel Holtmann unsigned long flags = hdev->flags; 1962c542a06cSJohan Hedberg 19632e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 19642e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 19652e84d8dbSMarcel Holtmann * device is actually down. 19662e84d8dbSMarcel Holtmann */ 19672e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 19682e84d8dbSMarcel Holtmann flags &= ~BIT(HCI_UP); 1969c542a06cSJohan Hedberg 19701da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 19712e84d8dbSMarcel Holtmann (dr + n)->dev_opt = flags; 1972c542a06cSJohan Hedberg 19731da177e4SLinus Torvalds if (++n >= dev_num) 19741da177e4SLinus Torvalds break; 19751da177e4SLinus Torvalds } 1976f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 19771da177e4SLinus Torvalds 19781da177e4SLinus Torvalds dl->dev_num = n; 19791da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 19801da177e4SLinus Torvalds 19811da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 19821da177e4SLinus Torvalds kfree(dl); 19831da177e4SLinus Torvalds 19841da177e4SLinus Torvalds return err ? -EFAULT : 0; 19851da177e4SLinus Torvalds } 19861da177e4SLinus Torvalds 19871da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 19881da177e4SLinus Torvalds { 19891da177e4SLinus Torvalds struct hci_dev *hdev; 19901da177e4SLinus Torvalds struct hci_dev_info di; 19912e84d8dbSMarcel Holtmann unsigned long flags; 19921da177e4SLinus Torvalds int err = 0; 19931da177e4SLinus Torvalds 19941da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 19951da177e4SLinus Torvalds return -EFAULT; 19961da177e4SLinus Torvalds 199770f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 199870f23020SAndrei Emeltchenko if (!hdev) 19991da177e4SLinus Torvalds return -ENODEV; 20001da177e4SLinus Torvalds 20012e84d8dbSMarcel Holtmann /* When the auto-off is configured it means the transport 20022e84d8dbSMarcel Holtmann * is running, but in that case still indicate that the 20032e84d8dbSMarcel Holtmann * device is actually down. 20042e84d8dbSMarcel Holtmann */ 20052e84d8dbSMarcel Holtmann if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 20062e84d8dbSMarcel Holtmann flags = hdev->flags & ~BIT(HCI_UP); 20072e84d8dbSMarcel Holtmann else 20082e84d8dbSMarcel Holtmann flags = hdev->flags; 2009c542a06cSJohan Hedberg 20101da177e4SLinus Torvalds strcpy(di.name, hdev->name); 20111da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 201260f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 20132e84d8dbSMarcel Holtmann di.flags = flags; 20141da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 2015572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 20161da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 20171da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 20181da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 20191da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 2020572c7f84SJohan Hedberg } else { 2021572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 2022572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 2023572c7f84SJohan Hedberg di.sco_mtu = 0; 2024572c7f84SJohan Hedberg di.sco_pkts = 0; 2025572c7f84SJohan Hedberg } 20261da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 20271da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 20281da177e4SLinus Torvalds 20291da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 20301da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 20311da177e4SLinus Torvalds 20321da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 20331da177e4SLinus Torvalds err = -EFAULT; 20341da177e4SLinus Torvalds 20351da177e4SLinus Torvalds hci_dev_put(hdev); 20361da177e4SLinus Torvalds 20371da177e4SLinus Torvalds return err; 20381da177e4SLinus Torvalds } 20391da177e4SLinus Torvalds 20401da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 20411da177e4SLinus Torvalds 2042611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 2043611b30f7SMarcel Holtmann { 2044611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 2045611b30f7SMarcel Holtmann 2046611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 2047611b30f7SMarcel Holtmann 20480736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 20490736cfa8SMarcel Holtmann return -EBUSY; 20500736cfa8SMarcel Holtmann 20515e130367SJohan Hedberg if (blocked) { 20525e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 2053d603b76bSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 2054d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) 2055611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 20565e130367SJohan Hedberg } else { 20575e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 20585e130367SJohan Hedberg } 2059611b30f7SMarcel Holtmann 2060611b30f7SMarcel Holtmann return 0; 2061611b30f7SMarcel Holtmann } 2062611b30f7SMarcel Holtmann 2063611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 2064611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 2065611b30f7SMarcel Holtmann }; 2066611b30f7SMarcel Holtmann 2067ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 2068ab81cbf9SJohan Hedberg { 2069ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 207096570ffcSJohan Hedberg int err; 2071ab81cbf9SJohan Hedberg 2072ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2073ab81cbf9SJohan Hedberg 2074cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 207596570ffcSJohan Hedberg if (err < 0) { 20763ad67582SJaganath Kanakkassery hci_dev_lock(hdev); 207796570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 20783ad67582SJaganath Kanakkassery hci_dev_unlock(hdev); 2079ab81cbf9SJohan Hedberg return; 208096570ffcSJohan Hedberg } 2081ab81cbf9SJohan Hedberg 2082a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 2083a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 2084a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 2085a5c8f270SMarcel Holtmann */ 2086a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 20874a964404SMarcel Holtmann test_bit(HCI_UNCONFIGURED, &hdev->dev_flags) || 2088a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 2089a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 2090a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 2091bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2092bf543036SJohan Hedberg hci_dev_do_close(hdev); 2093bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 209419202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 209519202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 2096bf543036SJohan Hedberg } 2097ab81cbf9SJohan Hedberg 2098fee746b0SMarcel Holtmann if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) { 20994a964404SMarcel Holtmann /* For unconfigured devices, set the HCI_RAW flag 21004a964404SMarcel Holtmann * so that userspace can easily identify them. 21014a964404SMarcel Holtmann */ 21024a964404SMarcel Holtmann if (test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 21034a964404SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 21040602a8adSMarcel Holtmann 21050602a8adSMarcel Holtmann /* For fully configured devices, this will send 21060602a8adSMarcel Holtmann * the Index Added event. For unconfigured devices, 21070602a8adSMarcel Holtmann * it will send Unconfigued Index Added event. 21080602a8adSMarcel Holtmann * 21090602a8adSMarcel Holtmann * Devices with HCI_QUIRK_RAW_DEVICE are ignored 21100602a8adSMarcel Holtmann * and no event will be send. 21110602a8adSMarcel Holtmann */ 2112744cf19eSJohan Hedberg mgmt_index_added(hdev); 2113d603b76bSMarcel Holtmann } else if (test_and_clear_bit(HCI_CONFIG, &hdev->dev_flags)) { 21145ea234d3SMarcel Holtmann /* When the controller is now configured, then it 21155ea234d3SMarcel Holtmann * is important to clear the HCI_RAW flag. 21165ea234d3SMarcel Holtmann */ 21175ea234d3SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) 21185ea234d3SMarcel Holtmann clear_bit(HCI_RAW, &hdev->flags); 21195ea234d3SMarcel Holtmann 2120d603b76bSMarcel Holtmann /* Powering on the controller with HCI_CONFIG set only 2121d603b76bSMarcel Holtmann * happens with the transition from unconfigured to 2122d603b76bSMarcel Holtmann * configured. This will send the Index Added event. 2123d603b76bSMarcel Holtmann */ 2124d603b76bSMarcel Holtmann mgmt_index_added(hdev); 2125ab81cbf9SJohan Hedberg } 2126ab81cbf9SJohan Hedberg } 2127ab81cbf9SJohan Hedberg 2128ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 2129ab81cbf9SJohan Hedberg { 21303243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 21313243553fSJohan Hedberg power_off.work); 2132ab81cbf9SJohan Hedberg 2133ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 2134ab81cbf9SJohan Hedberg 21358ee56540SMarcel Holtmann hci_dev_do_close(hdev); 2136ab81cbf9SJohan Hedberg } 2137ab81cbf9SJohan Hedberg 213816ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 213916ab91abSJohan Hedberg { 214016ab91abSJohan Hedberg struct hci_dev *hdev; 214116ab91abSJohan Hedberg 214216ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 214316ab91abSJohan Hedberg 214416ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 214516ab91abSJohan Hedberg 2146d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 214716ab91abSJohan Hedberg } 214816ab91abSJohan Hedberg 214935f7498aSJohan Hedberg void hci_uuids_clear(struct hci_dev *hdev) 21502aeb9a1aSJohan Hedberg { 21514821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 21522aeb9a1aSJohan Hedberg 21534821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 21544821002cSJohan Hedberg list_del(&uuid->list); 21552aeb9a1aSJohan Hedberg kfree(uuid); 21562aeb9a1aSJohan Hedberg } 21572aeb9a1aSJohan Hedberg } 21582aeb9a1aSJohan Hedberg 215935f7498aSJohan Hedberg void hci_link_keys_clear(struct hci_dev *hdev) 216055ed8ca1SJohan Hedberg { 216155ed8ca1SJohan Hedberg struct link_key *key; 216255ed8ca1SJohan Hedberg 21630378b597SJohan Hedberg list_for_each_entry_rcu(key, &hdev->link_keys, list) { 21640378b597SJohan Hedberg list_del_rcu(&key->list); 21650378b597SJohan Hedberg kfree_rcu(key, rcu); 216655ed8ca1SJohan Hedberg } 216755ed8ca1SJohan Hedberg } 216855ed8ca1SJohan Hedberg 216935f7498aSJohan Hedberg void hci_smp_ltks_clear(struct hci_dev *hdev) 2170b899efafSVinicius Costa Gomes { 2171970d0f1bSJohan Hedberg struct smp_ltk *k; 2172b899efafSVinicius Costa Gomes 2173970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2174970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2175970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2176b899efafSVinicius Costa Gomes } 2177b899efafSVinicius Costa Gomes } 2178b899efafSVinicius Costa Gomes 2179970c4e46SJohan Hedberg void hci_smp_irks_clear(struct hci_dev *hdev) 2180970c4e46SJohan Hedberg { 2181adae20cbSJohan Hedberg struct smp_irk *k; 2182970c4e46SJohan Hedberg 2183adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2184adae20cbSJohan Hedberg list_del_rcu(&k->list); 2185adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2186970c4e46SJohan Hedberg } 2187970c4e46SJohan Hedberg } 2188970c4e46SJohan Hedberg 218955ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 219055ed8ca1SJohan Hedberg { 219155ed8ca1SJohan Hedberg struct link_key *k; 219255ed8ca1SJohan Hedberg 21930378b597SJohan Hedberg rcu_read_lock(); 21940378b597SJohan Hedberg list_for_each_entry_rcu(k, &hdev->link_keys, list) { 21950378b597SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) { 21960378b597SJohan Hedberg rcu_read_unlock(); 219755ed8ca1SJohan Hedberg return k; 21980378b597SJohan Hedberg } 21990378b597SJohan Hedberg } 22000378b597SJohan Hedberg rcu_read_unlock(); 220155ed8ca1SJohan Hedberg 220255ed8ca1SJohan Hedberg return NULL; 220355ed8ca1SJohan Hedberg } 220455ed8ca1SJohan Hedberg 2205745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 2206d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 2207d25e28abSJohan Hedberg { 2208d25e28abSJohan Hedberg /* Legacy key */ 2209d25e28abSJohan Hedberg if (key_type < 0x03) 2210745c0ce3SVishal Agarwal return true; 2211d25e28abSJohan Hedberg 2212d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 2213d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 2214745c0ce3SVishal Agarwal return false; 2215d25e28abSJohan Hedberg 2216d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 2217d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 2218745c0ce3SVishal Agarwal return false; 2219d25e28abSJohan Hedberg 2220d25e28abSJohan Hedberg /* Security mode 3 case */ 2221d25e28abSJohan Hedberg if (!conn) 2222745c0ce3SVishal Agarwal return true; 2223d25e28abSJohan Hedberg 2224e3befab9SJohan Hedberg /* BR/EDR key derived using SC from an LE link */ 2225e3befab9SJohan Hedberg if (conn->type == LE_LINK) 2226e3befab9SJohan Hedberg return true; 2227e3befab9SJohan Hedberg 2228d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 2229d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 2230745c0ce3SVishal Agarwal return true; 2231d25e28abSJohan Hedberg 2232d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 2233d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 2234745c0ce3SVishal Agarwal return true; 2235d25e28abSJohan Hedberg 2236d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 2237d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 2238745c0ce3SVishal Agarwal return true; 2239d25e28abSJohan Hedberg 2240d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 2241d25e28abSJohan Hedberg * persistently */ 2242745c0ce3SVishal Agarwal return false; 2243d25e28abSJohan Hedberg } 2244d25e28abSJohan Hedberg 2245e804d25dSJohan Hedberg static u8 ltk_role(u8 type) 224698a0b845SJohan Hedberg { 2247e804d25dSJohan Hedberg if (type == SMP_LTK) 2248e804d25dSJohan Hedberg return HCI_ROLE_MASTER; 224998a0b845SJohan Hedberg 2250e804d25dSJohan Hedberg return HCI_ROLE_SLAVE; 225198a0b845SJohan Hedberg } 225298a0b845SJohan Hedberg 2253f3a73d97SJohan Hedberg struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2254e804d25dSJohan Hedberg u8 addr_type, u8 role) 225575d262c2SVinicius Costa Gomes { 2256c9839a11SVinicius Costa Gomes struct smp_ltk *k; 225775d262c2SVinicius Costa Gomes 2258970d0f1bSJohan Hedberg rcu_read_lock(); 2259970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 22605378bc56SJohan Hedberg if (addr_type != k->bdaddr_type || bacmp(bdaddr, &k->bdaddr)) 22615378bc56SJohan Hedberg continue; 22625378bc56SJohan Hedberg 2263923e2414SJohan Hedberg if (smp_ltk_is_sc(k) || ltk_role(k->type) == role) { 2264970d0f1bSJohan Hedberg rcu_read_unlock(); 226575d262c2SVinicius Costa Gomes return k; 2266970d0f1bSJohan Hedberg } 2267970d0f1bSJohan Hedberg } 2268970d0f1bSJohan Hedberg rcu_read_unlock(); 226975d262c2SVinicius Costa Gomes 227075d262c2SVinicius Costa Gomes return NULL; 227175d262c2SVinicius Costa Gomes } 227275d262c2SVinicius Costa Gomes 2273970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_rpa(struct hci_dev *hdev, bdaddr_t *rpa) 2274970c4e46SJohan Hedberg { 2275970c4e46SJohan Hedberg struct smp_irk *irk; 2276970c4e46SJohan Hedberg 2277adae20cbSJohan Hedberg rcu_read_lock(); 2278adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2279adae20cbSJohan Hedberg if (!bacmp(&irk->rpa, rpa)) { 2280adae20cbSJohan Hedberg rcu_read_unlock(); 2281970c4e46SJohan Hedberg return irk; 2282970c4e46SJohan Hedberg } 2283adae20cbSJohan Hedberg } 2284970c4e46SJohan Hedberg 2285adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2286defce9e8SJohan Hedberg if (smp_irk_matches(hdev, irk->val, rpa)) { 2287970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2288adae20cbSJohan Hedberg rcu_read_unlock(); 2289970c4e46SJohan Hedberg return irk; 2290970c4e46SJohan Hedberg } 2291970c4e46SJohan Hedberg } 2292adae20cbSJohan Hedberg rcu_read_unlock(); 2293970c4e46SJohan Hedberg 2294970c4e46SJohan Hedberg return NULL; 2295970c4e46SJohan Hedberg } 2296970c4e46SJohan Hedberg 2297970c4e46SJohan Hedberg struct smp_irk *hci_find_irk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 2298970c4e46SJohan Hedberg u8 addr_type) 2299970c4e46SJohan Hedberg { 2300970c4e46SJohan Hedberg struct smp_irk *irk; 2301970c4e46SJohan Hedberg 23026cfc9988SJohan Hedberg /* Identity Address must be public or static random */ 23036cfc9988SJohan Hedberg if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0) 23046cfc9988SJohan Hedberg return NULL; 23056cfc9988SJohan Hedberg 2306adae20cbSJohan Hedberg rcu_read_lock(); 2307adae20cbSJohan Hedberg list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) { 2308970c4e46SJohan Hedberg if (addr_type == irk->addr_type && 2309adae20cbSJohan Hedberg bacmp(bdaddr, &irk->bdaddr) == 0) { 2310adae20cbSJohan Hedberg rcu_read_unlock(); 2311970c4e46SJohan Hedberg return irk; 2312970c4e46SJohan Hedberg } 2313adae20cbSJohan Hedberg } 2314adae20cbSJohan Hedberg rcu_read_unlock(); 2315970c4e46SJohan Hedberg 2316970c4e46SJohan Hedberg return NULL; 2317970c4e46SJohan Hedberg } 2318970c4e46SJohan Hedberg 2319567fa2aaSJohan Hedberg struct link_key *hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, 23207652ff6aSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, 23217652ff6aSJohan Hedberg u8 pin_len, bool *persistent) 232255ed8ca1SJohan Hedberg { 232355ed8ca1SJohan Hedberg struct link_key *key, *old_key; 2324745c0ce3SVishal Agarwal u8 old_key_type; 232555ed8ca1SJohan Hedberg 232655ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 232755ed8ca1SJohan Hedberg if (old_key) { 232855ed8ca1SJohan Hedberg old_key_type = old_key->type; 232955ed8ca1SJohan Hedberg key = old_key; 233055ed8ca1SJohan Hedberg } else { 233112adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 23320a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 233355ed8ca1SJohan Hedberg if (!key) 2334567fa2aaSJohan Hedberg return NULL; 23350378b597SJohan Hedberg list_add_rcu(&key->list, &hdev->link_keys); 233655ed8ca1SJohan Hedberg } 233755ed8ca1SJohan Hedberg 23386ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 233955ed8ca1SJohan Hedberg 2340d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2341d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2342d25e28abSJohan Hedberg * previous key */ 2343d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2344a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2345d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2346655fe6ecSJohan Hedberg if (conn) 2347655fe6ecSJohan Hedberg conn->key_type = type; 2348655fe6ecSJohan Hedberg } 2349d25e28abSJohan Hedberg 235055ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 23519b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 235255ed8ca1SJohan Hedberg key->pin_len = pin_len; 235355ed8ca1SJohan Hedberg 2354b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 235555ed8ca1SJohan Hedberg key->type = old_key_type; 23564748fed2SJohan Hedberg else 23574748fed2SJohan Hedberg key->type = type; 23584748fed2SJohan Hedberg 23597652ff6aSJohan Hedberg if (persistent) 23607652ff6aSJohan Hedberg *persistent = hci_persistent_key(hdev, conn, type, 23617652ff6aSJohan Hedberg old_key_type); 23624df378a1SJohan Hedberg 2363567fa2aaSJohan Hedberg return key; 236455ed8ca1SJohan Hedberg } 236555ed8ca1SJohan Hedberg 2366ca9142b8SJohan Hedberg struct smp_ltk *hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, 236735d70271SJohan Hedberg u8 addr_type, u8 type, u8 authenticated, 2368fe39c7b2SMarcel Holtmann u8 tk[16], u8 enc_size, __le16 ediv, __le64 rand) 236975d262c2SVinicius Costa Gomes { 2370c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 2371e804d25dSJohan Hedberg u8 role = ltk_role(type); 237275d262c2SVinicius Costa Gomes 2373f3a73d97SJohan Hedberg old_key = hci_find_ltk(hdev, bdaddr, addr_type, role); 2374c9839a11SVinicius Costa Gomes if (old_key) 237575d262c2SVinicius Costa Gomes key = old_key; 2376c9839a11SVinicius Costa Gomes else { 23770a14ab41SJohan Hedberg key = kzalloc(sizeof(*key), GFP_KERNEL); 237875d262c2SVinicius Costa Gomes if (!key) 2379ca9142b8SJohan Hedberg return NULL; 2380970d0f1bSJohan Hedberg list_add_rcu(&key->list, &hdev->long_term_keys); 238175d262c2SVinicius Costa Gomes } 238275d262c2SVinicius Costa Gomes 238375d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2384c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2385c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2386c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2387c9839a11SVinicius Costa Gomes key->ediv = ediv; 2388fe39c7b2SMarcel Holtmann key->rand = rand; 2389c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2390c9839a11SVinicius Costa Gomes key->type = type; 239175d262c2SVinicius Costa Gomes 2392ca9142b8SJohan Hedberg return key; 239375d262c2SVinicius Costa Gomes } 239475d262c2SVinicius Costa Gomes 2395ca9142b8SJohan Hedberg struct smp_irk *hci_add_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, 2396ca9142b8SJohan Hedberg u8 addr_type, u8 val[16], bdaddr_t *rpa) 2397970c4e46SJohan Hedberg { 2398970c4e46SJohan Hedberg struct smp_irk *irk; 2399970c4e46SJohan Hedberg 2400970c4e46SJohan Hedberg irk = hci_find_irk_by_addr(hdev, bdaddr, addr_type); 2401970c4e46SJohan Hedberg if (!irk) { 2402970c4e46SJohan Hedberg irk = kzalloc(sizeof(*irk), GFP_KERNEL); 2403970c4e46SJohan Hedberg if (!irk) 2404ca9142b8SJohan Hedberg return NULL; 2405970c4e46SJohan Hedberg 2406970c4e46SJohan Hedberg bacpy(&irk->bdaddr, bdaddr); 2407970c4e46SJohan Hedberg irk->addr_type = addr_type; 2408970c4e46SJohan Hedberg 2409adae20cbSJohan Hedberg list_add_rcu(&irk->list, &hdev->identity_resolving_keys); 2410970c4e46SJohan Hedberg } 2411970c4e46SJohan Hedberg 2412970c4e46SJohan Hedberg memcpy(irk->val, val, 16); 2413970c4e46SJohan Hedberg bacpy(&irk->rpa, rpa); 2414970c4e46SJohan Hedberg 2415ca9142b8SJohan Hedberg return irk; 2416970c4e46SJohan Hedberg } 2417970c4e46SJohan Hedberg 241855ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 241955ed8ca1SJohan Hedberg { 242055ed8ca1SJohan Hedberg struct link_key *key; 242155ed8ca1SJohan Hedberg 242255ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 242355ed8ca1SJohan Hedberg if (!key) 242455ed8ca1SJohan Hedberg return -ENOENT; 242555ed8ca1SJohan Hedberg 24266ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 242755ed8ca1SJohan Hedberg 24280378b597SJohan Hedberg list_del_rcu(&key->list); 24290378b597SJohan Hedberg kfree_rcu(key, rcu); 243055ed8ca1SJohan Hedberg 243155ed8ca1SJohan Hedberg return 0; 243255ed8ca1SJohan Hedberg } 243355ed8ca1SJohan Hedberg 2434e0b2b27eSJohan Hedberg int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 bdaddr_type) 2435b899efafSVinicius Costa Gomes { 2436970d0f1bSJohan Hedberg struct smp_ltk *k; 2437c51ffa0bSJohan Hedberg int removed = 0; 2438b899efafSVinicius Costa Gomes 2439970d0f1bSJohan Hedberg list_for_each_entry_rcu(k, &hdev->long_term_keys, list) { 2440e0b2b27eSJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type) 2441b899efafSVinicius Costa Gomes continue; 2442b899efafSVinicius Costa Gomes 24436ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2444b899efafSVinicius Costa Gomes 2445970d0f1bSJohan Hedberg list_del_rcu(&k->list); 2446970d0f1bSJohan Hedberg kfree_rcu(k, rcu); 2447c51ffa0bSJohan Hedberg removed++; 2448b899efafSVinicius Costa Gomes } 2449b899efafSVinicius Costa Gomes 2450c51ffa0bSJohan Hedberg return removed ? 0 : -ENOENT; 2451b899efafSVinicius Costa Gomes } 2452b899efafSVinicius Costa Gomes 2453a7ec7338SJohan Hedberg void hci_remove_irk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type) 2454a7ec7338SJohan Hedberg { 2455adae20cbSJohan Hedberg struct smp_irk *k; 2456a7ec7338SJohan Hedberg 2457adae20cbSJohan Hedberg list_for_each_entry_rcu(k, &hdev->identity_resolving_keys, list) { 2458a7ec7338SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type) 2459a7ec7338SJohan Hedberg continue; 2460a7ec7338SJohan Hedberg 2461a7ec7338SJohan Hedberg BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2462a7ec7338SJohan Hedberg 2463adae20cbSJohan Hedberg list_del_rcu(&k->list); 2464adae20cbSJohan Hedberg kfree_rcu(k, rcu); 2465a7ec7338SJohan Hedberg } 2466a7ec7338SJohan Hedberg } 2467a7ec7338SJohan Hedberg 24686bd32326SVille Tervo /* HCI command timer function */ 246965cc2b49SMarcel Holtmann static void hci_cmd_timeout(struct work_struct *work) 24706bd32326SVille Tervo { 247165cc2b49SMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, 247265cc2b49SMarcel Holtmann cmd_timer.work); 24736bd32326SVille Tervo 2474bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2475bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2476bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2477bda4f23aSAndrei Emeltchenko 2478bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 2479bda4f23aSAndrei Emeltchenko } else { 24806bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 2481bda4f23aSAndrei Emeltchenko } 2482bda4f23aSAndrei Emeltchenko 24836bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2484c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 24856bd32326SVille Tervo } 24866bd32326SVille Tervo 24872763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 24886928a924SJohan Hedberg bdaddr_t *bdaddr, u8 bdaddr_type) 24892763eda6SSzymon Janc { 24902763eda6SSzymon Janc struct oob_data *data; 24912763eda6SSzymon Janc 24926928a924SJohan Hedberg list_for_each_entry(data, &hdev->remote_oob_data, list) { 24936928a924SJohan Hedberg if (bacmp(bdaddr, &data->bdaddr) != 0) 24946928a924SJohan Hedberg continue; 24956928a924SJohan Hedberg if (data->bdaddr_type != bdaddr_type) 24966928a924SJohan Hedberg continue; 24972763eda6SSzymon Janc return data; 24986928a924SJohan Hedberg } 24992763eda6SSzymon Janc 25002763eda6SSzymon Janc return NULL; 25012763eda6SSzymon Janc } 25022763eda6SSzymon Janc 25036928a924SJohan Hedberg int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 25046928a924SJohan Hedberg u8 bdaddr_type) 25052763eda6SSzymon Janc { 25062763eda6SSzymon Janc struct oob_data *data; 25072763eda6SSzymon Janc 25086928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 25092763eda6SSzymon Janc if (!data) 25102763eda6SSzymon Janc return -ENOENT; 25112763eda6SSzymon Janc 25126928a924SJohan Hedberg BT_DBG("%s removing %pMR (%u)", hdev->name, bdaddr, bdaddr_type); 25132763eda6SSzymon Janc 25142763eda6SSzymon Janc list_del(&data->list); 25152763eda6SSzymon Janc kfree(data); 25162763eda6SSzymon Janc 25172763eda6SSzymon Janc return 0; 25182763eda6SSzymon Janc } 25192763eda6SSzymon Janc 252035f7498aSJohan Hedberg void hci_remote_oob_data_clear(struct hci_dev *hdev) 25212763eda6SSzymon Janc { 25222763eda6SSzymon Janc struct oob_data *data, *n; 25232763eda6SSzymon Janc 25242763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 25252763eda6SSzymon Janc list_del(&data->list); 25262763eda6SSzymon Janc kfree(data); 25272763eda6SSzymon Janc } 25282763eda6SSzymon Janc } 25292763eda6SSzymon Janc 25300798872eSMarcel Holtmann int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, 25316928a924SJohan Hedberg u8 bdaddr_type, u8 *hash192, u8 *rand192, 253238da1703SJohan Hedberg u8 *hash256, u8 *rand256) 25330798872eSMarcel Holtmann { 25340798872eSMarcel Holtmann struct oob_data *data; 25350798872eSMarcel Holtmann 25366928a924SJohan Hedberg data = hci_find_remote_oob_data(hdev, bdaddr, bdaddr_type); 25370798872eSMarcel Holtmann if (!data) { 25380a14ab41SJohan Hedberg data = kmalloc(sizeof(*data), GFP_KERNEL); 25390798872eSMarcel Holtmann if (!data) 25400798872eSMarcel Holtmann return -ENOMEM; 25410798872eSMarcel Holtmann 25420798872eSMarcel Holtmann bacpy(&data->bdaddr, bdaddr); 25436928a924SJohan Hedberg data->bdaddr_type = bdaddr_type; 25440798872eSMarcel Holtmann list_add(&data->list, &hdev->remote_oob_data); 25450798872eSMarcel Holtmann } 25460798872eSMarcel Holtmann 254781328d5cSJohan Hedberg if (hash192 && rand192) { 25480798872eSMarcel Holtmann memcpy(data->hash192, hash192, sizeof(data->hash192)); 254938da1703SJohan Hedberg memcpy(data->rand192, rand192, sizeof(data->rand192)); 255081328d5cSJohan Hedberg } else { 255181328d5cSJohan Hedberg memset(data->hash192, 0, sizeof(data->hash192)); 255281328d5cSJohan Hedberg memset(data->rand192, 0, sizeof(data->rand192)); 255381328d5cSJohan Hedberg } 25540798872eSMarcel Holtmann 255581328d5cSJohan Hedberg if (hash256 && rand256) { 25560798872eSMarcel Holtmann memcpy(data->hash256, hash256, sizeof(data->hash256)); 255738da1703SJohan Hedberg memcpy(data->rand256, rand256, sizeof(data->rand256)); 255881328d5cSJohan Hedberg } else { 255981328d5cSJohan Hedberg memset(data->hash256, 0, sizeof(data->hash256)); 256081328d5cSJohan Hedberg memset(data->rand256, 0, sizeof(data->rand256)); 256181328d5cSJohan Hedberg } 25620798872eSMarcel Holtmann 25636ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 25642763eda6SSzymon Janc 25652763eda6SSzymon Janc return 0; 25662763eda6SSzymon Janc } 25672763eda6SSzymon Janc 2568dcc36c16SJohan Hedberg struct bdaddr_list *hci_bdaddr_list_lookup(struct list_head *bdaddr_list, 2569b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2570b2a66aadSAntti Julku { 2571b2a66aadSAntti Julku struct bdaddr_list *b; 2572b2a66aadSAntti Julku 2573dcc36c16SJohan Hedberg list_for_each_entry(b, bdaddr_list, list) { 2574b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2575b2a66aadSAntti Julku return b; 2576b9ee0a78SMarcel Holtmann } 2577b2a66aadSAntti Julku 2578b2a66aadSAntti Julku return NULL; 2579b2a66aadSAntti Julku } 2580b2a66aadSAntti Julku 2581dcc36c16SJohan Hedberg void hci_bdaddr_list_clear(struct list_head *bdaddr_list) 2582b2a66aadSAntti Julku { 2583b2a66aadSAntti Julku struct list_head *p, *n; 2584b2a66aadSAntti Julku 2585dcc36c16SJohan Hedberg list_for_each_safe(p, n, bdaddr_list) { 2586b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 2587b2a66aadSAntti Julku 2588b2a66aadSAntti Julku list_del(p); 2589b2a66aadSAntti Julku kfree(b); 2590b2a66aadSAntti Julku } 2591b2a66aadSAntti Julku } 2592b2a66aadSAntti Julku 2593dcc36c16SJohan Hedberg int hci_bdaddr_list_add(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2594b2a66aadSAntti Julku { 2595b2a66aadSAntti Julku struct bdaddr_list *entry; 2596b2a66aadSAntti Julku 2597b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2598b2a66aadSAntti Julku return -EBADF; 2599b2a66aadSAntti Julku 2600dcc36c16SJohan Hedberg if (hci_bdaddr_list_lookup(list, bdaddr, type)) 26015e762444SAntti Julku return -EEXIST; 2602b2a66aadSAntti Julku 260327f70f3eSJohan Hedberg entry = kzalloc(sizeof(*entry), GFP_KERNEL); 26045e762444SAntti Julku if (!entry) 26055e762444SAntti Julku return -ENOMEM; 2606b2a66aadSAntti Julku 2607b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2608b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2609b2a66aadSAntti Julku 2610dcc36c16SJohan Hedberg list_add(&entry->list, list); 2611b2a66aadSAntti Julku 26122a8357f2SJohan Hedberg return 0; 2613b2a66aadSAntti Julku } 2614b2a66aadSAntti Julku 2615dcc36c16SJohan Hedberg int hci_bdaddr_list_del(struct list_head *list, bdaddr_t *bdaddr, u8 type) 2616b2a66aadSAntti Julku { 2617b2a66aadSAntti Julku struct bdaddr_list *entry; 2618b2a66aadSAntti Julku 261935f7498aSJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY)) { 2620dcc36c16SJohan Hedberg hci_bdaddr_list_clear(list); 262135f7498aSJohan Hedberg return 0; 262235f7498aSJohan Hedberg } 2623b2a66aadSAntti Julku 2624dcc36c16SJohan Hedberg entry = hci_bdaddr_list_lookup(list, bdaddr, type); 2625d2ab0ac1SMarcel Holtmann if (!entry) 2626d2ab0ac1SMarcel Holtmann return -ENOENT; 2627d2ab0ac1SMarcel Holtmann 2628d2ab0ac1SMarcel Holtmann list_del(&entry->list); 2629d2ab0ac1SMarcel Holtmann kfree(entry); 2630d2ab0ac1SMarcel Holtmann 2631d2ab0ac1SMarcel Holtmann return 0; 2632d2ab0ac1SMarcel Holtmann } 2633d2ab0ac1SMarcel Holtmann 263415819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 263515819a70SAndre Guedes struct hci_conn_params *hci_conn_params_lookup(struct hci_dev *hdev, 263615819a70SAndre Guedes bdaddr_t *addr, u8 addr_type) 263715819a70SAndre Guedes { 263815819a70SAndre Guedes struct hci_conn_params *params; 263915819a70SAndre Guedes 2640738f6185SJohan Hedberg /* The conn params list only contains identity addresses */ 2641738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 2642738f6185SJohan Hedberg return NULL; 2643738f6185SJohan Hedberg 264415819a70SAndre Guedes list_for_each_entry(params, &hdev->le_conn_params, list) { 264515819a70SAndre Guedes if (bacmp(¶ms->addr, addr) == 0 && 264615819a70SAndre Guedes params->addr_type == addr_type) { 264715819a70SAndre Guedes return params; 264815819a70SAndre Guedes } 264915819a70SAndre Guedes } 265015819a70SAndre Guedes 265115819a70SAndre Guedes return NULL; 265215819a70SAndre Guedes } 265315819a70SAndre Guedes 265415819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 2655501f8827SJohan Hedberg struct hci_conn_params *hci_pend_le_action_lookup(struct list_head *list, 26564b10966fSMarcel Holtmann bdaddr_t *addr, u8 addr_type) 265715819a70SAndre Guedes { 2658912b42efSJohan Hedberg struct hci_conn_params *param; 265915819a70SAndre Guedes 2660738f6185SJohan Hedberg /* The list only contains identity addresses */ 2661738f6185SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 2662738f6185SJohan Hedberg return NULL; 266315819a70SAndre Guedes 2664501f8827SJohan Hedberg list_for_each_entry(param, list, action) { 2665912b42efSJohan Hedberg if (bacmp(¶m->addr, addr) == 0 && 2666912b42efSJohan Hedberg param->addr_type == addr_type) 2667912b42efSJohan Hedberg return param; 26684b10966fSMarcel Holtmann } 26694b10966fSMarcel Holtmann 26704b10966fSMarcel Holtmann return NULL; 267115819a70SAndre Guedes } 267215819a70SAndre Guedes 267315819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 267451d167c0SMarcel Holtmann struct hci_conn_params *hci_conn_params_add(struct hci_dev *hdev, 267551d167c0SMarcel Holtmann bdaddr_t *addr, u8 addr_type) 267615819a70SAndre Guedes { 267715819a70SAndre Guedes struct hci_conn_params *params; 267815819a70SAndre Guedes 2679c46245b3SJohan Hedberg if (!hci_is_identity_address(addr, addr_type)) 268051d167c0SMarcel Holtmann return NULL; 2681a9b0a04cSAndre Guedes 268215819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 2683cef952ceSAndre Guedes if (params) 268451d167c0SMarcel Holtmann return params; 268515819a70SAndre Guedes 268615819a70SAndre Guedes params = kzalloc(sizeof(*params), GFP_KERNEL); 268715819a70SAndre Guedes if (!params) { 268815819a70SAndre Guedes BT_ERR("Out of memory"); 268951d167c0SMarcel Holtmann return NULL; 269015819a70SAndre Guedes } 269115819a70SAndre Guedes 269215819a70SAndre Guedes bacpy(¶ms->addr, addr); 269315819a70SAndre Guedes params->addr_type = addr_type; 2694cef952ceSAndre Guedes 2695cef952ceSAndre Guedes list_add(¶ms->list, &hdev->le_conn_params); 269693450c75SJohan Hedberg INIT_LIST_HEAD(¶ms->action); 2697cef952ceSAndre Guedes 2698bf5b3c8bSMarcel Holtmann params->conn_min_interval = hdev->le_conn_min_interval; 2699bf5b3c8bSMarcel Holtmann params->conn_max_interval = hdev->le_conn_max_interval; 2700bf5b3c8bSMarcel Holtmann params->conn_latency = hdev->le_conn_latency; 2701bf5b3c8bSMarcel Holtmann params->supervision_timeout = hdev->le_supv_timeout; 2702bf5b3c8bSMarcel Holtmann params->auto_connect = HCI_AUTO_CONN_DISABLED; 2703bf5b3c8bSMarcel Holtmann 2704bf5b3c8bSMarcel Holtmann BT_DBG("addr %pMR (type %u)", addr, addr_type); 2705bf5b3c8bSMarcel Holtmann 270651d167c0SMarcel Holtmann return params; 2707bf5b3c8bSMarcel Holtmann } 2708bf5b3c8bSMarcel Holtmann 2709f6c63249SJohan Hedberg static void hci_conn_params_free(struct hci_conn_params *params) 2710f6c63249SJohan Hedberg { 2711f6c63249SJohan Hedberg if (params->conn) { 2712f6c63249SJohan Hedberg hci_conn_drop(params->conn); 2713f6c63249SJohan Hedberg hci_conn_put(params->conn); 2714f6c63249SJohan Hedberg } 2715f6c63249SJohan Hedberg 2716f6c63249SJohan Hedberg list_del(¶ms->action); 2717f6c63249SJohan Hedberg list_del(¶ms->list); 2718f6c63249SJohan Hedberg kfree(params); 2719f6c63249SJohan Hedberg } 2720f6c63249SJohan Hedberg 272115819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 272215819a70SAndre Guedes void hci_conn_params_del(struct hci_dev *hdev, bdaddr_t *addr, u8 addr_type) 272315819a70SAndre Guedes { 272415819a70SAndre Guedes struct hci_conn_params *params; 272515819a70SAndre Guedes 272615819a70SAndre Guedes params = hci_conn_params_lookup(hdev, addr, addr_type); 272715819a70SAndre Guedes if (!params) 272815819a70SAndre Guedes return; 272915819a70SAndre Guedes 2730f6c63249SJohan Hedberg hci_conn_params_free(params); 273115819a70SAndre Guedes 273295305baaSJohan Hedberg hci_update_background_scan(hdev); 273395305baaSJohan Hedberg 273415819a70SAndre Guedes BT_DBG("addr %pMR (type %u)", addr, addr_type); 273515819a70SAndre Guedes } 273615819a70SAndre Guedes 273715819a70SAndre Guedes /* This function requires the caller holds hdev->lock */ 273855af49a8SJohan Hedberg void hci_conn_params_clear_disabled(struct hci_dev *hdev) 273915819a70SAndre Guedes { 274015819a70SAndre Guedes struct hci_conn_params *params, *tmp; 274115819a70SAndre Guedes 274215819a70SAndre Guedes list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) { 274355af49a8SJohan Hedberg if (params->auto_connect != HCI_AUTO_CONN_DISABLED) 274455af49a8SJohan Hedberg continue; 274515819a70SAndre Guedes list_del(¶ms->list); 274615819a70SAndre Guedes kfree(params); 274715819a70SAndre Guedes } 274815819a70SAndre Guedes 274955af49a8SJohan Hedberg BT_DBG("All LE disabled connection parameters were removed"); 275055af49a8SJohan Hedberg } 275155af49a8SJohan Hedberg 275255af49a8SJohan Hedberg /* This function requires the caller holds hdev->lock */ 2753373110c5SJohan Hedberg void hci_conn_params_clear_all(struct hci_dev *hdev) 275415819a70SAndre Guedes { 275515819a70SAndre Guedes struct hci_conn_params *params, *tmp; 275615819a70SAndre Guedes 2757f6c63249SJohan Hedberg list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) 2758f6c63249SJohan Hedberg hci_conn_params_free(params); 275915819a70SAndre Guedes 2760a2f41a8fSJohan Hedberg hci_update_background_scan(hdev); 27611089b67dSMarcel Holtmann 276215819a70SAndre Guedes BT_DBG("All LE connection parameters were removed"); 276315819a70SAndre Guedes } 276415819a70SAndre Guedes 27651904a853SMarcel Holtmann static void inquiry_complete(struct hci_dev *hdev, u8 status, u16 opcode) 27667ba8b4beSAndre Guedes { 27674c87eaabSAndre Guedes if (status) { 27684c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 27697ba8b4beSAndre Guedes 27704c87eaabSAndre Guedes hci_dev_lock(hdev); 27714c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 27724c87eaabSAndre Guedes hci_dev_unlock(hdev); 27734c87eaabSAndre Guedes return; 27744c87eaabSAndre Guedes } 27757ba8b4beSAndre Guedes } 27767ba8b4beSAndre Guedes 27771904a853SMarcel Holtmann static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status, 27781904a853SMarcel Holtmann u16 opcode) 27797ba8b4beSAndre Guedes { 27804c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 27814c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 27824c87eaabSAndre Guedes struct hci_request req; 27834c87eaabSAndre Guedes struct hci_cp_inquiry cp; 27847ba8b4beSAndre Guedes int err; 27857ba8b4beSAndre Guedes 27864c87eaabSAndre Guedes if (status) { 27874c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 27884c87eaabSAndre Guedes return; 27897ba8b4beSAndre Guedes } 27907ba8b4beSAndre Guedes 27914c87eaabSAndre Guedes switch (hdev->discovery.type) { 27924c87eaabSAndre Guedes case DISCOV_TYPE_LE: 27934c87eaabSAndre Guedes hci_dev_lock(hdev); 27944c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 27954c87eaabSAndre Guedes hci_dev_unlock(hdev); 27964c87eaabSAndre Guedes break; 27977dbfac1dSAndre Guedes 27984c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 27994c87eaabSAndre Guedes hci_req_init(&req, hdev); 28007dbfac1dSAndre Guedes 28017dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 28024c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 28034c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 28044c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 28054c87eaabSAndre Guedes 28064c87eaabSAndre Guedes hci_dev_lock(hdev); 28074c87eaabSAndre Guedes 28084c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 28094c87eaabSAndre Guedes 28104c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 28114c87eaabSAndre Guedes if (err) { 28124c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 28134c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 28147dbfac1dSAndre Guedes } 28157dbfac1dSAndre Guedes 28164c87eaabSAndre Guedes hci_dev_unlock(hdev); 28174c87eaabSAndre Guedes break; 28184c87eaabSAndre Guedes } 28197dbfac1dSAndre Guedes } 28207dbfac1dSAndre Guedes 28217ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 28227ba8b4beSAndre Guedes { 28237ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 28247ba8b4beSAndre Guedes le_scan_disable.work); 28254c87eaabSAndre Guedes struct hci_request req; 28264c87eaabSAndre Guedes int err; 28277ba8b4beSAndre Guedes 28287ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 28297ba8b4beSAndre Guedes 28304c87eaabSAndre Guedes hci_req_init(&req, hdev); 28317ba8b4beSAndre Guedes 2832b1efcc28SAndre Guedes hci_req_add_le_scan_disable(&req); 28337ba8b4beSAndre Guedes 28344c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 28354c87eaabSAndre Guedes if (err) 28364c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 283728b75a89SAndre Guedes } 283828b75a89SAndre Guedes 2839a1f4c318SJohan Hedberg /* Copy the Identity Address of the controller. 2840a1f4c318SJohan Hedberg * 2841a1f4c318SJohan Hedberg * If the controller has a public BD_ADDR, then by default use that one. 2842a1f4c318SJohan Hedberg * If this is a LE only controller without a public address, default to 2843a1f4c318SJohan Hedberg * the static random address. 2844a1f4c318SJohan Hedberg * 2845a1f4c318SJohan Hedberg * For debugging purposes it is possible to force controllers with a 2846a1f4c318SJohan Hedberg * public address to use the static random address instead. 284750b5b952SMarcel Holtmann * 284850b5b952SMarcel Holtmann * In case BR/EDR has been disabled on a dual-mode controller and 284950b5b952SMarcel Holtmann * userspace has configured a static address, then that address 285050b5b952SMarcel Holtmann * becomes the identity address instead of the public BR/EDR address. 2851a1f4c318SJohan Hedberg */ 2852a1f4c318SJohan Hedberg void hci_copy_identity_address(struct hci_dev *hdev, bdaddr_t *bdaddr, 2853a1f4c318SJohan Hedberg u8 *bdaddr_type) 2854a1f4c318SJohan Hedberg { 2855111902f7SMarcel Holtmann if (test_bit(HCI_FORCE_STATIC_ADDR, &hdev->dbg_flags) || 285650b5b952SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) || 285750b5b952SMarcel Holtmann (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags) && 285850b5b952SMarcel Holtmann bacmp(&hdev->static_addr, BDADDR_ANY))) { 2859a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->static_addr); 2860a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_RANDOM; 2861a1f4c318SJohan Hedberg } else { 2862a1f4c318SJohan Hedberg bacpy(bdaddr, &hdev->bdaddr); 2863a1f4c318SJohan Hedberg *bdaddr_type = ADDR_LE_DEV_PUBLIC; 2864a1f4c318SJohan Hedberg } 2865a1f4c318SJohan Hedberg } 2866a1f4c318SJohan Hedberg 28679be0dab7SDavid Herrmann /* Alloc HCI device */ 28689be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 28699be0dab7SDavid Herrmann { 28709be0dab7SDavid Herrmann struct hci_dev *hdev; 28719be0dab7SDavid Herrmann 287227f70f3eSJohan Hedberg hdev = kzalloc(sizeof(*hdev), GFP_KERNEL); 28739be0dab7SDavid Herrmann if (!hdev) 28749be0dab7SDavid Herrmann return NULL; 28759be0dab7SDavid Herrmann 2876b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 2877b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 2878b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 2879b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 2880b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 288196c2103aSMarcel Holtmann hdev->manufacturer = 0xffff; /* Default to internal use */ 2882bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 2883bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 2884b1b813d4SDavid Herrmann 2885b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 2886b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 2887b1b813d4SDavid Herrmann 28883f959d46SMarcel Holtmann hdev->le_adv_channel_map = 0x07; 2889628531c9SGeorg Lukas hdev->le_adv_min_interval = 0x0800; 2890628531c9SGeorg Lukas hdev->le_adv_max_interval = 0x0800; 2891bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 2892bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 28934e70c7e7SMarcel Holtmann hdev->le_conn_min_interval = 0x0028; 28944e70c7e7SMarcel Holtmann hdev->le_conn_max_interval = 0x0038; 289504fb7d90SMarcel Holtmann hdev->le_conn_latency = 0x0000; 289604fb7d90SMarcel Holtmann hdev->le_supv_timeout = 0x002a; 2897a8e1bfaaSMarcel Holtmann hdev->le_def_tx_len = 0x001b; 2898a8e1bfaaSMarcel Holtmann hdev->le_def_tx_time = 0x0148; 2899a8e1bfaaSMarcel Holtmann hdev->le_max_tx_len = 0x001b; 2900a8e1bfaaSMarcel Holtmann hdev->le_max_tx_time = 0x0148; 2901a8e1bfaaSMarcel Holtmann hdev->le_max_rx_len = 0x001b; 2902a8e1bfaaSMarcel Holtmann hdev->le_max_rx_time = 0x0148; 2903bef64738SMarcel Holtmann 2904d6bfd59cSJohan Hedberg hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT; 2905b9a7a61eSLukasz Rymanowski hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT; 290631ad1691SAndrzej Kaczmarek hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE; 290731ad1691SAndrzej Kaczmarek hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE; 2908d6bfd59cSJohan Hedberg 2909b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 2910b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 2911b1b813d4SDavid Herrmann 2912b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 2913b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 29146659358eSJohan Hedberg INIT_LIST_HEAD(&hdev->whitelist); 2915b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 2916b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 2917b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 2918970c4e46SJohan Hedberg INIT_LIST_HEAD(&hdev->identity_resolving_keys); 2919b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 2920d2ab0ac1SMarcel Holtmann INIT_LIST_HEAD(&hdev->le_white_list); 292115819a70SAndre Guedes INIT_LIST_HEAD(&hdev->le_conn_params); 292277a77a30SAndre Guedes INIT_LIST_HEAD(&hdev->pend_le_conns); 292366f8455aSJohan Hedberg INIT_LIST_HEAD(&hdev->pend_le_reports); 29246b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 2925b1b813d4SDavid Herrmann 2926b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 2927b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 2928b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 2929b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 2930b1b813d4SDavid Herrmann 2931b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 2932b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 2933b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 2934b1b813d4SDavid Herrmann 2935b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 2936b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 2937b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 2938b1b813d4SDavid Herrmann 2939b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 2940b1b813d4SDavid Herrmann 294165cc2b49SMarcel Holtmann INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout); 2942b1b813d4SDavid Herrmann 2943b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 2944b1b813d4SDavid Herrmann discovery_init(hdev); 29459be0dab7SDavid Herrmann 29469be0dab7SDavid Herrmann return hdev; 29479be0dab7SDavid Herrmann } 29489be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 29499be0dab7SDavid Herrmann 29509be0dab7SDavid Herrmann /* Free HCI device */ 29519be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 29529be0dab7SDavid Herrmann { 29539be0dab7SDavid Herrmann /* will free via device release */ 29549be0dab7SDavid Herrmann put_device(&hdev->dev); 29559be0dab7SDavid Herrmann } 29569be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 29579be0dab7SDavid Herrmann 29581da177e4SLinus Torvalds /* Register HCI device */ 29591da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 29601da177e4SLinus Torvalds { 2961b1b813d4SDavid Herrmann int id, error; 29621da177e4SLinus Torvalds 296374292d5aSMarcel Holtmann if (!hdev->open || !hdev->close || !hdev->send) 29641da177e4SLinus Torvalds return -EINVAL; 29651da177e4SLinus Torvalds 296608add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 296708add513SMat Martineau * so the index can be used as the AMP controller ID. 296808add513SMat Martineau */ 29693df92b31SSasha Levin switch (hdev->dev_type) { 29703df92b31SSasha Levin case HCI_BREDR: 29713df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 29721da177e4SLinus Torvalds break; 29733df92b31SSasha Levin case HCI_AMP: 29743df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 29753df92b31SSasha Levin break; 29763df92b31SSasha Levin default: 29773df92b31SSasha Levin return -EINVAL; 29781da177e4SLinus Torvalds } 29791da177e4SLinus Torvalds 29803df92b31SSasha Levin if (id < 0) 29813df92b31SSasha Levin return id; 29823df92b31SSasha Levin 29831da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 29841da177e4SLinus Torvalds hdev->id = id; 29852d8b3a11SAndrei Emeltchenko 29862d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 29872d8b3a11SAndrei Emeltchenko 2988d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 2989d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 299033ca954dSDavid Herrmann if (!hdev->workqueue) { 299133ca954dSDavid Herrmann error = -ENOMEM; 299233ca954dSDavid Herrmann goto err; 299333ca954dSDavid Herrmann } 2994f48fd9c8SMarcel Holtmann 2995d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 2996d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 29976ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 29986ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 29996ead1bbcSJohan Hedberg error = -ENOMEM; 30006ead1bbcSJohan Hedberg goto err; 30016ead1bbcSJohan Hedberg } 30026ead1bbcSJohan Hedberg 30030153e2ecSMarcel Holtmann if (!IS_ERR_OR_NULL(bt_debugfs)) 30040153e2ecSMarcel Holtmann hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs); 30050153e2ecSMarcel Holtmann 3006bdc3e0f1SMarcel Holtmann dev_set_name(&hdev->dev, "%s", hdev->name); 3007bdc3e0f1SMarcel Holtmann 3008bdc3e0f1SMarcel Holtmann error = device_add(&hdev->dev); 300933ca954dSDavid Herrmann if (error < 0) 301054506918SJohan Hedberg goto err_wqueue; 30111da177e4SLinus Torvalds 3012611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 3013a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 3014a8c5fb1aSGustavo Padovan hdev); 3015611b30f7SMarcel Holtmann if (hdev->rfkill) { 3016611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 3017611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3018611b30f7SMarcel Holtmann hdev->rfkill = NULL; 3019611b30f7SMarcel Holtmann } 3020611b30f7SMarcel Holtmann } 3021611b30f7SMarcel Holtmann 30225e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 30235e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 30245e130367SJohan Hedberg 3025a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 3026004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 3027ce2be9acSAndrei Emeltchenko 302801cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 302956f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 303056f87901SJohan Hedberg * through reading supported features during init. 303156f87901SJohan Hedberg */ 303256f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 303356f87901SJohan Hedberg } 3034ce2be9acSAndrei Emeltchenko 3035fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 3036fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 3037fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 3038fcee3377SGustavo Padovan 30394a964404SMarcel Holtmann /* Devices that are marked for raw-only usage are unconfigured 30404a964404SMarcel Holtmann * and should not be included in normal operation. 3041fee746b0SMarcel Holtmann */ 3042fee746b0SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 30434a964404SMarcel Holtmann set_bit(HCI_UNCONFIGURED, &hdev->dev_flags); 3044fee746b0SMarcel Holtmann 30451da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 3046dc946bd8SDavid Herrmann hci_dev_hold(hdev); 30471da177e4SLinus Torvalds 304819202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 3049fbe96d6fSMarcel Holtmann 30501da177e4SLinus Torvalds return id; 3051f48fd9c8SMarcel Holtmann 305233ca954dSDavid Herrmann err_wqueue: 305333ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 30546ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 305533ca954dSDavid Herrmann err: 30563df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 3057f48fd9c8SMarcel Holtmann 305833ca954dSDavid Herrmann return error; 30591da177e4SLinus Torvalds } 30601da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 30611da177e4SLinus Torvalds 30621da177e4SLinus Torvalds /* Unregister HCI device */ 306359735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 30641da177e4SLinus Torvalds { 30653df92b31SSasha Levin int i, id; 3066ef222013SMarcel Holtmann 3067c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 30681da177e4SLinus Torvalds 306994324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 307094324962SJohan Hovold 30713df92b31SSasha Levin id = hdev->id; 30723df92b31SSasha Levin 3073f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 30741da177e4SLinus Torvalds list_del(&hdev->list); 3075f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 30761da177e4SLinus Torvalds 30771da177e4SLinus Torvalds hci_dev_do_close(hdev); 30781da177e4SLinus Torvalds 3079cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 3080ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 3081ef222013SMarcel Holtmann 3082b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 3083b9b5ef18SGustavo Padovan 3084ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 3085d603b76bSMarcel Holtmann !test_bit(HCI_SETUP, &hdev->dev_flags) && 3086d603b76bSMarcel Holtmann !test_bit(HCI_CONFIG, &hdev->dev_flags)) { 308709fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3088744cf19eSJohan Hedberg mgmt_index_removed(hdev); 308909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 309056e5cb86SJohan Hedberg } 3091ab81cbf9SJohan Hedberg 30922e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 30932e58ef3eSJohan Hedberg * pending list */ 30942e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 30952e58ef3eSJohan Hedberg 30961da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 30971da177e4SLinus Torvalds 3098611b30f7SMarcel Holtmann if (hdev->rfkill) { 3099611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 3100611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 3101611b30f7SMarcel Holtmann } 3102611b30f7SMarcel Holtmann 3103711eafe3SJohan Hedberg smp_unregister(hdev); 310499780a7bSJohan Hedberg 3105bdc3e0f1SMarcel Holtmann device_del(&hdev->dev); 3106147e2d59SDave Young 31070153e2ecSMarcel Holtmann debugfs_remove_recursive(hdev->debugfs); 31080153e2ecSMarcel Holtmann 3109f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 31106ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 3111f48fd9c8SMarcel Holtmann 311209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 3113dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->blacklist); 31146659358eSJohan Hedberg hci_bdaddr_list_clear(&hdev->whitelist); 31152aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 311655ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 3117b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 3118970c4e46SJohan Hedberg hci_smp_irks_clear(hdev); 31192763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 3120dcc36c16SJohan Hedberg hci_bdaddr_list_clear(&hdev->le_white_list); 3121373110c5SJohan Hedberg hci_conn_params_clear_all(hdev); 312222078800SMarcel Holtmann hci_discovery_filter_clear(hdev); 312309fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 3124e2e0cacbSJohan Hedberg 3125dc946bd8SDavid Herrmann hci_dev_put(hdev); 31263df92b31SSasha Levin 31273df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 31281da177e4SLinus Torvalds } 31291da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 31301da177e4SLinus Torvalds 31311da177e4SLinus Torvalds /* Suspend HCI device */ 31321da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 31331da177e4SLinus Torvalds { 31341da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 31351da177e4SLinus Torvalds return 0; 31361da177e4SLinus Torvalds } 31371da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 31381da177e4SLinus Torvalds 31391da177e4SLinus Torvalds /* Resume HCI device */ 31401da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 31411da177e4SLinus Torvalds { 31421da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 31431da177e4SLinus Torvalds return 0; 31441da177e4SLinus Torvalds } 31451da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 31461da177e4SLinus Torvalds 314775e0569fSMarcel Holtmann /* Reset HCI device */ 314875e0569fSMarcel Holtmann int hci_reset_dev(struct hci_dev *hdev) 314975e0569fSMarcel Holtmann { 315075e0569fSMarcel Holtmann const u8 hw_err[] = { HCI_EV_HARDWARE_ERROR, 0x01, 0x00 }; 315175e0569fSMarcel Holtmann struct sk_buff *skb; 315275e0569fSMarcel Holtmann 315375e0569fSMarcel Holtmann skb = bt_skb_alloc(3, GFP_ATOMIC); 315475e0569fSMarcel Holtmann if (!skb) 315575e0569fSMarcel Holtmann return -ENOMEM; 315675e0569fSMarcel Holtmann 315775e0569fSMarcel Holtmann bt_cb(skb)->pkt_type = HCI_EVENT_PKT; 315875e0569fSMarcel Holtmann memcpy(skb_put(skb, 3), hw_err, 3); 315975e0569fSMarcel Holtmann 316075e0569fSMarcel Holtmann /* Send Hardware Error to upper stack */ 316175e0569fSMarcel Holtmann return hci_recv_frame(hdev, skb); 316275e0569fSMarcel Holtmann } 316375e0569fSMarcel Holtmann EXPORT_SYMBOL(hci_reset_dev); 316475e0569fSMarcel Holtmann 316576bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 3166e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 316776bca880SMarcel Holtmann { 316876bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 316976bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 317076bca880SMarcel Holtmann kfree_skb(skb); 317176bca880SMarcel Holtmann return -ENXIO; 317276bca880SMarcel Holtmann } 317376bca880SMarcel Holtmann 3174d82603c6SJorrit Schippers /* Incoming skb */ 317576bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 317676bca880SMarcel Holtmann 317776bca880SMarcel Holtmann /* Time stamp */ 317876bca880SMarcel Holtmann __net_timestamp(skb); 317976bca880SMarcel Holtmann 318076bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 3181b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 3182c78ae283SMarcel Holtmann 318376bca880SMarcel Holtmann return 0; 318476bca880SMarcel Holtmann } 318576bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 318676bca880SMarcel Holtmann 318733e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 31881e429f38SGustavo F. Padovan int count, __u8 index) 318933e882a5SSuraj Sumangala { 319033e882a5SSuraj Sumangala int len = 0; 319133e882a5SSuraj Sumangala int hlen = 0; 319233e882a5SSuraj Sumangala int remain = count; 319333e882a5SSuraj Sumangala struct sk_buff *skb; 319433e882a5SSuraj Sumangala struct bt_skb_cb *scb; 319533e882a5SSuraj Sumangala 319633e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 319733e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 319833e882a5SSuraj Sumangala return -EILSEQ; 319933e882a5SSuraj Sumangala 320033e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 320133e882a5SSuraj Sumangala 320233e882a5SSuraj Sumangala if (!skb) { 320333e882a5SSuraj Sumangala switch (type) { 320433e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 320533e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 320633e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 320733e882a5SSuraj Sumangala break; 320833e882a5SSuraj Sumangala case HCI_EVENT_PKT: 320933e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 321033e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 321133e882a5SSuraj Sumangala break; 321233e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 321333e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 321433e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 321533e882a5SSuraj Sumangala break; 321633e882a5SSuraj Sumangala } 321733e882a5SSuraj Sumangala 32181e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 321933e882a5SSuraj Sumangala if (!skb) 322033e882a5SSuraj Sumangala return -ENOMEM; 322133e882a5SSuraj Sumangala 322233e882a5SSuraj Sumangala scb = (void *) skb->cb; 322333e882a5SSuraj Sumangala scb->expect = hlen; 322433e882a5SSuraj Sumangala scb->pkt_type = type; 322533e882a5SSuraj Sumangala 322633e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 322733e882a5SSuraj Sumangala } 322833e882a5SSuraj Sumangala 322933e882a5SSuraj Sumangala while (count) { 323033e882a5SSuraj Sumangala scb = (void *) skb->cb; 323189bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 323233e882a5SSuraj Sumangala 323333e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 323433e882a5SSuraj Sumangala 323533e882a5SSuraj Sumangala count -= len; 323633e882a5SSuraj Sumangala data += len; 323733e882a5SSuraj Sumangala scb->expect -= len; 323833e882a5SSuraj Sumangala remain = count; 323933e882a5SSuraj Sumangala 324033e882a5SSuraj Sumangala switch (type) { 324133e882a5SSuraj Sumangala case HCI_EVENT_PKT: 324233e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 324333e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 324433e882a5SSuraj Sumangala scb->expect = h->plen; 324533e882a5SSuraj Sumangala 324633e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 324733e882a5SSuraj Sumangala kfree_skb(skb); 324833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 324933e882a5SSuraj Sumangala return -ENOMEM; 325033e882a5SSuraj Sumangala } 325133e882a5SSuraj Sumangala } 325233e882a5SSuraj Sumangala break; 325333e882a5SSuraj Sumangala 325433e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 325533e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 325633e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 325733e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 325833e882a5SSuraj Sumangala 325933e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 326033e882a5SSuraj Sumangala kfree_skb(skb); 326133e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 326233e882a5SSuraj Sumangala return -ENOMEM; 326333e882a5SSuraj Sumangala } 326433e882a5SSuraj Sumangala } 326533e882a5SSuraj Sumangala break; 326633e882a5SSuraj Sumangala 326733e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 326833e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 326933e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 327033e882a5SSuraj Sumangala scb->expect = h->dlen; 327133e882a5SSuraj Sumangala 327233e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 327333e882a5SSuraj Sumangala kfree_skb(skb); 327433e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 327533e882a5SSuraj Sumangala return -ENOMEM; 327633e882a5SSuraj Sumangala } 327733e882a5SSuraj Sumangala } 327833e882a5SSuraj Sumangala break; 327933e882a5SSuraj Sumangala } 328033e882a5SSuraj Sumangala 328133e882a5SSuraj Sumangala if (scb->expect == 0) { 328233e882a5SSuraj Sumangala /* Complete frame */ 328333e882a5SSuraj Sumangala 328433e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 3285e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 328633e882a5SSuraj Sumangala 328733e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 328833e882a5SSuraj Sumangala return remain; 328933e882a5SSuraj Sumangala } 329033e882a5SSuraj Sumangala } 329133e882a5SSuraj Sumangala 329233e882a5SSuraj Sumangala return remain; 329333e882a5SSuraj Sumangala } 329433e882a5SSuraj Sumangala 329599811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 329699811510SSuraj Sumangala 329799811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 329899811510SSuraj Sumangala { 329999811510SSuraj Sumangala int type; 330099811510SSuraj Sumangala int rem = 0; 330199811510SSuraj Sumangala 3302da5f6c37SGustavo F. Padovan while (count) { 330399811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 330499811510SSuraj Sumangala 330599811510SSuraj Sumangala if (!skb) { 330699811510SSuraj Sumangala struct { char type; } *pkt; 330799811510SSuraj Sumangala 330899811510SSuraj Sumangala /* Start of the frame */ 330999811510SSuraj Sumangala pkt = data; 331099811510SSuraj Sumangala type = pkt->type; 331199811510SSuraj Sumangala 331299811510SSuraj Sumangala data++; 331399811510SSuraj Sumangala count--; 331499811510SSuraj Sumangala } else 331599811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 331699811510SSuraj Sumangala 33171e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 33181e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 331999811510SSuraj Sumangala if (rem < 0) 332099811510SSuraj Sumangala return rem; 332199811510SSuraj Sumangala 332299811510SSuraj Sumangala data += (count - rem); 332399811510SSuraj Sumangala count = rem; 3324f81c6224SJoe Perches } 332599811510SSuraj Sumangala 332699811510SSuraj Sumangala return rem; 332799811510SSuraj Sumangala } 332899811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 332999811510SSuraj Sumangala 33301da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 33311da177e4SLinus Torvalds 33321da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 33331da177e4SLinus Torvalds { 33341da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 33351da177e4SLinus Torvalds 3336f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 33371da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 3338f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 33391da177e4SLinus Torvalds 33401da177e4SLinus Torvalds return 0; 33411da177e4SLinus Torvalds } 33421da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 33431da177e4SLinus Torvalds 33441da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 33451da177e4SLinus Torvalds { 33461da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 33471da177e4SLinus Torvalds 3348f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 33491da177e4SLinus Torvalds list_del(&cb->list); 3350f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 33511da177e4SLinus Torvalds 33521da177e4SLinus Torvalds return 0; 33531da177e4SLinus Torvalds } 33541da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 33551da177e4SLinus Torvalds 335651086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 33571da177e4SLinus Torvalds { 3358cdc52faaSMarcel Holtmann int err; 3359cdc52faaSMarcel Holtmann 33600d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 33611da177e4SLinus Torvalds 33621da177e4SLinus Torvalds /* Time stamp */ 3363a61bbcf2SPatrick McHardy __net_timestamp(skb); 33641da177e4SLinus Torvalds 3365cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3366cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3367cd82e61cSMarcel Holtmann 3368cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 3369cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 3370470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 33711da177e4SLinus Torvalds } 33721da177e4SLinus Torvalds 33731da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 33741da177e4SLinus Torvalds skb_orphan(skb); 33751da177e4SLinus Torvalds 3376cdc52faaSMarcel Holtmann err = hdev->send(hdev, skb); 3377cdc52faaSMarcel Holtmann if (err < 0) { 3378cdc52faaSMarcel Holtmann BT_ERR("%s sending frame failed (%d)", hdev->name, err); 3379cdc52faaSMarcel Holtmann kfree_skb(skb); 3380cdc52faaSMarcel Holtmann } 33811da177e4SLinus Torvalds } 33821da177e4SLinus Torvalds 3383899de765SMarcel Holtmann bool hci_req_pending(struct hci_dev *hdev) 3384899de765SMarcel Holtmann { 3385899de765SMarcel Holtmann return (hdev->req_status == HCI_REQ_PEND); 3386899de765SMarcel Holtmann } 3387899de765SMarcel Holtmann 33881ca3a9d0SJohan Hedberg /* Send HCI command */ 338907dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 339007dc93ddSJohan Hedberg const void *param) 33911ca3a9d0SJohan Hedberg { 33921ca3a9d0SJohan Hedberg struct sk_buff *skb; 33931ca3a9d0SJohan Hedberg 33941ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 33951ca3a9d0SJohan Hedberg 33961ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 33971ca3a9d0SJohan Hedberg if (!skb) { 33981ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 33991ca3a9d0SJohan Hedberg return -ENOMEM; 34001ca3a9d0SJohan Hedberg } 34011ca3a9d0SJohan Hedberg 340249c922bbSStephen Hemminger /* Stand-alone HCI commands must be flagged as 340311714b3dSJohan Hedberg * single-command requests. 340411714b3dSJohan Hedberg */ 340511714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 340611714b3dSJohan Hedberg 34071da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 3408c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 34091da177e4SLinus Torvalds 34101da177e4SLinus Torvalds return 0; 34111da177e4SLinus Torvalds } 34121da177e4SLinus Torvalds 34131da177e4SLinus Torvalds /* Get data from the previously sent command */ 3414a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 34151da177e4SLinus Torvalds { 34161da177e4SLinus Torvalds struct hci_command_hdr *hdr; 34171da177e4SLinus Torvalds 34181da177e4SLinus Torvalds if (!hdev->sent_cmd) 34191da177e4SLinus Torvalds return NULL; 34201da177e4SLinus Torvalds 34211da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 34221da177e4SLinus Torvalds 3423a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 34241da177e4SLinus Torvalds return NULL; 34251da177e4SLinus Torvalds 3426f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 34271da177e4SLinus Torvalds 34281da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 34291da177e4SLinus Torvalds } 34301da177e4SLinus Torvalds 34311da177e4SLinus Torvalds /* Send ACL data */ 34321da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 34331da177e4SLinus Torvalds { 34341da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 34351da177e4SLinus Torvalds int len = skb->len; 34361da177e4SLinus Torvalds 3437badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 3438badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 34399c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 3440aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 3441aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 34421da177e4SLinus Torvalds } 34431da177e4SLinus Torvalds 3444ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 344573d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 34461da177e4SLinus Torvalds { 3447ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 34481da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 34491da177e4SLinus Torvalds struct sk_buff *list; 34501da177e4SLinus Torvalds 3451087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 3452087bfd99SGustavo Padovan skb->data_len = 0; 3453087bfd99SGustavo Padovan 3454087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3455204a6e54SAndrei Emeltchenko 3456204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 3457204a6e54SAndrei Emeltchenko case HCI_BREDR: 3458087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 3459204a6e54SAndrei Emeltchenko break; 3460204a6e54SAndrei Emeltchenko case HCI_AMP: 3461204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 3462204a6e54SAndrei Emeltchenko break; 3463204a6e54SAndrei Emeltchenko default: 3464204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 3465204a6e54SAndrei Emeltchenko return; 3466204a6e54SAndrei Emeltchenko } 3467087bfd99SGustavo Padovan 346870f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 346970f23020SAndrei Emeltchenko if (!list) { 34701da177e4SLinus Torvalds /* Non fragmented */ 34711da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 34721da177e4SLinus Torvalds 347373d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 34741da177e4SLinus Torvalds } else { 34751da177e4SLinus Torvalds /* Fragmented */ 34761da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 34771da177e4SLinus Torvalds 34781da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 34791da177e4SLinus Torvalds 34809cfd5a23SJukka Rissanen /* Queue all fragments atomically. We need to use spin_lock_bh 34819cfd5a23SJukka Rissanen * here because of 6LoWPAN links, as there this function is 34829cfd5a23SJukka Rissanen * called from softirq and using normal spin lock could cause 34839cfd5a23SJukka Rissanen * deadlocks. 34849cfd5a23SJukka Rissanen */ 34859cfd5a23SJukka Rissanen spin_lock_bh(&queue->lock); 34861da177e4SLinus Torvalds 348773d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 3488e702112fSAndrei Emeltchenko 3489e702112fSAndrei Emeltchenko flags &= ~ACL_START; 3490e702112fSAndrei Emeltchenko flags |= ACL_CONT; 34911da177e4SLinus Torvalds do { 34921da177e4SLinus Torvalds skb = list; list = list->next; 34931da177e4SLinus Torvalds 34940d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3495e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 34961da177e4SLinus Torvalds 34971da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 34981da177e4SLinus Torvalds 349973d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 35001da177e4SLinus Torvalds } while (list); 35011da177e4SLinus Torvalds 35029cfd5a23SJukka Rissanen spin_unlock_bh(&queue->lock); 35031da177e4SLinus Torvalds } 350473d80debSLuiz Augusto von Dentz } 350573d80debSLuiz Augusto von Dentz 350673d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 350773d80debSLuiz Augusto von Dentz { 3508ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 350973d80debSLuiz Augusto von Dentz 3510f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 351173d80debSLuiz Augusto von Dentz 3512ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 35131da177e4SLinus Torvalds 35143eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 35151da177e4SLinus Torvalds } 35161da177e4SLinus Torvalds 35171da177e4SLinus Torvalds /* Send SCO data */ 35180d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 35191da177e4SLinus Torvalds { 35201da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 35211da177e4SLinus Torvalds struct hci_sco_hdr hdr; 35221da177e4SLinus Torvalds 35231da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 35241da177e4SLinus Torvalds 3525aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 35261da177e4SLinus Torvalds hdr.dlen = skb->len; 35271da177e4SLinus Torvalds 3528badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3529badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 35309c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 35311da177e4SLinus Torvalds 35320d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 3533c78ae283SMarcel Holtmann 35341da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 35353eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 35361da177e4SLinus Torvalds } 35371da177e4SLinus Torvalds 35381da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 35391da177e4SLinus Torvalds 35401da177e4SLinus Torvalds /* HCI Connection scheduler */ 35416039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3542a8c5fb1aSGustavo Padovan int *quote) 35431da177e4SLinus Torvalds { 35441da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 35458035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3546abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 35471da177e4SLinus Torvalds 35481da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 35491da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3550bf4c6325SGustavo F. Padovan 3551bf4c6325SGustavo F. Padovan rcu_read_lock(); 3552bf4c6325SGustavo F. Padovan 3553bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3554769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 35551da177e4SLinus Torvalds continue; 3556769be974SMarcel Holtmann 3557769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3558769be974SMarcel Holtmann continue; 3559769be974SMarcel Holtmann 35601da177e4SLinus Torvalds num++; 35611da177e4SLinus Torvalds 35621da177e4SLinus Torvalds if (c->sent < min) { 35631da177e4SLinus Torvalds min = c->sent; 35641da177e4SLinus Torvalds conn = c; 35651da177e4SLinus Torvalds } 356652087a79SLuiz Augusto von Dentz 356752087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 356852087a79SLuiz Augusto von Dentz break; 35691da177e4SLinus Torvalds } 35701da177e4SLinus Torvalds 3571bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3572bf4c6325SGustavo F. Padovan 35731da177e4SLinus Torvalds if (conn) { 35746ed58ec5SVille Tervo int cnt, q; 35756ed58ec5SVille Tervo 35766ed58ec5SVille Tervo switch (conn->type) { 35776ed58ec5SVille Tervo case ACL_LINK: 35786ed58ec5SVille Tervo cnt = hdev->acl_cnt; 35796ed58ec5SVille Tervo break; 35806ed58ec5SVille Tervo case SCO_LINK: 35816ed58ec5SVille Tervo case ESCO_LINK: 35826ed58ec5SVille Tervo cnt = hdev->sco_cnt; 35836ed58ec5SVille Tervo break; 35846ed58ec5SVille Tervo case LE_LINK: 35856ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 35866ed58ec5SVille Tervo break; 35876ed58ec5SVille Tervo default: 35886ed58ec5SVille Tervo cnt = 0; 35896ed58ec5SVille Tervo BT_ERR("Unknown link type"); 35906ed58ec5SVille Tervo } 35916ed58ec5SVille Tervo 35926ed58ec5SVille Tervo q = cnt / num; 35931da177e4SLinus Torvalds *quote = q ? q : 1; 35941da177e4SLinus Torvalds } else 35951da177e4SLinus Torvalds *quote = 0; 35961da177e4SLinus Torvalds 35971da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 35981da177e4SLinus Torvalds return conn; 35991da177e4SLinus Torvalds } 36001da177e4SLinus Torvalds 36016039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 36021da177e4SLinus Torvalds { 36031da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 36041da177e4SLinus Torvalds struct hci_conn *c; 36051da177e4SLinus Torvalds 3606bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 36071da177e4SLinus Torvalds 3608bf4c6325SGustavo F. Padovan rcu_read_lock(); 3609bf4c6325SGustavo F. Padovan 36101da177e4SLinus Torvalds /* Kill stalled connections */ 3611bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3612bae1f5d9SVille Tervo if (c->type == type && c->sent) { 36136ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 36146ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 3615bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 36161da177e4SLinus Torvalds } 36171da177e4SLinus Torvalds } 3618bf4c6325SGustavo F. Padovan 3619bf4c6325SGustavo F. Padovan rcu_read_unlock(); 36201da177e4SLinus Torvalds } 36211da177e4SLinus Torvalds 36226039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 362373d80debSLuiz Augusto von Dentz int *quote) 362473d80debSLuiz Augusto von Dentz { 362573d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 362673d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3627abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 362873d80debSLuiz Augusto von Dentz struct hci_conn *conn; 362973d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 363073d80debSLuiz Augusto von Dentz 363173d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 363273d80debSLuiz Augusto von Dentz 3633bf4c6325SGustavo F. Padovan rcu_read_lock(); 3634bf4c6325SGustavo F. Padovan 3635bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 363673d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 363773d80debSLuiz Augusto von Dentz 363873d80debSLuiz Augusto von Dentz if (conn->type != type) 363973d80debSLuiz Augusto von Dentz continue; 364073d80debSLuiz Augusto von Dentz 364173d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 364273d80debSLuiz Augusto von Dentz continue; 364373d80debSLuiz Augusto von Dentz 364473d80debSLuiz Augusto von Dentz conn_num++; 364573d80debSLuiz Augusto von Dentz 36468192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 364773d80debSLuiz Augusto von Dentz struct sk_buff *skb; 364873d80debSLuiz Augusto von Dentz 364973d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 365073d80debSLuiz Augusto von Dentz continue; 365173d80debSLuiz Augusto von Dentz 365273d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 365373d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 365473d80debSLuiz Augusto von Dentz continue; 365573d80debSLuiz Augusto von Dentz 365673d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 365773d80debSLuiz Augusto von Dentz num = 0; 365873d80debSLuiz Augusto von Dentz min = ~0; 365973d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 366073d80debSLuiz Augusto von Dentz } 366173d80debSLuiz Augusto von Dentz 366273d80debSLuiz Augusto von Dentz num++; 366373d80debSLuiz Augusto von Dentz 366473d80debSLuiz Augusto von Dentz if (conn->sent < min) { 366573d80debSLuiz Augusto von Dentz min = conn->sent; 366673d80debSLuiz Augusto von Dentz chan = tmp; 366773d80debSLuiz Augusto von Dentz } 366873d80debSLuiz Augusto von Dentz } 366973d80debSLuiz Augusto von Dentz 367073d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 367173d80debSLuiz Augusto von Dentz break; 367273d80debSLuiz Augusto von Dentz } 367373d80debSLuiz Augusto von Dentz 3674bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3675bf4c6325SGustavo F. Padovan 367673d80debSLuiz Augusto von Dentz if (!chan) 367773d80debSLuiz Augusto von Dentz return NULL; 367873d80debSLuiz Augusto von Dentz 367973d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 368073d80debSLuiz Augusto von Dentz case ACL_LINK: 368173d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 368273d80debSLuiz Augusto von Dentz break; 3683bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3684bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3685bd1eb66bSAndrei Emeltchenko break; 368673d80debSLuiz Augusto von Dentz case SCO_LINK: 368773d80debSLuiz Augusto von Dentz case ESCO_LINK: 368873d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 368973d80debSLuiz Augusto von Dentz break; 369073d80debSLuiz Augusto von Dentz case LE_LINK: 369173d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 369273d80debSLuiz Augusto von Dentz break; 369373d80debSLuiz Augusto von Dentz default: 369473d80debSLuiz Augusto von Dentz cnt = 0; 369573d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 369673d80debSLuiz Augusto von Dentz } 369773d80debSLuiz Augusto von Dentz 369873d80debSLuiz Augusto von Dentz q = cnt / num; 369973d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 370073d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 370173d80debSLuiz Augusto von Dentz return chan; 370273d80debSLuiz Augusto von Dentz } 370373d80debSLuiz Augusto von Dentz 370402b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 370502b20f0bSLuiz Augusto von Dentz { 370602b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 370702b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 370802b20f0bSLuiz Augusto von Dentz int num = 0; 370902b20f0bSLuiz Augusto von Dentz 371002b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 371102b20f0bSLuiz Augusto von Dentz 3712bf4c6325SGustavo F. Padovan rcu_read_lock(); 3713bf4c6325SGustavo F. Padovan 3714bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 371502b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 371602b20f0bSLuiz Augusto von Dentz 371702b20f0bSLuiz Augusto von Dentz if (conn->type != type) 371802b20f0bSLuiz Augusto von Dentz continue; 371902b20f0bSLuiz Augusto von Dentz 372002b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 372102b20f0bSLuiz Augusto von Dentz continue; 372202b20f0bSLuiz Augusto von Dentz 372302b20f0bSLuiz Augusto von Dentz num++; 372402b20f0bSLuiz Augusto von Dentz 37258192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 372602b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 372702b20f0bSLuiz Augusto von Dentz 372802b20f0bSLuiz Augusto von Dentz if (chan->sent) { 372902b20f0bSLuiz Augusto von Dentz chan->sent = 0; 373002b20f0bSLuiz Augusto von Dentz continue; 373102b20f0bSLuiz Augusto von Dentz } 373202b20f0bSLuiz Augusto von Dentz 373302b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 373402b20f0bSLuiz Augusto von Dentz continue; 373502b20f0bSLuiz Augusto von Dentz 373602b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 373702b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 373802b20f0bSLuiz Augusto von Dentz continue; 373902b20f0bSLuiz Augusto von Dentz 374002b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 374102b20f0bSLuiz Augusto von Dentz 374202b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 374302b20f0bSLuiz Augusto von Dentz skb->priority); 374402b20f0bSLuiz Augusto von Dentz } 374502b20f0bSLuiz Augusto von Dentz 374602b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 374702b20f0bSLuiz Augusto von Dentz break; 374802b20f0bSLuiz Augusto von Dentz } 3749bf4c6325SGustavo F. Padovan 3750bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3751bf4c6325SGustavo F. Padovan 375202b20f0bSLuiz Augusto von Dentz } 375302b20f0bSLuiz Augusto von Dentz 3754b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 3755b71d385aSAndrei Emeltchenko { 3756b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 3757b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 3758b71d385aSAndrei Emeltchenko } 3759b71d385aSAndrei Emeltchenko 37606039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 37611da177e4SLinus Torvalds { 37624a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 37631da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 37641da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 376563d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 37665f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 3767bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 37681da177e4SLinus Torvalds } 376963d2bc1bSAndrei Emeltchenko } 37701da177e4SLinus Torvalds 37716039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 377263d2bc1bSAndrei Emeltchenko { 377363d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 377463d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 377563d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 377663d2bc1bSAndrei Emeltchenko int quote; 377763d2bc1bSAndrei Emeltchenko 377863d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 377904837f64SMarcel Holtmann 378073d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 378173d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 3782ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3783ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 378473d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 378573d80debSLuiz Augusto von Dentz skb->len, skb->priority); 378673d80debSLuiz Augusto von Dentz 3787ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3788ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3789ec1cce24SLuiz Augusto von Dentz break; 3790ec1cce24SLuiz Augusto von Dentz 3791ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3792ec1cce24SLuiz Augusto von Dentz 379373d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 379473d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 379504837f64SMarcel Holtmann 379657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 37971da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 37981da177e4SLinus Torvalds 37991da177e4SLinus Torvalds hdev->acl_cnt--; 380073d80debSLuiz Augusto von Dentz chan->sent++; 380173d80debSLuiz Augusto von Dentz chan->conn->sent++; 38021da177e4SLinus Torvalds } 38031da177e4SLinus Torvalds } 380402b20f0bSLuiz Augusto von Dentz 380502b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 380602b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 38071da177e4SLinus Torvalds } 38081da177e4SLinus Torvalds 38096039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 3810b71d385aSAndrei Emeltchenko { 381163d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 3812b71d385aSAndrei Emeltchenko struct hci_chan *chan; 3813b71d385aSAndrei Emeltchenko struct sk_buff *skb; 3814b71d385aSAndrei Emeltchenko int quote; 3815bd1eb66bSAndrei Emeltchenko u8 type; 3816b71d385aSAndrei Emeltchenko 381763d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 3818b71d385aSAndrei Emeltchenko 3819bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3820bd1eb66bSAndrei Emeltchenko 3821bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 3822bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 3823bd1eb66bSAndrei Emeltchenko else 3824bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 3825bd1eb66bSAndrei Emeltchenko 3826b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 3827bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 3828b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 3829b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 3830b71d385aSAndrei Emeltchenko int blocks; 3831b71d385aSAndrei Emeltchenko 3832b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 3833b71d385aSAndrei Emeltchenko skb->len, skb->priority); 3834b71d385aSAndrei Emeltchenko 3835b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 3836b71d385aSAndrei Emeltchenko if (skb->priority < priority) 3837b71d385aSAndrei Emeltchenko break; 3838b71d385aSAndrei Emeltchenko 3839b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 3840b71d385aSAndrei Emeltchenko 3841b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 3842b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 3843b71d385aSAndrei Emeltchenko return; 3844b71d385aSAndrei Emeltchenko 3845b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 3846b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 3847b71d385aSAndrei Emeltchenko 384857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3849b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 3850b71d385aSAndrei Emeltchenko 3851b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 3852b71d385aSAndrei Emeltchenko quote -= blocks; 3853b71d385aSAndrei Emeltchenko 3854b71d385aSAndrei Emeltchenko chan->sent += blocks; 3855b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 3856b71d385aSAndrei Emeltchenko } 3857b71d385aSAndrei Emeltchenko } 3858b71d385aSAndrei Emeltchenko 3859b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 3860bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 3861b71d385aSAndrei Emeltchenko } 3862b71d385aSAndrei Emeltchenko 38636039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 3864b71d385aSAndrei Emeltchenko { 3865b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3866b71d385aSAndrei Emeltchenko 3867bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 3868bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 3869bd1eb66bSAndrei Emeltchenko return; 3870bd1eb66bSAndrei Emeltchenko 3871bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 3872bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 3873b71d385aSAndrei Emeltchenko return; 3874b71d385aSAndrei Emeltchenko 3875b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 3876b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 3877b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 3878b71d385aSAndrei Emeltchenko break; 3879b71d385aSAndrei Emeltchenko 3880b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 3881b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 3882b71d385aSAndrei Emeltchenko break; 3883b71d385aSAndrei Emeltchenko } 3884b71d385aSAndrei Emeltchenko } 3885b71d385aSAndrei Emeltchenko 38861da177e4SLinus Torvalds /* Schedule SCO */ 38876039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 38881da177e4SLinus Torvalds { 38891da177e4SLinus Torvalds struct hci_conn *conn; 38901da177e4SLinus Torvalds struct sk_buff *skb; 38911da177e4SLinus Torvalds int quote; 38921da177e4SLinus Torvalds 38931da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 38941da177e4SLinus Torvalds 389552087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 389652087a79SLuiz Augusto von Dentz return; 389752087a79SLuiz Augusto von Dentz 38981da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 38991da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 39001da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 390157d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 39021da177e4SLinus Torvalds 39031da177e4SLinus Torvalds conn->sent++; 39041da177e4SLinus Torvalds if (conn->sent == ~0) 39051da177e4SLinus Torvalds conn->sent = 0; 39061da177e4SLinus Torvalds } 39071da177e4SLinus Torvalds } 39081da177e4SLinus Torvalds } 39091da177e4SLinus Torvalds 39106039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 3911b6a0dc82SMarcel Holtmann { 3912b6a0dc82SMarcel Holtmann struct hci_conn *conn; 3913b6a0dc82SMarcel Holtmann struct sk_buff *skb; 3914b6a0dc82SMarcel Holtmann int quote; 3915b6a0dc82SMarcel Holtmann 3916b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 3917b6a0dc82SMarcel Holtmann 391852087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 391952087a79SLuiz Augusto von Dentz return; 392052087a79SLuiz Augusto von Dentz 39218fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 39228fc9ced3SGustavo Padovan "e))) { 3923b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 3924b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 392557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3926b6a0dc82SMarcel Holtmann 3927b6a0dc82SMarcel Holtmann conn->sent++; 3928b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 3929b6a0dc82SMarcel Holtmann conn->sent = 0; 3930b6a0dc82SMarcel Holtmann } 3931b6a0dc82SMarcel Holtmann } 3932b6a0dc82SMarcel Holtmann } 3933b6a0dc82SMarcel Holtmann 39346039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 39356ed58ec5SVille Tervo { 393673d80debSLuiz Augusto von Dentz struct hci_chan *chan; 39376ed58ec5SVille Tervo struct sk_buff *skb; 393802b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 39396ed58ec5SVille Tervo 39406ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 39416ed58ec5SVille Tervo 394252087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 394352087a79SLuiz Augusto von Dentz return; 394452087a79SLuiz Augusto von Dentz 39454a964404SMarcel Holtmann if (!test_bit(HCI_UNCONFIGURED, &hdev->dev_flags)) { 39466ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 39476ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 3948bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 39496ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 3950bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 39516ed58ec5SVille Tervo } 39526ed58ec5SVille Tervo 39536ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 395402b20f0bSLuiz Augusto von Dentz tmp = cnt; 395573d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 3956ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3957ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 395873d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 395973d80debSLuiz Augusto von Dentz skb->len, skb->priority); 39606ed58ec5SVille Tervo 3961ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3962ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3963ec1cce24SLuiz Augusto von Dentz break; 3964ec1cce24SLuiz Augusto von Dentz 3965ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3966ec1cce24SLuiz Augusto von Dentz 396757d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 39686ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 39696ed58ec5SVille Tervo 39706ed58ec5SVille Tervo cnt--; 397173d80debSLuiz Augusto von Dentz chan->sent++; 397273d80debSLuiz Augusto von Dentz chan->conn->sent++; 39736ed58ec5SVille Tervo } 39746ed58ec5SVille Tervo } 397573d80debSLuiz Augusto von Dentz 39766ed58ec5SVille Tervo if (hdev->le_pkts) 39776ed58ec5SVille Tervo hdev->le_cnt = cnt; 39786ed58ec5SVille Tervo else 39796ed58ec5SVille Tervo hdev->acl_cnt = cnt; 398002b20f0bSLuiz Augusto von Dentz 398102b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 398202b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 39836ed58ec5SVille Tervo } 39846ed58ec5SVille Tervo 39853eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 39861da177e4SLinus Torvalds { 39873eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 39881da177e4SLinus Torvalds struct sk_buff *skb; 39891da177e4SLinus Torvalds 39906ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 39916ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 39921da177e4SLinus Torvalds 399352de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 39941da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 39951da177e4SLinus Torvalds hci_sched_acl(hdev); 39961da177e4SLinus Torvalds hci_sched_sco(hdev); 3997b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 39986ed58ec5SVille Tervo hci_sched_le(hdev); 399952de599eSMarcel Holtmann } 40006ed58ec5SVille Tervo 40011da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 40021da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 400357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 40041da177e4SLinus Torvalds } 40051da177e4SLinus Torvalds 400625985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 40071da177e4SLinus Torvalds 40081da177e4SLinus Torvalds /* ACL data packet */ 40096039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 40101da177e4SLinus Torvalds { 40111da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 40121da177e4SLinus Torvalds struct hci_conn *conn; 40131da177e4SLinus Torvalds __u16 handle, flags; 40141da177e4SLinus Torvalds 40151da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 40161da177e4SLinus Torvalds 40171da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 40181da177e4SLinus Torvalds flags = hci_flags(handle); 40191da177e4SLinus Torvalds handle = hci_handle(handle); 40201da177e4SLinus Torvalds 4021f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 4022a8c5fb1aSGustavo Padovan handle, flags); 40231da177e4SLinus Torvalds 40241da177e4SLinus Torvalds hdev->stat.acl_rx++; 40251da177e4SLinus Torvalds 40261da177e4SLinus Torvalds hci_dev_lock(hdev); 40271da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 40281da177e4SLinus Torvalds hci_dev_unlock(hdev); 40291da177e4SLinus Torvalds 40301da177e4SLinus Torvalds if (conn) { 403165983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 403204837f64SMarcel Holtmann 40331da177e4SLinus Torvalds /* Send to upper protocol */ 4034686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 40351da177e4SLinus Torvalds return; 40361da177e4SLinus Torvalds } else { 40371da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 40381da177e4SLinus Torvalds hdev->name, handle); 40391da177e4SLinus Torvalds } 40401da177e4SLinus Torvalds 40411da177e4SLinus Torvalds kfree_skb(skb); 40421da177e4SLinus Torvalds } 40431da177e4SLinus Torvalds 40441da177e4SLinus Torvalds /* SCO data packet */ 40456039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 40461da177e4SLinus Torvalds { 40471da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 40481da177e4SLinus Torvalds struct hci_conn *conn; 40491da177e4SLinus Torvalds __u16 handle; 40501da177e4SLinus Torvalds 40511da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 40521da177e4SLinus Torvalds 40531da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 40541da177e4SLinus Torvalds 4055f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 40561da177e4SLinus Torvalds 40571da177e4SLinus Torvalds hdev->stat.sco_rx++; 40581da177e4SLinus Torvalds 40591da177e4SLinus Torvalds hci_dev_lock(hdev); 40601da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 40611da177e4SLinus Torvalds hci_dev_unlock(hdev); 40621da177e4SLinus Torvalds 40631da177e4SLinus Torvalds if (conn) { 40641da177e4SLinus Torvalds /* Send to upper protocol */ 4065686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 40661da177e4SLinus Torvalds return; 40671da177e4SLinus Torvalds } else { 40681da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 40691da177e4SLinus Torvalds hdev->name, handle); 40701da177e4SLinus Torvalds } 40711da177e4SLinus Torvalds 40721da177e4SLinus Torvalds kfree_skb(skb); 40731da177e4SLinus Torvalds } 40741da177e4SLinus Torvalds 40759238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 40769238f36aSJohan Hedberg { 40779238f36aSJohan Hedberg struct sk_buff *skb; 40789238f36aSJohan Hedberg 40799238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 40809238f36aSJohan Hedberg if (!skb) 40819238f36aSJohan Hedberg return true; 40829238f36aSJohan Hedberg 40839238f36aSJohan Hedberg return bt_cb(skb)->req.start; 40849238f36aSJohan Hedberg } 40859238f36aSJohan Hedberg 408642c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 408742c6b129SJohan Hedberg { 408842c6b129SJohan Hedberg struct hci_command_hdr *sent; 408942c6b129SJohan Hedberg struct sk_buff *skb; 409042c6b129SJohan Hedberg u16 opcode; 409142c6b129SJohan Hedberg 409242c6b129SJohan Hedberg if (!hdev->sent_cmd) 409342c6b129SJohan Hedberg return; 409442c6b129SJohan Hedberg 409542c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 409642c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 409742c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 409842c6b129SJohan Hedberg return; 409942c6b129SJohan Hedberg 410042c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 410142c6b129SJohan Hedberg if (!skb) 410242c6b129SJohan Hedberg return; 410342c6b129SJohan Hedberg 410442c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 410542c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 410642c6b129SJohan Hedberg } 410742c6b129SJohan Hedberg 41089238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 41099238f36aSJohan Hedberg { 41109238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 41119238f36aSJohan Hedberg struct sk_buff *skb; 41129238f36aSJohan Hedberg unsigned long flags; 41139238f36aSJohan Hedberg 41149238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 41159238f36aSJohan Hedberg 411642c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 411742c6b129SJohan Hedberg * sent we need to do special handling of it. 41189238f36aSJohan Hedberg */ 411942c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 412042c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 412142c6b129SJohan Hedberg * reset complete event during init and any pending 412242c6b129SJohan Hedberg * command will never be completed. In such a case we 412342c6b129SJohan Hedberg * need to resend whatever was the last sent 412442c6b129SJohan Hedberg * command. 412542c6b129SJohan Hedberg */ 412642c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 412742c6b129SJohan Hedberg hci_resend_last(hdev); 412842c6b129SJohan Hedberg 41299238f36aSJohan Hedberg return; 413042c6b129SJohan Hedberg } 41319238f36aSJohan Hedberg 41329238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 41339238f36aSJohan Hedberg * this request the request is not yet complete. 41349238f36aSJohan Hedberg */ 41359238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 41369238f36aSJohan Hedberg return; 41379238f36aSJohan Hedberg 41389238f36aSJohan Hedberg /* If this was the last command in a request the complete 41399238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 41409238f36aSJohan Hedberg * command queue (hdev->cmd_q). 41419238f36aSJohan Hedberg */ 41429238f36aSJohan Hedberg if (hdev->sent_cmd) { 41439238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 414453e21fbcSJohan Hedberg 414553e21fbcSJohan Hedberg if (req_complete) { 414653e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 414753e21fbcSJohan Hedberg * avoid calling the callback more than once if 414853e21fbcSJohan Hedberg * this function gets called again. 414953e21fbcSJohan Hedberg */ 415053e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 415153e21fbcSJohan Hedberg 41529238f36aSJohan Hedberg goto call_complete; 41539238f36aSJohan Hedberg } 415453e21fbcSJohan Hedberg } 41559238f36aSJohan Hedberg 41569238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 41579238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 41589238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 41599238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 41609238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 41619238f36aSJohan Hedberg break; 41629238f36aSJohan Hedberg } 41639238f36aSJohan Hedberg 41649238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 41659238f36aSJohan Hedberg kfree_skb(skb); 41669238f36aSJohan Hedberg } 41679238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 41689238f36aSJohan Hedberg 41699238f36aSJohan Hedberg call_complete: 41709238f36aSJohan Hedberg if (req_complete) 41711904a853SMarcel Holtmann req_complete(hdev, status, status ? opcode : HCI_OP_NOP); 41729238f36aSJohan Hedberg } 41739238f36aSJohan Hedberg 4174b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 41751da177e4SLinus Torvalds { 4176b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 41771da177e4SLinus Torvalds struct sk_buff *skb; 41781da177e4SLinus Torvalds 41791da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 41801da177e4SLinus Torvalds 41811da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 4182cd82e61cSMarcel Holtmann /* Send copy to monitor */ 4183cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 4184cd82e61cSMarcel Holtmann 41851da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 41861da177e4SLinus Torvalds /* Send copy to the sockets */ 4187470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 41881da177e4SLinus Torvalds } 41891da177e4SLinus Torvalds 4190fee746b0SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 41911da177e4SLinus Torvalds kfree_skb(skb); 41921da177e4SLinus Torvalds continue; 41931da177e4SLinus Torvalds } 41941da177e4SLinus Torvalds 41951da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 41961da177e4SLinus Torvalds /* Don't process data packets in this states. */ 41970d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 41981da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 41991da177e4SLinus Torvalds case HCI_SCODATA_PKT: 42001da177e4SLinus Torvalds kfree_skb(skb); 42011da177e4SLinus Torvalds continue; 42023ff50b79SStephen Hemminger } 42031da177e4SLinus Torvalds } 42041da177e4SLinus Torvalds 42051da177e4SLinus Torvalds /* Process frame */ 42060d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 42071da177e4SLinus Torvalds case HCI_EVENT_PKT: 4208b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 42091da177e4SLinus Torvalds hci_event_packet(hdev, skb); 42101da177e4SLinus Torvalds break; 42111da177e4SLinus Torvalds 42121da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 42131da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 42141da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 42151da177e4SLinus Torvalds break; 42161da177e4SLinus Torvalds 42171da177e4SLinus Torvalds case HCI_SCODATA_PKT: 42181da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 42191da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 42201da177e4SLinus Torvalds break; 42211da177e4SLinus Torvalds 42221da177e4SLinus Torvalds default: 42231da177e4SLinus Torvalds kfree_skb(skb); 42241da177e4SLinus Torvalds break; 42251da177e4SLinus Torvalds } 42261da177e4SLinus Torvalds } 42271da177e4SLinus Torvalds } 42281da177e4SLinus Torvalds 4229c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 42301da177e4SLinus Torvalds { 4231c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 42321da177e4SLinus Torvalds struct sk_buff *skb; 42331da177e4SLinus Torvalds 42342104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 42352104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 42361da177e4SLinus Torvalds 42371da177e4SLinus Torvalds /* Send queued commands */ 42385a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 42395a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 42405a08ecceSAndrei Emeltchenko if (!skb) 42415a08ecceSAndrei Emeltchenko return; 42425a08ecceSAndrei Emeltchenko 42431da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 42441da177e4SLinus Torvalds 4245a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 424670f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 42471da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 424857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 42497bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 425065cc2b49SMarcel Holtmann cancel_delayed_work(&hdev->cmd_timer); 42517bdb8a5cSSzymon Janc else 425265cc2b49SMarcel Holtmann schedule_delayed_work(&hdev->cmd_timer, 425365cc2b49SMarcel Holtmann HCI_CMD_TIMEOUT); 42541da177e4SLinus Torvalds } else { 42551da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 4256c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 42571da177e4SLinus Torvalds } 42581da177e4SLinus Torvalds } 42591da177e4SLinus Torvalds } 4260