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> 321da177e4SLinus Torvalds 331da177e4SLinus Torvalds #include <net/bluetooth/bluetooth.h> 341da177e4SLinus Torvalds #include <net/bluetooth/hci_core.h> 351da177e4SLinus Torvalds 36b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work); 37c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work); 383eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work); 391da177e4SLinus Torvalds 401da177e4SLinus Torvalds /* HCI device list */ 411da177e4SLinus Torvalds LIST_HEAD(hci_dev_list); 421da177e4SLinus Torvalds DEFINE_RWLOCK(hci_dev_list_lock); 431da177e4SLinus Torvalds 441da177e4SLinus Torvalds /* HCI callback list */ 451da177e4SLinus Torvalds LIST_HEAD(hci_cb_list); 461da177e4SLinus Torvalds DEFINE_RWLOCK(hci_cb_list_lock); 471da177e4SLinus Torvalds 483df92b31SSasha Levin /* HCI ID Numbering */ 493df92b31SSasha Levin static DEFINE_IDA(hci_index_ida); 503df92b31SSasha Levin 511da177e4SLinus Torvalds /* ---- HCI notifications ---- */ 521da177e4SLinus Torvalds 536516455dSMarcel Holtmann static void hci_notify(struct hci_dev *hdev, int event) 541da177e4SLinus Torvalds { 55040030efSMarcel Holtmann hci_sock_dev_event(hdev, event); 561da177e4SLinus Torvalds } 571da177e4SLinus Torvalds 58baf27f6eSMarcel Holtmann /* ---- HCI debugfs entries ---- */ 59baf27f6eSMarcel Holtmann 60*70afe0b8SMarcel Holtmann static int blacklist_show(struct seq_file *f, void *p) 61*70afe0b8SMarcel Holtmann { 62*70afe0b8SMarcel Holtmann struct hci_dev *hdev = f->private; 63*70afe0b8SMarcel Holtmann struct bdaddr_list *b; 64*70afe0b8SMarcel Holtmann 65*70afe0b8SMarcel Holtmann hci_dev_lock(hdev); 66*70afe0b8SMarcel Holtmann list_for_each_entry(b, &hdev->blacklist, list) 67*70afe0b8SMarcel Holtmann seq_printf(f, "%pMR\n", &b->bdaddr); 68*70afe0b8SMarcel Holtmann hci_dev_unlock(hdev); 69*70afe0b8SMarcel Holtmann 70*70afe0b8SMarcel Holtmann return 0; 71*70afe0b8SMarcel Holtmann } 72*70afe0b8SMarcel Holtmann 73*70afe0b8SMarcel Holtmann static int blacklist_open(struct inode *inode, struct file *file) 74*70afe0b8SMarcel Holtmann { 75*70afe0b8SMarcel Holtmann return single_open(file, blacklist_show, inode->i_private); 76*70afe0b8SMarcel Holtmann } 77*70afe0b8SMarcel Holtmann 78*70afe0b8SMarcel Holtmann static const struct file_operations blacklist_fops = { 79*70afe0b8SMarcel Holtmann .open = blacklist_open, 80*70afe0b8SMarcel Holtmann .read = seq_read, 81*70afe0b8SMarcel Holtmann .llseek = seq_lseek, 82*70afe0b8SMarcel Holtmann .release = single_release, 83*70afe0b8SMarcel Holtmann }; 84*70afe0b8SMarcel Holtmann 85baf27f6eSMarcel Holtmann static int inquiry_cache_show(struct seq_file *f, void *p) 86baf27f6eSMarcel Holtmann { 87baf27f6eSMarcel Holtmann struct hci_dev *hdev = f->private; 88baf27f6eSMarcel Holtmann struct discovery_state *cache = &hdev->discovery; 89baf27f6eSMarcel Holtmann struct inquiry_entry *e; 90baf27f6eSMarcel Holtmann 91baf27f6eSMarcel Holtmann hci_dev_lock(hdev); 92baf27f6eSMarcel Holtmann 93baf27f6eSMarcel Holtmann list_for_each_entry(e, &cache->all, all) { 94baf27f6eSMarcel Holtmann struct inquiry_data *data = &e->data; 95baf27f6eSMarcel Holtmann seq_printf(f, "%pMR %d %d %d 0x%.2x%.2x%.2x 0x%.4x %d %d %u\n", 96baf27f6eSMarcel Holtmann &data->bdaddr, 97baf27f6eSMarcel Holtmann data->pscan_rep_mode, data->pscan_period_mode, 98baf27f6eSMarcel Holtmann data->pscan_mode, data->dev_class[2], 99baf27f6eSMarcel Holtmann data->dev_class[1], data->dev_class[0], 100baf27f6eSMarcel Holtmann __le16_to_cpu(data->clock_offset), 101baf27f6eSMarcel Holtmann data->rssi, data->ssp_mode, e->timestamp); 102baf27f6eSMarcel Holtmann } 103baf27f6eSMarcel Holtmann 104baf27f6eSMarcel Holtmann hci_dev_unlock(hdev); 105baf27f6eSMarcel Holtmann 106baf27f6eSMarcel Holtmann return 0; 107baf27f6eSMarcel Holtmann } 108baf27f6eSMarcel Holtmann 109baf27f6eSMarcel Holtmann static int inquiry_cache_open(struct inode *inode, struct file *file) 110baf27f6eSMarcel Holtmann { 111baf27f6eSMarcel Holtmann return single_open(file, inquiry_cache_show, inode->i_private); 112baf27f6eSMarcel Holtmann } 113baf27f6eSMarcel Holtmann 114baf27f6eSMarcel Holtmann static const struct file_operations inquiry_cache_fops = { 115baf27f6eSMarcel Holtmann .open = inquiry_cache_open, 116baf27f6eSMarcel Holtmann .read = seq_read, 117baf27f6eSMarcel Holtmann .llseek = seq_lseek, 118baf27f6eSMarcel Holtmann .release = single_release, 119baf27f6eSMarcel Holtmann }; 120baf27f6eSMarcel Holtmann 121041000b9SMarcel Holtmann static int voice_setting_get(void *data, u64 *val) 122041000b9SMarcel Holtmann { 123041000b9SMarcel Holtmann struct hci_dev *hdev = data; 124041000b9SMarcel Holtmann 125041000b9SMarcel Holtmann hci_dev_lock(hdev); 126041000b9SMarcel Holtmann *val = hdev->voice_setting; 127041000b9SMarcel Holtmann hci_dev_unlock(hdev); 128041000b9SMarcel Holtmann 129041000b9SMarcel Holtmann return 0; 130041000b9SMarcel Holtmann } 131041000b9SMarcel Holtmann 132041000b9SMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(voice_setting_fops, voice_setting_get, 133041000b9SMarcel Holtmann NULL, "0x%4.4llx\n"); 134041000b9SMarcel Holtmann 135ebd1e33bSMarcel Holtmann static int auto_accept_delay_set(void *data, u64 val) 136ebd1e33bSMarcel Holtmann { 137ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 138ebd1e33bSMarcel Holtmann 139ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 140ebd1e33bSMarcel Holtmann hdev->auto_accept_delay = val; 141ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 142ebd1e33bSMarcel Holtmann 143ebd1e33bSMarcel Holtmann return 0; 144ebd1e33bSMarcel Holtmann } 145ebd1e33bSMarcel Holtmann 146ebd1e33bSMarcel Holtmann static int auto_accept_delay_get(void *data, u64 *val) 147ebd1e33bSMarcel Holtmann { 148ebd1e33bSMarcel Holtmann struct hci_dev *hdev = data; 149ebd1e33bSMarcel Holtmann 150ebd1e33bSMarcel Holtmann hci_dev_lock(hdev); 151ebd1e33bSMarcel Holtmann *val = hdev->auto_accept_delay; 152ebd1e33bSMarcel Holtmann hci_dev_unlock(hdev); 153ebd1e33bSMarcel Holtmann 154ebd1e33bSMarcel Holtmann return 0; 155ebd1e33bSMarcel Holtmann } 156ebd1e33bSMarcel Holtmann 157ebd1e33bSMarcel Holtmann DEFINE_SIMPLE_ATTRIBUTE(auto_accept_delay_fops, auto_accept_delay_get, 158ebd1e33bSMarcel Holtmann auto_accept_delay_set, "%llu\n"); 159ebd1e33bSMarcel Holtmann 160e7b8fc92SMarcel Holtmann static int static_address_show(struct seq_file *f, void *p) 161e7b8fc92SMarcel Holtmann { 162e7b8fc92SMarcel Holtmann struct hci_dev *hdev = f->private; 163e7b8fc92SMarcel Holtmann 164e7b8fc92SMarcel Holtmann hci_dev_lock(hdev); 165e7b8fc92SMarcel Holtmann seq_printf(f, "%pMR\n", &hdev->static_addr); 166e7b8fc92SMarcel Holtmann hci_dev_unlock(hdev); 167e7b8fc92SMarcel Holtmann 168e7b8fc92SMarcel Holtmann return 0; 169e7b8fc92SMarcel Holtmann } 170e7b8fc92SMarcel Holtmann 171e7b8fc92SMarcel Holtmann static int static_address_open(struct inode *inode, struct file *file) 172e7b8fc92SMarcel Holtmann { 173e7b8fc92SMarcel Holtmann return single_open(file, static_address_show, inode->i_private); 174e7b8fc92SMarcel Holtmann } 175e7b8fc92SMarcel Holtmann 176e7b8fc92SMarcel Holtmann static const struct file_operations static_address_fops = { 177e7b8fc92SMarcel Holtmann .open = static_address_open, 178e7b8fc92SMarcel Holtmann .read = seq_read, 179e7b8fc92SMarcel Holtmann .llseek = seq_lseek, 180e7b8fc92SMarcel Holtmann .release = single_release, 181e7b8fc92SMarcel Holtmann }; 182e7b8fc92SMarcel Holtmann 1831da177e4SLinus Torvalds /* ---- HCI requests ---- */ 1841da177e4SLinus Torvalds 18542c6b129SJohan Hedberg static void hci_req_sync_complete(struct hci_dev *hdev, u8 result) 1861da177e4SLinus Torvalds { 18742c6b129SJohan Hedberg BT_DBG("%s result 0x%2.2x", hdev->name, result); 18875fb0e32SJohan Hedberg 1891da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 1901da177e4SLinus Torvalds hdev->req_result = result; 1911da177e4SLinus Torvalds hdev->req_status = HCI_REQ_DONE; 1921da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 1931da177e4SLinus Torvalds } 1941da177e4SLinus Torvalds } 1951da177e4SLinus Torvalds 1961da177e4SLinus Torvalds static void hci_req_cancel(struct hci_dev *hdev, int err) 1971da177e4SLinus Torvalds { 1981da177e4SLinus Torvalds BT_DBG("%s err 0x%2.2x", hdev->name, err); 1991da177e4SLinus Torvalds 2001da177e4SLinus Torvalds if (hdev->req_status == HCI_REQ_PEND) { 2011da177e4SLinus Torvalds hdev->req_result = err; 2021da177e4SLinus Torvalds hdev->req_status = HCI_REQ_CANCELED; 2031da177e4SLinus Torvalds wake_up_interruptible(&hdev->req_wait_q); 2041da177e4SLinus Torvalds } 2051da177e4SLinus Torvalds } 2061da177e4SLinus Torvalds 20777a63e0aSFengguang Wu static struct sk_buff *hci_get_cmd_complete(struct hci_dev *hdev, u16 opcode, 20877a63e0aSFengguang Wu u8 event) 20975e84b7cSJohan Hedberg { 21075e84b7cSJohan Hedberg struct hci_ev_cmd_complete *ev; 21175e84b7cSJohan Hedberg struct hci_event_hdr *hdr; 21275e84b7cSJohan Hedberg struct sk_buff *skb; 21375e84b7cSJohan Hedberg 21475e84b7cSJohan Hedberg hci_dev_lock(hdev); 21575e84b7cSJohan Hedberg 21675e84b7cSJohan Hedberg skb = hdev->recv_evt; 21775e84b7cSJohan Hedberg hdev->recv_evt = NULL; 21875e84b7cSJohan Hedberg 21975e84b7cSJohan Hedberg hci_dev_unlock(hdev); 22075e84b7cSJohan Hedberg 22175e84b7cSJohan Hedberg if (!skb) 22275e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 22375e84b7cSJohan Hedberg 22475e84b7cSJohan Hedberg if (skb->len < sizeof(*hdr)) { 22575e84b7cSJohan Hedberg BT_ERR("Too short HCI event"); 22675e84b7cSJohan Hedberg goto failed; 22775e84b7cSJohan Hedberg } 22875e84b7cSJohan Hedberg 22975e84b7cSJohan Hedberg hdr = (void *) skb->data; 23075e84b7cSJohan Hedberg skb_pull(skb, HCI_EVENT_HDR_SIZE); 23175e84b7cSJohan Hedberg 2327b1abbbeSJohan Hedberg if (event) { 2337b1abbbeSJohan Hedberg if (hdr->evt != event) 2347b1abbbeSJohan Hedberg goto failed; 2357b1abbbeSJohan Hedberg return skb; 2367b1abbbeSJohan Hedberg } 2377b1abbbeSJohan Hedberg 23875e84b7cSJohan Hedberg if (hdr->evt != HCI_EV_CMD_COMPLETE) { 23975e84b7cSJohan Hedberg BT_DBG("Last event is not cmd complete (0x%2.2x)", hdr->evt); 24075e84b7cSJohan Hedberg goto failed; 24175e84b7cSJohan Hedberg } 24275e84b7cSJohan Hedberg 24375e84b7cSJohan Hedberg if (skb->len < sizeof(*ev)) { 24475e84b7cSJohan Hedberg BT_ERR("Too short cmd_complete event"); 24575e84b7cSJohan Hedberg goto failed; 24675e84b7cSJohan Hedberg } 24775e84b7cSJohan Hedberg 24875e84b7cSJohan Hedberg ev = (void *) skb->data; 24975e84b7cSJohan Hedberg skb_pull(skb, sizeof(*ev)); 25075e84b7cSJohan Hedberg 25175e84b7cSJohan Hedberg if (opcode == __le16_to_cpu(ev->opcode)) 25275e84b7cSJohan Hedberg return skb; 25375e84b7cSJohan Hedberg 25475e84b7cSJohan Hedberg BT_DBG("opcode doesn't match (0x%2.2x != 0x%2.2x)", opcode, 25575e84b7cSJohan Hedberg __le16_to_cpu(ev->opcode)); 25675e84b7cSJohan Hedberg 25775e84b7cSJohan Hedberg failed: 25875e84b7cSJohan Hedberg kfree_skb(skb); 25975e84b7cSJohan Hedberg return ERR_PTR(-ENODATA); 26075e84b7cSJohan Hedberg } 26175e84b7cSJohan Hedberg 2627b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync_ev(struct hci_dev *hdev, u16 opcode, u32 plen, 26307dc93ddSJohan Hedberg const void *param, u8 event, u32 timeout) 26475e84b7cSJohan Hedberg { 26575e84b7cSJohan Hedberg DECLARE_WAITQUEUE(wait, current); 26675e84b7cSJohan Hedberg struct hci_request req; 26775e84b7cSJohan Hedberg int err = 0; 26875e84b7cSJohan Hedberg 26975e84b7cSJohan Hedberg BT_DBG("%s", hdev->name); 27075e84b7cSJohan Hedberg 27175e84b7cSJohan Hedberg hci_req_init(&req, hdev); 27275e84b7cSJohan Hedberg 2737b1abbbeSJohan Hedberg hci_req_add_ev(&req, opcode, plen, param, event); 27475e84b7cSJohan Hedberg 27575e84b7cSJohan Hedberg hdev->req_status = HCI_REQ_PEND; 27675e84b7cSJohan Hedberg 27775e84b7cSJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 27875e84b7cSJohan Hedberg if (err < 0) 27975e84b7cSJohan Hedberg return ERR_PTR(err); 28075e84b7cSJohan Hedberg 28175e84b7cSJohan Hedberg add_wait_queue(&hdev->req_wait_q, &wait); 28275e84b7cSJohan Hedberg set_current_state(TASK_INTERRUPTIBLE); 28375e84b7cSJohan Hedberg 28475e84b7cSJohan Hedberg schedule_timeout(timeout); 28575e84b7cSJohan Hedberg 28675e84b7cSJohan Hedberg remove_wait_queue(&hdev->req_wait_q, &wait); 28775e84b7cSJohan Hedberg 28875e84b7cSJohan Hedberg if (signal_pending(current)) 28975e84b7cSJohan Hedberg return ERR_PTR(-EINTR); 29075e84b7cSJohan Hedberg 29175e84b7cSJohan Hedberg switch (hdev->req_status) { 29275e84b7cSJohan Hedberg case HCI_REQ_DONE: 29375e84b7cSJohan Hedberg err = -bt_to_errno(hdev->req_result); 29475e84b7cSJohan Hedberg break; 29575e84b7cSJohan Hedberg 29675e84b7cSJohan Hedberg case HCI_REQ_CANCELED: 29775e84b7cSJohan Hedberg err = -hdev->req_result; 29875e84b7cSJohan Hedberg break; 29975e84b7cSJohan Hedberg 30075e84b7cSJohan Hedberg default: 30175e84b7cSJohan Hedberg err = -ETIMEDOUT; 30275e84b7cSJohan Hedberg break; 30375e84b7cSJohan Hedberg } 30475e84b7cSJohan Hedberg 30575e84b7cSJohan Hedberg hdev->req_status = hdev->req_result = 0; 30675e84b7cSJohan Hedberg 30775e84b7cSJohan Hedberg BT_DBG("%s end: err %d", hdev->name, err); 30875e84b7cSJohan Hedberg 30975e84b7cSJohan Hedberg if (err < 0) 31075e84b7cSJohan Hedberg return ERR_PTR(err); 31175e84b7cSJohan Hedberg 3127b1abbbeSJohan Hedberg return hci_get_cmd_complete(hdev, opcode, event); 3137b1abbbeSJohan Hedberg } 3147b1abbbeSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync_ev); 3157b1abbbeSJohan Hedberg 3167b1abbbeSJohan Hedberg struct sk_buff *__hci_cmd_sync(struct hci_dev *hdev, u16 opcode, u32 plen, 31707dc93ddSJohan Hedberg const void *param, u32 timeout) 3187b1abbbeSJohan Hedberg { 3197b1abbbeSJohan Hedberg return __hci_cmd_sync_ev(hdev, opcode, plen, param, 0, timeout); 32075e84b7cSJohan Hedberg } 32175e84b7cSJohan Hedberg EXPORT_SYMBOL(__hci_cmd_sync); 32275e84b7cSJohan Hedberg 3231da177e4SLinus Torvalds /* Execute request and wait for completion. */ 32401178cd4SJohan Hedberg static int __hci_req_sync(struct hci_dev *hdev, 32542c6b129SJohan Hedberg void (*func)(struct hci_request *req, 32642c6b129SJohan Hedberg unsigned long opt), 3271da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 3281da177e4SLinus Torvalds { 32942c6b129SJohan Hedberg struct hci_request req; 3301da177e4SLinus Torvalds DECLARE_WAITQUEUE(wait, current); 3311da177e4SLinus Torvalds int err = 0; 3321da177e4SLinus Torvalds 3331da177e4SLinus Torvalds BT_DBG("%s start", hdev->name); 3341da177e4SLinus Torvalds 33542c6b129SJohan Hedberg hci_req_init(&req, hdev); 33642c6b129SJohan Hedberg 3371da177e4SLinus Torvalds hdev->req_status = HCI_REQ_PEND; 3381da177e4SLinus Torvalds 33942c6b129SJohan Hedberg func(&req, opt); 34053cce22dSJohan Hedberg 34142c6b129SJohan Hedberg err = hci_req_run(&req, hci_req_sync_complete); 34242c6b129SJohan Hedberg if (err < 0) { 34353cce22dSJohan Hedberg hdev->req_status = 0; 344920c8300SAndre Guedes 345920c8300SAndre Guedes /* ENODATA means the HCI request command queue is empty. 346920c8300SAndre Guedes * This can happen when a request with conditionals doesn't 347920c8300SAndre Guedes * trigger any commands to be sent. This is normal behavior 348920c8300SAndre Guedes * and should not trigger an error return. 34942c6b129SJohan Hedberg */ 350920c8300SAndre Guedes if (err == -ENODATA) 35142c6b129SJohan Hedberg return 0; 352920c8300SAndre Guedes 353920c8300SAndre Guedes return err; 35453cce22dSJohan Hedberg } 35553cce22dSJohan Hedberg 356bc4445c7SAndre Guedes add_wait_queue(&hdev->req_wait_q, &wait); 357bc4445c7SAndre Guedes set_current_state(TASK_INTERRUPTIBLE); 358bc4445c7SAndre Guedes 3591da177e4SLinus Torvalds schedule_timeout(timeout); 3601da177e4SLinus Torvalds 3611da177e4SLinus Torvalds remove_wait_queue(&hdev->req_wait_q, &wait); 3621da177e4SLinus Torvalds 3631da177e4SLinus Torvalds if (signal_pending(current)) 3641da177e4SLinus Torvalds return -EINTR; 3651da177e4SLinus Torvalds 3661da177e4SLinus Torvalds switch (hdev->req_status) { 3671da177e4SLinus Torvalds case HCI_REQ_DONE: 368e175072fSJoe Perches err = -bt_to_errno(hdev->req_result); 3691da177e4SLinus Torvalds break; 3701da177e4SLinus Torvalds 3711da177e4SLinus Torvalds case HCI_REQ_CANCELED: 3721da177e4SLinus Torvalds err = -hdev->req_result; 3731da177e4SLinus Torvalds break; 3741da177e4SLinus Torvalds 3751da177e4SLinus Torvalds default: 3761da177e4SLinus Torvalds err = -ETIMEDOUT; 3771da177e4SLinus Torvalds break; 3783ff50b79SStephen Hemminger } 3791da177e4SLinus Torvalds 380a5040efaSJohan Hedberg hdev->req_status = hdev->req_result = 0; 3811da177e4SLinus Torvalds 3821da177e4SLinus Torvalds BT_DBG("%s end: err %d", hdev->name, err); 3831da177e4SLinus Torvalds 3841da177e4SLinus Torvalds return err; 3851da177e4SLinus Torvalds } 3861da177e4SLinus Torvalds 38701178cd4SJohan Hedberg static int hci_req_sync(struct hci_dev *hdev, 38842c6b129SJohan Hedberg void (*req)(struct hci_request *req, 38942c6b129SJohan Hedberg unsigned long opt), 3901da177e4SLinus Torvalds unsigned long opt, __u32 timeout) 3911da177e4SLinus Torvalds { 3921da177e4SLinus Torvalds int ret; 3931da177e4SLinus Torvalds 3947c6a329eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) 3957c6a329eSMarcel Holtmann return -ENETDOWN; 3967c6a329eSMarcel Holtmann 3971da177e4SLinus Torvalds /* Serialize all requests */ 3981da177e4SLinus Torvalds hci_req_lock(hdev); 39901178cd4SJohan Hedberg ret = __hci_req_sync(hdev, req, opt, timeout); 4001da177e4SLinus Torvalds hci_req_unlock(hdev); 4011da177e4SLinus Torvalds 4021da177e4SLinus Torvalds return ret; 4031da177e4SLinus Torvalds } 4041da177e4SLinus Torvalds 40542c6b129SJohan Hedberg static void hci_reset_req(struct hci_request *req, unsigned long opt) 4061da177e4SLinus Torvalds { 40742c6b129SJohan Hedberg BT_DBG("%s %ld", req->hdev->name, opt); 4081da177e4SLinus Torvalds 4091da177e4SLinus Torvalds /* Reset device */ 41042c6b129SJohan Hedberg set_bit(HCI_RESET, &req->hdev->flags); 41142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_RESET, 0, NULL); 4121da177e4SLinus Torvalds } 4131da177e4SLinus Torvalds 41442c6b129SJohan Hedberg static void bredr_init(struct hci_request *req) 4151da177e4SLinus Torvalds { 41642c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_PACKET_BASED; 4172455a3eaSAndrei Emeltchenko 4181da177e4SLinus Torvalds /* Read Local Supported Features */ 41942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 4201da177e4SLinus Torvalds 4211143e5a6SMarcel Holtmann /* Read Local Version */ 42242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 4232177bab5SJohan Hedberg 4242177bab5SJohan Hedberg /* Read BD Address */ 42542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BD_ADDR, 0, NULL); 4261da177e4SLinus Torvalds } 4271da177e4SLinus Torvalds 42842c6b129SJohan Hedberg static void amp_init(struct hci_request *req) 429e61ef499SAndrei Emeltchenko { 43042c6b129SJohan Hedberg req->hdev->flow_ctl_mode = HCI_FLOW_CTL_MODE_BLOCK_BASED; 4312455a3eaSAndrei Emeltchenko 432e61ef499SAndrei Emeltchenko /* Read Local Version */ 43342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_VERSION, 0, NULL); 4346bcbc489SAndrei Emeltchenko 435f6996cfeSMarcel Holtmann /* Read Local Supported Commands */ 436f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 437f6996cfeSMarcel Holtmann 438f6996cfeSMarcel Holtmann /* Read Local Supported Features */ 439f6996cfeSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCAL_FEATURES, 0, NULL); 440f6996cfeSMarcel Holtmann 4416bcbc489SAndrei Emeltchenko /* Read Local AMP Info */ 44242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_AMP_INFO, 0, NULL); 443e71dfabaSAndrei Emeltchenko 444e71dfabaSAndrei Emeltchenko /* Read Data Blk size */ 44542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_DATA_BLOCK_SIZE, 0, NULL); 4467528ca1cSMarcel Holtmann 447f38ba941SMarcel Holtmann /* Read Flow Control Mode */ 448f38ba941SMarcel Holtmann hci_req_add(req, HCI_OP_READ_FLOW_CONTROL_MODE, 0, NULL); 449f38ba941SMarcel Holtmann 4507528ca1cSMarcel Holtmann /* Read Location Data */ 4517528ca1cSMarcel Holtmann hci_req_add(req, HCI_OP_READ_LOCATION_DATA, 0, NULL); 452e61ef499SAndrei Emeltchenko } 453e61ef499SAndrei Emeltchenko 45442c6b129SJohan Hedberg static void hci_init1_req(struct hci_request *req, unsigned long opt) 455e61ef499SAndrei Emeltchenko { 45642c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 457e61ef499SAndrei Emeltchenko 458e61ef499SAndrei Emeltchenko BT_DBG("%s %ld", hdev->name, opt); 459e61ef499SAndrei Emeltchenko 46011778716SAndrei Emeltchenko /* Reset */ 46111778716SAndrei Emeltchenko if (!test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) 46242c6b129SJohan Hedberg hci_reset_req(req, 0); 46311778716SAndrei Emeltchenko 464e61ef499SAndrei Emeltchenko switch (hdev->dev_type) { 465e61ef499SAndrei Emeltchenko case HCI_BREDR: 46642c6b129SJohan Hedberg bredr_init(req); 467e61ef499SAndrei Emeltchenko break; 468e61ef499SAndrei Emeltchenko 469e61ef499SAndrei Emeltchenko case HCI_AMP: 47042c6b129SJohan Hedberg amp_init(req); 471e61ef499SAndrei Emeltchenko break; 472e61ef499SAndrei Emeltchenko 473e61ef499SAndrei Emeltchenko default: 474e61ef499SAndrei Emeltchenko BT_ERR("Unknown device type %d", hdev->dev_type); 475e61ef499SAndrei Emeltchenko break; 476e61ef499SAndrei Emeltchenko } 477e61ef499SAndrei Emeltchenko } 478e61ef499SAndrei Emeltchenko 47942c6b129SJohan Hedberg static void bredr_setup(struct hci_request *req) 4802177bab5SJohan Hedberg { 4814ca048e3SMarcel Holtmann struct hci_dev *hdev = req->hdev; 4824ca048e3SMarcel Holtmann 4832177bab5SJohan Hedberg __le16 param; 4842177bab5SJohan Hedberg __u8 flt_type; 4852177bab5SJohan Hedberg 4862177bab5SJohan Hedberg /* Read Buffer Size (ACL mtu, max pkt, etc.) */ 48742c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_BUFFER_SIZE, 0, NULL); 4882177bab5SJohan Hedberg 4892177bab5SJohan Hedberg /* Read Class of Device */ 49042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_CLASS_OF_DEV, 0, NULL); 4912177bab5SJohan Hedberg 4922177bab5SJohan Hedberg /* Read Local Name */ 49342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_NAME, 0, NULL); 4942177bab5SJohan Hedberg 4952177bab5SJohan Hedberg /* Read Voice Setting */ 49642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_VOICE_SETTING, 0, NULL); 4972177bab5SJohan Hedberg 498b4cb9fb2SMarcel Holtmann /* Read Number of Supported IAC */ 499b4cb9fb2SMarcel Holtmann hci_req_add(req, HCI_OP_READ_NUM_SUPPORTED_IAC, 0, NULL); 500b4cb9fb2SMarcel Holtmann 5014b836f39SMarcel Holtmann /* Read Current IAC LAP */ 5024b836f39SMarcel Holtmann hci_req_add(req, HCI_OP_READ_CURRENT_IAC_LAP, 0, NULL); 5034b836f39SMarcel Holtmann 5042177bab5SJohan Hedberg /* Clear Event Filters */ 5052177bab5SJohan Hedberg flt_type = HCI_FLT_CLEAR_ALL; 50642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_FLT, 1, &flt_type); 5072177bab5SJohan Hedberg 5082177bab5SJohan Hedberg /* Connection accept timeout ~20 secs */ 5092177bab5SJohan Hedberg param = __constant_cpu_to_le16(0x7d00); 51042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_CA_TIMEOUT, 2, ¶m); 5112177bab5SJohan Hedberg 5124ca048e3SMarcel Holtmann /* AVM Berlin (31), aka "BlueFRITZ!", reports version 1.2, 5134ca048e3SMarcel Holtmann * but it does not support page scan related HCI commands. 5144ca048e3SMarcel Holtmann */ 5154ca048e3SMarcel Holtmann if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) { 516f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_ACTIVITY, 0, NULL); 517f332ec66SJohan Hedberg hci_req_add(req, HCI_OP_READ_PAGE_SCAN_TYPE, 0, NULL); 518f332ec66SJohan Hedberg } 5192177bab5SJohan Hedberg } 5202177bab5SJohan Hedberg 52142c6b129SJohan Hedberg static void le_setup(struct hci_request *req) 5222177bab5SJohan Hedberg { 523c73eee91SJohan Hedberg struct hci_dev *hdev = req->hdev; 524c73eee91SJohan Hedberg 5252177bab5SJohan Hedberg /* Read LE Buffer Size */ 52642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_BUFFER_SIZE, 0, NULL); 5272177bab5SJohan Hedberg 5282177bab5SJohan Hedberg /* Read LE Local Supported Features */ 52942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_LOCAL_FEATURES, 0, NULL); 5302177bab5SJohan Hedberg 5312177bab5SJohan Hedberg /* Read LE Advertising Channel TX Power */ 53242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_ADV_TX_POWER, 0, NULL); 5332177bab5SJohan Hedberg 5342177bab5SJohan Hedberg /* Read LE White List Size */ 53542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_WHITE_LIST_SIZE, 0, NULL); 5362177bab5SJohan Hedberg 5372177bab5SJohan Hedberg /* Read LE Supported States */ 53842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_READ_SUPPORTED_STATES, 0, NULL); 539c73eee91SJohan Hedberg 540c73eee91SJohan Hedberg /* LE-only controllers have LE implicitly enabled */ 541c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 542c73eee91SJohan Hedberg set_bit(HCI_LE_ENABLED, &hdev->dev_flags); 5432177bab5SJohan Hedberg } 5442177bab5SJohan Hedberg 5452177bab5SJohan Hedberg static u8 hci_get_inquiry_mode(struct hci_dev *hdev) 5462177bab5SJohan Hedberg { 5472177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 5482177bab5SJohan Hedberg return 0x02; 5492177bab5SJohan Hedberg 5502177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 5512177bab5SJohan Hedberg return 0x01; 5522177bab5SJohan Hedberg 5532177bab5SJohan Hedberg if (hdev->manufacturer == 11 && hdev->hci_rev == 0x00 && 5542177bab5SJohan Hedberg hdev->lmp_subver == 0x0757) 5552177bab5SJohan Hedberg return 0x01; 5562177bab5SJohan Hedberg 5572177bab5SJohan Hedberg if (hdev->manufacturer == 15) { 5582177bab5SJohan Hedberg if (hdev->hci_rev == 0x03 && hdev->lmp_subver == 0x6963) 5592177bab5SJohan Hedberg return 0x01; 5602177bab5SJohan Hedberg if (hdev->hci_rev == 0x09 && hdev->lmp_subver == 0x6963) 5612177bab5SJohan Hedberg return 0x01; 5622177bab5SJohan Hedberg if (hdev->hci_rev == 0x00 && hdev->lmp_subver == 0x6965) 5632177bab5SJohan Hedberg return 0x01; 5642177bab5SJohan Hedberg } 5652177bab5SJohan Hedberg 5662177bab5SJohan Hedberg if (hdev->manufacturer == 31 && hdev->hci_rev == 0x2005 && 5672177bab5SJohan Hedberg hdev->lmp_subver == 0x1805) 5682177bab5SJohan Hedberg return 0x01; 5692177bab5SJohan Hedberg 5702177bab5SJohan Hedberg return 0x00; 5712177bab5SJohan Hedberg } 5722177bab5SJohan Hedberg 57342c6b129SJohan Hedberg static void hci_setup_inquiry_mode(struct hci_request *req) 5742177bab5SJohan Hedberg { 5752177bab5SJohan Hedberg u8 mode; 5762177bab5SJohan Hedberg 57742c6b129SJohan Hedberg mode = hci_get_inquiry_mode(req->hdev); 5782177bab5SJohan Hedberg 57942c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_INQUIRY_MODE, 1, &mode); 5802177bab5SJohan Hedberg } 5812177bab5SJohan Hedberg 58242c6b129SJohan Hedberg static void hci_setup_event_mask(struct hci_request *req) 5832177bab5SJohan Hedberg { 58442c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 58542c6b129SJohan Hedberg 5862177bab5SJohan Hedberg /* The second byte is 0xff instead of 0x9f (two reserved bits 5872177bab5SJohan Hedberg * disabled) since a Broadcom 1.2 dongle doesn't respond to the 5882177bab5SJohan Hedberg * command otherwise. 5892177bab5SJohan Hedberg */ 5902177bab5SJohan Hedberg u8 events[8] = { 0xff, 0xff, 0xfb, 0xff, 0x00, 0x00, 0x00, 0x00 }; 5912177bab5SJohan Hedberg 5922177bab5SJohan Hedberg /* CSR 1.1 dongles does not accept any bitfield so don't try to set 5932177bab5SJohan Hedberg * any event mask for pre 1.2 devices. 5942177bab5SJohan Hedberg */ 5952177bab5SJohan Hedberg if (hdev->hci_ver < BLUETOOTH_VER_1_2) 5962177bab5SJohan Hedberg return; 5972177bab5SJohan Hedberg 5982177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) { 5992177bab5SJohan Hedberg events[4] |= 0x01; /* Flow Specification Complete */ 6002177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 6012177bab5SJohan Hedberg events[4] |= 0x04; /* Read Remote Extended Features Complete */ 6022177bab5SJohan Hedberg events[5] |= 0x08; /* Synchronous Connection Complete */ 6032177bab5SJohan Hedberg events[5] |= 0x10; /* Synchronous Connection Changed */ 604c7882cbdSMarcel Holtmann } else { 605c7882cbdSMarcel Holtmann /* Use a different default for LE-only devices */ 606c7882cbdSMarcel Holtmann memset(events, 0, sizeof(events)); 607c7882cbdSMarcel Holtmann events[0] |= 0x10; /* Disconnection Complete */ 608c7882cbdSMarcel Holtmann events[0] |= 0x80; /* Encryption Change */ 609c7882cbdSMarcel Holtmann events[1] |= 0x08; /* Read Remote Version Information Complete */ 610c7882cbdSMarcel Holtmann events[1] |= 0x20; /* Command Complete */ 611c7882cbdSMarcel Holtmann events[1] |= 0x40; /* Command Status */ 612c7882cbdSMarcel Holtmann events[1] |= 0x80; /* Hardware Error */ 613c7882cbdSMarcel Holtmann events[2] |= 0x04; /* Number of Completed Packets */ 614c7882cbdSMarcel Holtmann events[3] |= 0x02; /* Data Buffer Overflow */ 615c7882cbdSMarcel Holtmann events[5] |= 0x80; /* Encryption Key Refresh Complete */ 6162177bab5SJohan Hedberg } 6172177bab5SJohan Hedberg 6182177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 6192177bab5SJohan Hedberg events[4] |= 0x02; /* Inquiry Result with RSSI */ 6202177bab5SJohan Hedberg 6212177bab5SJohan Hedberg if (lmp_sniffsubr_capable(hdev)) 6222177bab5SJohan Hedberg events[5] |= 0x20; /* Sniff Subrating */ 6232177bab5SJohan Hedberg 6242177bab5SJohan Hedberg if (lmp_pause_enc_capable(hdev)) 6252177bab5SJohan Hedberg events[5] |= 0x80; /* Encryption Key Refresh Complete */ 6262177bab5SJohan Hedberg 6272177bab5SJohan Hedberg if (lmp_ext_inq_capable(hdev)) 6282177bab5SJohan Hedberg events[5] |= 0x40; /* Extended Inquiry Result */ 6292177bab5SJohan Hedberg 6302177bab5SJohan Hedberg if (lmp_no_flush_capable(hdev)) 6312177bab5SJohan Hedberg events[7] |= 0x01; /* Enhanced Flush Complete */ 6322177bab5SJohan Hedberg 6332177bab5SJohan Hedberg if (lmp_lsto_capable(hdev)) 6342177bab5SJohan Hedberg events[6] |= 0x80; /* Link Supervision Timeout Changed */ 6352177bab5SJohan Hedberg 6362177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 6372177bab5SJohan Hedberg events[6] |= 0x01; /* IO Capability Request */ 6382177bab5SJohan Hedberg events[6] |= 0x02; /* IO Capability Response */ 6392177bab5SJohan Hedberg events[6] |= 0x04; /* User Confirmation Request */ 6402177bab5SJohan Hedberg events[6] |= 0x08; /* User Passkey Request */ 6412177bab5SJohan Hedberg events[6] |= 0x10; /* Remote OOB Data Request */ 6422177bab5SJohan Hedberg events[6] |= 0x20; /* Simple Pairing Complete */ 6432177bab5SJohan Hedberg events[7] |= 0x04; /* User Passkey Notification */ 6442177bab5SJohan Hedberg events[7] |= 0x08; /* Keypress Notification */ 6452177bab5SJohan Hedberg events[7] |= 0x10; /* Remote Host Supported 6462177bab5SJohan Hedberg * Features Notification 6472177bab5SJohan Hedberg */ 6482177bab5SJohan Hedberg } 6492177bab5SJohan Hedberg 6502177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 6512177bab5SJohan Hedberg events[7] |= 0x20; /* LE Meta-Event */ 6522177bab5SJohan Hedberg 65342c6b129SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK, sizeof(events), events); 6542177bab5SJohan Hedberg 6552177bab5SJohan Hedberg if (lmp_le_capable(hdev)) { 6562177bab5SJohan Hedberg memset(events, 0, sizeof(events)); 6572177bab5SJohan Hedberg events[0] = 0x1f; 65842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_LE_SET_EVENT_MASK, 6592177bab5SJohan Hedberg sizeof(events), events); 6602177bab5SJohan Hedberg } 6612177bab5SJohan Hedberg } 6622177bab5SJohan Hedberg 66342c6b129SJohan Hedberg static void hci_init2_req(struct hci_request *req, unsigned long opt) 6642177bab5SJohan Hedberg { 66542c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 66642c6b129SJohan Hedberg 6672177bab5SJohan Hedberg if (lmp_bredr_capable(hdev)) 66842c6b129SJohan Hedberg bredr_setup(req); 66956f87901SJohan Hedberg else 67056f87901SJohan Hedberg clear_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 6712177bab5SJohan Hedberg 6722177bab5SJohan Hedberg if (lmp_le_capable(hdev)) 67342c6b129SJohan Hedberg le_setup(req); 6742177bab5SJohan Hedberg 67542c6b129SJohan Hedberg hci_setup_event_mask(req); 6762177bab5SJohan Hedberg 6773f8e2d75SJohan Hedberg /* AVM Berlin (31), aka "BlueFRITZ!", doesn't support the read 6783f8e2d75SJohan Hedberg * local supported commands HCI command. 6793f8e2d75SJohan Hedberg */ 6803f8e2d75SJohan Hedberg if (hdev->manufacturer != 31 && hdev->hci_ver > BLUETOOTH_VER_1_1) 68142c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_COMMANDS, 0, NULL); 6822177bab5SJohan Hedberg 6832177bab5SJohan Hedberg if (lmp_ssp_capable(hdev)) { 6842177bab5SJohan Hedberg if (test_bit(HCI_SSP_ENABLED, &hdev->dev_flags)) { 6852177bab5SJohan Hedberg u8 mode = 0x01; 68642c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SSP_MODE, 6872177bab5SJohan Hedberg sizeof(mode), &mode); 6882177bab5SJohan Hedberg } else { 6892177bab5SJohan Hedberg struct hci_cp_write_eir cp; 6902177bab5SJohan Hedberg 6912177bab5SJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 6922177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 6932177bab5SJohan Hedberg 69442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_EIR, sizeof(cp), &cp); 6952177bab5SJohan Hedberg } 6962177bab5SJohan Hedberg } 6972177bab5SJohan Hedberg 6982177bab5SJohan Hedberg if (lmp_inq_rssi_capable(hdev)) 69942c6b129SJohan Hedberg hci_setup_inquiry_mode(req); 7002177bab5SJohan Hedberg 7012177bab5SJohan Hedberg if (lmp_inq_tx_pwr_capable(hdev)) 70242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_INQ_RSP_TX_POWER, 0, NULL); 7032177bab5SJohan Hedberg 7042177bab5SJohan Hedberg if (lmp_ext_feat_capable(hdev)) { 7052177bab5SJohan Hedberg struct hci_cp_read_local_ext_features cp; 7062177bab5SJohan Hedberg 7072177bab5SJohan Hedberg cp.page = 0x01; 70842c6b129SJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 70942c6b129SJohan Hedberg sizeof(cp), &cp); 7102177bab5SJohan Hedberg } 7112177bab5SJohan Hedberg 7122177bab5SJohan Hedberg if (test_bit(HCI_LINK_SECURITY, &hdev->dev_flags)) { 7132177bab5SJohan Hedberg u8 enable = 1; 71442c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, sizeof(enable), 7152177bab5SJohan Hedberg &enable); 7162177bab5SJohan Hedberg } 7172177bab5SJohan Hedberg } 7182177bab5SJohan Hedberg 71942c6b129SJohan Hedberg static void hci_setup_link_policy(struct hci_request *req) 7202177bab5SJohan Hedberg { 72142c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 7222177bab5SJohan Hedberg struct hci_cp_write_def_link_policy cp; 7232177bab5SJohan Hedberg u16 link_policy = 0; 7242177bab5SJohan Hedberg 7252177bab5SJohan Hedberg if (lmp_rswitch_capable(hdev)) 7262177bab5SJohan Hedberg link_policy |= HCI_LP_RSWITCH; 7272177bab5SJohan Hedberg if (lmp_hold_capable(hdev)) 7282177bab5SJohan Hedberg link_policy |= HCI_LP_HOLD; 7292177bab5SJohan Hedberg if (lmp_sniff_capable(hdev)) 7302177bab5SJohan Hedberg link_policy |= HCI_LP_SNIFF; 7312177bab5SJohan Hedberg if (lmp_park_capable(hdev)) 7322177bab5SJohan Hedberg link_policy |= HCI_LP_PARK; 7332177bab5SJohan Hedberg 7342177bab5SJohan Hedberg cp.policy = cpu_to_le16(link_policy); 73542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, sizeof(cp), &cp); 7362177bab5SJohan Hedberg } 7372177bab5SJohan Hedberg 73842c6b129SJohan Hedberg static void hci_set_le_support(struct hci_request *req) 7392177bab5SJohan Hedberg { 74042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 7412177bab5SJohan Hedberg struct hci_cp_write_le_host_supported cp; 7422177bab5SJohan Hedberg 743c73eee91SJohan Hedberg /* LE-only devices do not support explicit enablement */ 744c73eee91SJohan Hedberg if (!lmp_bredr_capable(hdev)) 745c73eee91SJohan Hedberg return; 746c73eee91SJohan Hedberg 7472177bab5SJohan Hedberg memset(&cp, 0, sizeof(cp)); 7482177bab5SJohan Hedberg 7492177bab5SJohan Hedberg if (test_bit(HCI_LE_ENABLED, &hdev->dev_flags)) { 7502177bab5SJohan Hedberg cp.le = 0x01; 7512177bab5SJohan Hedberg cp.simul = lmp_le_br_capable(hdev); 7522177bab5SJohan Hedberg } 7532177bab5SJohan Hedberg 7542177bab5SJohan Hedberg if (cp.le != lmp_host_le_capable(hdev)) 75542c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_LE_HOST_SUPPORTED, sizeof(cp), 7562177bab5SJohan Hedberg &cp); 7572177bab5SJohan Hedberg } 7582177bab5SJohan Hedberg 759d62e6d67SJohan Hedberg static void hci_set_event_mask_page_2(struct hci_request *req) 760d62e6d67SJohan Hedberg { 761d62e6d67SJohan Hedberg struct hci_dev *hdev = req->hdev; 762d62e6d67SJohan Hedberg u8 events[8] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }; 763d62e6d67SJohan Hedberg 764d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast master role is supported 765d62e6d67SJohan Hedberg * enable all necessary events for it. 766d62e6d67SJohan Hedberg */ 767d62e6d67SJohan Hedberg if (hdev->features[2][0] & 0x01) { 768d62e6d67SJohan Hedberg events[1] |= 0x40; /* Triggered Clock Capture */ 769d62e6d67SJohan Hedberg events[1] |= 0x80; /* Synchronization Train Complete */ 770d62e6d67SJohan Hedberg events[2] |= 0x10; /* Slave Page Response Timeout */ 771d62e6d67SJohan Hedberg events[2] |= 0x20; /* CSB Channel Map Change */ 772d62e6d67SJohan Hedberg } 773d62e6d67SJohan Hedberg 774d62e6d67SJohan Hedberg /* If Connectionless Slave Broadcast slave role is supported 775d62e6d67SJohan Hedberg * enable all necessary events for it. 776d62e6d67SJohan Hedberg */ 777d62e6d67SJohan Hedberg if (hdev->features[2][0] & 0x02) { 778d62e6d67SJohan Hedberg events[2] |= 0x01; /* Synchronization Train Received */ 779d62e6d67SJohan Hedberg events[2] |= 0x02; /* CSB Receive */ 780d62e6d67SJohan Hedberg events[2] |= 0x04; /* CSB Timeout */ 781d62e6d67SJohan Hedberg events[2] |= 0x08; /* Truncated Page Complete */ 782d62e6d67SJohan Hedberg } 783d62e6d67SJohan Hedberg 784d62e6d67SJohan Hedberg hci_req_add(req, HCI_OP_SET_EVENT_MASK_PAGE_2, sizeof(events), events); 785d62e6d67SJohan Hedberg } 786d62e6d67SJohan Hedberg 78742c6b129SJohan Hedberg static void hci_init3_req(struct hci_request *req, unsigned long opt) 7882177bab5SJohan Hedberg { 78942c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 790d2c5d77fSJohan Hedberg u8 p; 79142c6b129SJohan Hedberg 792b8f4e068SGustavo Padovan /* Some Broadcom based Bluetooth controllers do not support the 793b8f4e068SGustavo Padovan * Delete Stored Link Key command. They are clearly indicating its 794b8f4e068SGustavo Padovan * absence in the bit mask of supported commands. 795b8f4e068SGustavo Padovan * 796b8f4e068SGustavo Padovan * Check the supported commands and only if the the command is marked 797b8f4e068SGustavo Padovan * as supported send it. If not supported assume that the controller 798b8f4e068SGustavo Padovan * does not have actual support for stored link keys which makes this 799b8f4e068SGustavo Padovan * command redundant anyway. 800b8f4e068SGustavo Padovan */ 80159f45d57SJohan Hedberg if (hdev->commands[6] & 0x80) { 80259f45d57SJohan Hedberg struct hci_cp_delete_stored_link_key cp; 80359f45d57SJohan Hedberg 80459f45d57SJohan Hedberg bacpy(&cp.bdaddr, BDADDR_ANY); 80559f45d57SJohan Hedberg cp.delete_all = 0x01; 80659f45d57SJohan Hedberg hci_req_add(req, HCI_OP_DELETE_STORED_LINK_KEY, 80759f45d57SJohan Hedberg sizeof(cp), &cp); 80859f45d57SJohan Hedberg } 80959f45d57SJohan Hedberg 8102177bab5SJohan Hedberg if (hdev->commands[5] & 0x10) 81142c6b129SJohan Hedberg hci_setup_link_policy(req); 8122177bab5SJohan Hedberg 813441ad2d0SMarcel Holtmann if (lmp_le_capable(hdev)) 81442c6b129SJohan Hedberg hci_set_le_support(req); 815d2c5d77fSJohan Hedberg 816d2c5d77fSJohan Hedberg /* Read features beyond page 1 if available */ 817d2c5d77fSJohan Hedberg for (p = 2; p < HCI_MAX_PAGES && p <= hdev->max_page; p++) { 818d2c5d77fSJohan Hedberg struct hci_cp_read_local_ext_features cp; 819d2c5d77fSJohan Hedberg 820d2c5d77fSJohan Hedberg cp.page = p; 821d2c5d77fSJohan Hedberg hci_req_add(req, HCI_OP_READ_LOCAL_EXT_FEATURES, 822d2c5d77fSJohan Hedberg sizeof(cp), &cp); 823d2c5d77fSJohan Hedberg } 8242177bab5SJohan Hedberg } 8252177bab5SJohan Hedberg 8265d4e7e8dSJohan Hedberg static void hci_init4_req(struct hci_request *req, unsigned long opt) 8275d4e7e8dSJohan Hedberg { 8285d4e7e8dSJohan Hedberg struct hci_dev *hdev = req->hdev; 8295d4e7e8dSJohan Hedberg 830d62e6d67SJohan Hedberg /* Set event mask page 2 if the HCI command for it is supported */ 831d62e6d67SJohan Hedberg if (hdev->commands[22] & 0x04) 832d62e6d67SJohan Hedberg hci_set_event_mask_page_2(req); 833d62e6d67SJohan Hedberg 8345d4e7e8dSJohan Hedberg /* Check for Synchronization Train support */ 8355d4e7e8dSJohan Hedberg if (hdev->features[2][0] & 0x04) 8365d4e7e8dSJohan Hedberg hci_req_add(req, HCI_OP_READ_SYNC_TRAIN_PARAMS, 0, NULL); 8375d4e7e8dSJohan Hedberg } 8385d4e7e8dSJohan Hedberg 8392177bab5SJohan Hedberg static int __hci_init(struct hci_dev *hdev) 8402177bab5SJohan Hedberg { 8412177bab5SJohan Hedberg int err; 8422177bab5SJohan Hedberg 8432177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init1_req, 0, HCI_INIT_TIMEOUT); 8442177bab5SJohan Hedberg if (err < 0) 8452177bab5SJohan Hedberg return err; 8462177bab5SJohan Hedberg 8472177bab5SJohan Hedberg /* HCI_BREDR covers both single-mode LE, BR/EDR and dual-mode 8482177bab5SJohan Hedberg * BR/EDR/LE type controllers. AMP controllers only need the 8492177bab5SJohan Hedberg * first stage init. 8502177bab5SJohan Hedberg */ 8512177bab5SJohan Hedberg if (hdev->dev_type != HCI_BREDR) 8522177bab5SJohan Hedberg return 0; 8532177bab5SJohan Hedberg 8542177bab5SJohan Hedberg err = __hci_req_sync(hdev, hci_init2_req, 0, HCI_INIT_TIMEOUT); 8552177bab5SJohan Hedberg if (err < 0) 8562177bab5SJohan Hedberg return err; 8572177bab5SJohan Hedberg 8585d4e7e8dSJohan Hedberg err = __hci_req_sync(hdev, hci_init3_req, 0, HCI_INIT_TIMEOUT); 8595d4e7e8dSJohan Hedberg if (err < 0) 8605d4e7e8dSJohan Hedberg return err; 8615d4e7e8dSJohan Hedberg 862baf27f6eSMarcel Holtmann err = __hci_req_sync(hdev, hci_init4_req, 0, HCI_INIT_TIMEOUT); 863baf27f6eSMarcel Holtmann if (err < 0) 864baf27f6eSMarcel Holtmann return err; 865baf27f6eSMarcel Holtmann 866baf27f6eSMarcel Holtmann /* Only create debugfs entries during the initial setup 867baf27f6eSMarcel Holtmann * phase and not every time the controller gets powered on. 868baf27f6eSMarcel Holtmann */ 869baf27f6eSMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 870baf27f6eSMarcel Holtmann return 0; 871baf27f6eSMarcel Holtmann 872*70afe0b8SMarcel Holtmann debugfs_create_file("blacklist", 0444, hdev->debugfs, hdev, 873*70afe0b8SMarcel Holtmann &blacklist_fops); 874*70afe0b8SMarcel Holtmann 875baf27f6eSMarcel Holtmann if (lmp_bredr_capable(hdev)) { 876baf27f6eSMarcel Holtmann debugfs_create_file("inquiry_cache", 0444, hdev->debugfs, 877baf27f6eSMarcel Holtmann hdev, &inquiry_cache_fops); 878041000b9SMarcel Holtmann debugfs_create_file("voice_setting", 0444, hdev->debugfs, 879041000b9SMarcel Holtmann hdev, &voice_setting_fops); 880baf27f6eSMarcel Holtmann } 881baf27f6eSMarcel Holtmann 882ebd1e33bSMarcel Holtmann if (lmp_ssp_capable(hdev)) 883ebd1e33bSMarcel Holtmann debugfs_create_file("auto_accept_delay", 0644, hdev->debugfs, 884ebd1e33bSMarcel Holtmann hdev, &auto_accept_delay_fops); 885ebd1e33bSMarcel Holtmann 886e7b8fc92SMarcel Holtmann if (lmp_le_capable(hdev)) 887e7b8fc92SMarcel Holtmann debugfs_create_file("static_address", 0444, hdev->debugfs, 888e7b8fc92SMarcel Holtmann hdev, &static_address_fops); 889e7b8fc92SMarcel Holtmann 890baf27f6eSMarcel Holtmann return 0; 8912177bab5SJohan Hedberg } 8922177bab5SJohan Hedberg 89342c6b129SJohan Hedberg static void hci_scan_req(struct hci_request *req, unsigned long opt) 8941da177e4SLinus Torvalds { 8951da177e4SLinus Torvalds __u8 scan = opt; 8961da177e4SLinus Torvalds 89742c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, scan); 8981da177e4SLinus Torvalds 8991da177e4SLinus Torvalds /* Inquiry and Page scans */ 90042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_SCAN_ENABLE, 1, &scan); 9011da177e4SLinus Torvalds } 9021da177e4SLinus Torvalds 90342c6b129SJohan Hedberg static void hci_auth_req(struct hci_request *req, unsigned long opt) 9041da177e4SLinus Torvalds { 9051da177e4SLinus Torvalds __u8 auth = opt; 9061da177e4SLinus Torvalds 90742c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, auth); 9081da177e4SLinus Torvalds 9091da177e4SLinus Torvalds /* Authentication */ 91042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_AUTH_ENABLE, 1, &auth); 9111da177e4SLinus Torvalds } 9121da177e4SLinus Torvalds 91342c6b129SJohan Hedberg static void hci_encrypt_req(struct hci_request *req, unsigned long opt) 9141da177e4SLinus Torvalds { 9151da177e4SLinus Torvalds __u8 encrypt = opt; 9161da177e4SLinus Torvalds 91742c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, encrypt); 9181da177e4SLinus Torvalds 919e4e8e37cSMarcel Holtmann /* Encryption */ 92042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_ENCRYPT_MODE, 1, &encrypt); 9211da177e4SLinus Torvalds } 9221da177e4SLinus Torvalds 92342c6b129SJohan Hedberg static void hci_linkpol_req(struct hci_request *req, unsigned long opt) 924e4e8e37cSMarcel Holtmann { 925e4e8e37cSMarcel Holtmann __le16 policy = cpu_to_le16(opt); 926e4e8e37cSMarcel Holtmann 92742c6b129SJohan Hedberg BT_DBG("%s %x", req->hdev->name, policy); 928e4e8e37cSMarcel Holtmann 929e4e8e37cSMarcel Holtmann /* Default link policy */ 93042c6b129SJohan Hedberg hci_req_add(req, HCI_OP_WRITE_DEF_LINK_POLICY, 2, &policy); 931e4e8e37cSMarcel Holtmann } 932e4e8e37cSMarcel Holtmann 9331da177e4SLinus Torvalds /* Get HCI device by index. 9341da177e4SLinus Torvalds * Device is held on return. */ 9351da177e4SLinus Torvalds struct hci_dev *hci_dev_get(int index) 9361da177e4SLinus Torvalds { 9378035ded4SLuiz Augusto von Dentz struct hci_dev *hdev = NULL, *d; 9381da177e4SLinus Torvalds 9391da177e4SLinus Torvalds BT_DBG("%d", index); 9401da177e4SLinus Torvalds 9411da177e4SLinus Torvalds if (index < 0) 9421da177e4SLinus Torvalds return NULL; 9431da177e4SLinus Torvalds 9441da177e4SLinus Torvalds read_lock(&hci_dev_list_lock); 9458035ded4SLuiz Augusto von Dentz list_for_each_entry(d, &hci_dev_list, list) { 9461da177e4SLinus Torvalds if (d->id == index) { 9471da177e4SLinus Torvalds hdev = hci_dev_hold(d); 9481da177e4SLinus Torvalds break; 9491da177e4SLinus Torvalds } 9501da177e4SLinus Torvalds } 9511da177e4SLinus Torvalds read_unlock(&hci_dev_list_lock); 9521da177e4SLinus Torvalds return hdev; 9531da177e4SLinus Torvalds } 9541da177e4SLinus Torvalds 9551da177e4SLinus Torvalds /* ---- Inquiry support ---- */ 956ff9ef578SJohan Hedberg 95730dc78e1SJohan Hedberg bool hci_discovery_active(struct hci_dev *hdev) 95830dc78e1SJohan Hedberg { 95930dc78e1SJohan Hedberg struct discovery_state *discov = &hdev->discovery; 96030dc78e1SJohan Hedberg 9616fbe195dSAndre Guedes switch (discov->state) { 962343f935bSAndre Guedes case DISCOVERY_FINDING: 9636fbe195dSAndre Guedes case DISCOVERY_RESOLVING: 96430dc78e1SJohan Hedberg return true; 96530dc78e1SJohan Hedberg 9666fbe195dSAndre Guedes default: 96730dc78e1SJohan Hedberg return false; 96830dc78e1SJohan Hedberg } 9696fbe195dSAndre Guedes } 97030dc78e1SJohan Hedberg 971ff9ef578SJohan Hedberg void hci_discovery_set_state(struct hci_dev *hdev, int state) 972ff9ef578SJohan Hedberg { 973ff9ef578SJohan Hedberg BT_DBG("%s state %u -> %u", hdev->name, hdev->discovery.state, state); 974ff9ef578SJohan Hedberg 975ff9ef578SJohan Hedberg if (hdev->discovery.state == state) 976ff9ef578SJohan Hedberg return; 977ff9ef578SJohan Hedberg 978ff9ef578SJohan Hedberg switch (state) { 979ff9ef578SJohan Hedberg case DISCOVERY_STOPPED: 9807b99b659SAndre Guedes if (hdev->discovery.state != DISCOVERY_STARTING) 981ff9ef578SJohan Hedberg mgmt_discovering(hdev, 0); 982ff9ef578SJohan Hedberg break; 983ff9ef578SJohan Hedberg case DISCOVERY_STARTING: 984ff9ef578SJohan Hedberg break; 985343f935bSAndre Guedes case DISCOVERY_FINDING: 986ff9ef578SJohan Hedberg mgmt_discovering(hdev, 1); 987ff9ef578SJohan Hedberg break; 98830dc78e1SJohan Hedberg case DISCOVERY_RESOLVING: 98930dc78e1SJohan Hedberg break; 990ff9ef578SJohan Hedberg case DISCOVERY_STOPPING: 991ff9ef578SJohan Hedberg break; 992ff9ef578SJohan Hedberg } 993ff9ef578SJohan Hedberg 994ff9ef578SJohan Hedberg hdev->discovery.state = state; 995ff9ef578SJohan Hedberg } 996ff9ef578SJohan Hedberg 9971f9b9a5dSAndre Guedes void hci_inquiry_cache_flush(struct hci_dev *hdev) 9981da177e4SLinus Torvalds { 99930883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1000b57c1a56SJohan Hedberg struct inquiry_entry *p, *n; 10011da177e4SLinus Torvalds 1002561aafbcSJohan Hedberg list_for_each_entry_safe(p, n, &cache->all, all) { 1003561aafbcSJohan Hedberg list_del(&p->all); 1004b57c1a56SJohan Hedberg kfree(p); 10051da177e4SLinus Torvalds } 1006561aafbcSJohan Hedberg 1007561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->unknown); 1008561aafbcSJohan Hedberg INIT_LIST_HEAD(&cache->resolve); 10091da177e4SLinus Torvalds } 10101da177e4SLinus Torvalds 1011a8c5fb1aSGustavo Padovan struct inquiry_entry *hci_inquiry_cache_lookup(struct hci_dev *hdev, 1012a8c5fb1aSGustavo Padovan bdaddr_t *bdaddr) 10131da177e4SLinus Torvalds { 101430883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 10151da177e4SLinus Torvalds struct inquiry_entry *e; 10161da177e4SLinus Torvalds 10176ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 10181da177e4SLinus Torvalds 1019561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 10201da177e4SLinus Torvalds if (!bacmp(&e->data.bdaddr, bdaddr)) 10211da177e4SLinus Torvalds return e; 10221da177e4SLinus Torvalds } 10231da177e4SLinus Torvalds 1024b57c1a56SJohan Hedberg return NULL; 1025b57c1a56SJohan Hedberg } 1026b57c1a56SJohan Hedberg 1027561aafbcSJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_unknown(struct hci_dev *hdev, 1028561aafbcSJohan Hedberg bdaddr_t *bdaddr) 1029561aafbcSJohan Hedberg { 103030883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1031561aafbcSJohan Hedberg struct inquiry_entry *e; 1032561aafbcSJohan Hedberg 10336ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, bdaddr); 1034561aafbcSJohan Hedberg 1035561aafbcSJohan Hedberg list_for_each_entry(e, &cache->unknown, list) { 1036561aafbcSJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 1037561aafbcSJohan Hedberg return e; 1038561aafbcSJohan Hedberg } 1039561aafbcSJohan Hedberg 1040561aafbcSJohan Hedberg return NULL; 1041561aafbcSJohan Hedberg } 1042561aafbcSJohan Hedberg 104330dc78e1SJohan Hedberg struct inquiry_entry *hci_inquiry_cache_lookup_resolve(struct hci_dev *hdev, 104430dc78e1SJohan Hedberg bdaddr_t *bdaddr, 104530dc78e1SJohan Hedberg int state) 104630dc78e1SJohan Hedberg { 104730dc78e1SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 104830dc78e1SJohan Hedberg struct inquiry_entry *e; 104930dc78e1SJohan Hedberg 10506ed93dc6SAndrei Emeltchenko BT_DBG("cache %p bdaddr %pMR state %d", cache, bdaddr, state); 105130dc78e1SJohan Hedberg 105230dc78e1SJohan Hedberg list_for_each_entry(e, &cache->resolve, list) { 105330dc78e1SJohan Hedberg if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state) 105430dc78e1SJohan Hedberg return e; 105530dc78e1SJohan Hedberg if (!bacmp(&e->data.bdaddr, bdaddr)) 105630dc78e1SJohan Hedberg return e; 105730dc78e1SJohan Hedberg } 105830dc78e1SJohan Hedberg 105930dc78e1SJohan Hedberg return NULL; 106030dc78e1SJohan Hedberg } 106130dc78e1SJohan Hedberg 1062a3d4e20aSJohan Hedberg void hci_inquiry_cache_update_resolve(struct hci_dev *hdev, 1063a3d4e20aSJohan Hedberg struct inquiry_entry *ie) 1064a3d4e20aSJohan Hedberg { 1065a3d4e20aSJohan Hedberg struct discovery_state *cache = &hdev->discovery; 1066a3d4e20aSJohan Hedberg struct list_head *pos = &cache->resolve; 1067a3d4e20aSJohan Hedberg struct inquiry_entry *p; 1068a3d4e20aSJohan Hedberg 1069a3d4e20aSJohan Hedberg list_del(&ie->list); 1070a3d4e20aSJohan Hedberg 1071a3d4e20aSJohan Hedberg list_for_each_entry(p, &cache->resolve, list) { 1072a3d4e20aSJohan Hedberg if (p->name_state != NAME_PENDING && 1073a3d4e20aSJohan Hedberg abs(p->data.rssi) >= abs(ie->data.rssi)) 1074a3d4e20aSJohan Hedberg break; 1075a3d4e20aSJohan Hedberg pos = &p->list; 1076a3d4e20aSJohan Hedberg } 1077a3d4e20aSJohan Hedberg 1078a3d4e20aSJohan Hedberg list_add(&ie->list, pos); 1079a3d4e20aSJohan Hedberg } 1080a3d4e20aSJohan Hedberg 10813175405bSJohan Hedberg bool hci_inquiry_cache_update(struct hci_dev *hdev, struct inquiry_data *data, 1082388fc8faSJohan Hedberg bool name_known, bool *ssp) 10831da177e4SLinus Torvalds { 108430883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 108570f23020SAndrei Emeltchenko struct inquiry_entry *ie; 10861da177e4SLinus Torvalds 10876ed93dc6SAndrei Emeltchenko BT_DBG("cache %p, %pMR", cache, &data->bdaddr); 10881da177e4SLinus Torvalds 10892b2fec4dSSzymon Janc hci_remove_remote_oob_data(hdev, &data->bdaddr); 10902b2fec4dSSzymon Janc 1091388fc8faSJohan Hedberg if (ssp) 1092388fc8faSJohan Hedberg *ssp = data->ssp_mode; 1093388fc8faSJohan Hedberg 109470f23020SAndrei Emeltchenko ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr); 1095a3d4e20aSJohan Hedberg if (ie) { 1096388fc8faSJohan Hedberg if (ie->data.ssp_mode && ssp) 1097388fc8faSJohan Hedberg *ssp = true; 1098388fc8faSJohan Hedberg 1099a3d4e20aSJohan Hedberg if (ie->name_state == NAME_NEEDED && 1100a3d4e20aSJohan Hedberg data->rssi != ie->data.rssi) { 1101a3d4e20aSJohan Hedberg ie->data.rssi = data->rssi; 1102a3d4e20aSJohan Hedberg hci_inquiry_cache_update_resolve(hdev, ie); 1103a3d4e20aSJohan Hedberg } 1104a3d4e20aSJohan Hedberg 1105561aafbcSJohan Hedberg goto update; 1106a3d4e20aSJohan Hedberg } 1107561aafbcSJohan Hedberg 11081da177e4SLinus Torvalds /* Entry not in the cache. Add new one. */ 110970f23020SAndrei Emeltchenko ie = kzalloc(sizeof(struct inquiry_entry), GFP_ATOMIC); 111070f23020SAndrei Emeltchenko if (!ie) 11113175405bSJohan Hedberg return false; 111270f23020SAndrei Emeltchenko 1113561aafbcSJohan Hedberg list_add(&ie->all, &cache->all); 1114561aafbcSJohan Hedberg 1115561aafbcSJohan Hedberg if (name_known) { 1116561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1117561aafbcSJohan Hedberg } else { 1118561aafbcSJohan Hedberg ie->name_state = NAME_NOT_KNOWN; 1119561aafbcSJohan Hedberg list_add(&ie->list, &cache->unknown); 1120561aafbcSJohan Hedberg } 1121561aafbcSJohan Hedberg 1122561aafbcSJohan Hedberg update: 1123561aafbcSJohan Hedberg if (name_known && ie->name_state != NAME_KNOWN && 1124561aafbcSJohan Hedberg ie->name_state != NAME_PENDING) { 1125561aafbcSJohan Hedberg ie->name_state = NAME_KNOWN; 1126561aafbcSJohan Hedberg list_del(&ie->list); 11271da177e4SLinus Torvalds } 11281da177e4SLinus Torvalds 112970f23020SAndrei Emeltchenko memcpy(&ie->data, data, sizeof(*data)); 113070f23020SAndrei Emeltchenko ie->timestamp = jiffies; 11311da177e4SLinus Torvalds cache->timestamp = jiffies; 11323175405bSJohan Hedberg 11333175405bSJohan Hedberg if (ie->name_state == NAME_NOT_KNOWN) 11343175405bSJohan Hedberg return false; 11353175405bSJohan Hedberg 11363175405bSJohan Hedberg return true; 11371da177e4SLinus Torvalds } 11381da177e4SLinus Torvalds 11391da177e4SLinus Torvalds static int inquiry_cache_dump(struct hci_dev *hdev, int num, __u8 *buf) 11401da177e4SLinus Torvalds { 114130883512SJohan Hedberg struct discovery_state *cache = &hdev->discovery; 11421da177e4SLinus Torvalds struct inquiry_info *info = (struct inquiry_info *) buf; 11431da177e4SLinus Torvalds struct inquiry_entry *e; 11441da177e4SLinus Torvalds int copied = 0; 11451da177e4SLinus Torvalds 1146561aafbcSJohan Hedberg list_for_each_entry(e, &cache->all, all) { 11471da177e4SLinus Torvalds struct inquiry_data *data = &e->data; 1148b57c1a56SJohan Hedberg 1149b57c1a56SJohan Hedberg if (copied >= num) 1150b57c1a56SJohan Hedberg break; 1151b57c1a56SJohan Hedberg 11521da177e4SLinus Torvalds bacpy(&info->bdaddr, &data->bdaddr); 11531da177e4SLinus Torvalds info->pscan_rep_mode = data->pscan_rep_mode; 11541da177e4SLinus Torvalds info->pscan_period_mode = data->pscan_period_mode; 11551da177e4SLinus Torvalds info->pscan_mode = data->pscan_mode; 11561da177e4SLinus Torvalds memcpy(info->dev_class, data->dev_class, 3); 11571da177e4SLinus Torvalds info->clock_offset = data->clock_offset; 1158b57c1a56SJohan Hedberg 11591da177e4SLinus Torvalds info++; 1160b57c1a56SJohan Hedberg copied++; 11611da177e4SLinus Torvalds } 11621da177e4SLinus Torvalds 11631da177e4SLinus Torvalds BT_DBG("cache %p, copied %d", cache, copied); 11641da177e4SLinus Torvalds return copied; 11651da177e4SLinus Torvalds } 11661da177e4SLinus Torvalds 116742c6b129SJohan Hedberg static void hci_inq_req(struct hci_request *req, unsigned long opt) 11681da177e4SLinus Torvalds { 11691da177e4SLinus Torvalds struct hci_inquiry_req *ir = (struct hci_inquiry_req *) opt; 117042c6b129SJohan Hedberg struct hci_dev *hdev = req->hdev; 11711da177e4SLinus Torvalds struct hci_cp_inquiry cp; 11721da177e4SLinus Torvalds 11731da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 11741da177e4SLinus Torvalds 11751da177e4SLinus Torvalds if (test_bit(HCI_INQUIRY, &hdev->flags)) 11761da177e4SLinus Torvalds return; 11771da177e4SLinus Torvalds 11781da177e4SLinus Torvalds /* Start Inquiry */ 11791da177e4SLinus Torvalds memcpy(&cp.lap, &ir->lap, 3); 11801da177e4SLinus Torvalds cp.length = ir->length; 11811da177e4SLinus Torvalds cp.num_rsp = ir->num_rsp; 118242c6b129SJohan Hedberg hci_req_add(req, HCI_OP_INQUIRY, sizeof(cp), &cp); 11831da177e4SLinus Torvalds } 11841da177e4SLinus Torvalds 11853e13fa1eSAndre Guedes static int wait_inquiry(void *word) 11863e13fa1eSAndre Guedes { 11873e13fa1eSAndre Guedes schedule(); 11883e13fa1eSAndre Guedes return signal_pending(current); 11893e13fa1eSAndre Guedes } 11903e13fa1eSAndre Guedes 11911da177e4SLinus Torvalds int hci_inquiry(void __user *arg) 11921da177e4SLinus Torvalds { 11931da177e4SLinus Torvalds __u8 __user *ptr = arg; 11941da177e4SLinus Torvalds struct hci_inquiry_req ir; 11951da177e4SLinus Torvalds struct hci_dev *hdev; 11961da177e4SLinus Torvalds int err = 0, do_inquiry = 0, max_rsp; 11971da177e4SLinus Torvalds long timeo; 11981da177e4SLinus Torvalds __u8 *buf; 11991da177e4SLinus Torvalds 12001da177e4SLinus Torvalds if (copy_from_user(&ir, ptr, sizeof(ir))) 12011da177e4SLinus Torvalds return -EFAULT; 12021da177e4SLinus Torvalds 12035a08ecceSAndrei Emeltchenko hdev = hci_dev_get(ir.dev_id); 12045a08ecceSAndrei Emeltchenko if (!hdev) 12051da177e4SLinus Torvalds return -ENODEV; 12061da177e4SLinus Torvalds 12070736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 12080736cfa8SMarcel Holtmann err = -EBUSY; 12090736cfa8SMarcel Holtmann goto done; 12100736cfa8SMarcel Holtmann } 12110736cfa8SMarcel Holtmann 12125b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 12135b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 12145b69bef5SMarcel Holtmann goto done; 12155b69bef5SMarcel Holtmann } 12165b69bef5SMarcel Holtmann 121756f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 121856f87901SJohan Hedberg err = -EOPNOTSUPP; 121956f87901SJohan Hedberg goto done; 122056f87901SJohan Hedberg } 122156f87901SJohan Hedberg 122209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 12231da177e4SLinus Torvalds if (inquiry_cache_age(hdev) > INQUIRY_CACHE_AGE_MAX || 1224a8c5fb1aSGustavo Padovan inquiry_cache_empty(hdev) || ir.flags & IREQ_CACHE_FLUSH) { 12251f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 12261da177e4SLinus Torvalds do_inquiry = 1; 12271da177e4SLinus Torvalds } 122809fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 12291da177e4SLinus Torvalds 123004837f64SMarcel Holtmann timeo = ir.length * msecs_to_jiffies(2000); 123170f23020SAndrei Emeltchenko 123270f23020SAndrei Emeltchenko if (do_inquiry) { 123301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_inq_req, (unsigned long) &ir, 123401178cd4SJohan Hedberg timeo); 123570f23020SAndrei Emeltchenko if (err < 0) 12361da177e4SLinus Torvalds goto done; 12373e13fa1eSAndre Guedes 12383e13fa1eSAndre Guedes /* Wait until Inquiry procedure finishes (HCI_INQUIRY flag is 12393e13fa1eSAndre Guedes * cleared). If it is interrupted by a signal, return -EINTR. 12403e13fa1eSAndre Guedes */ 12413e13fa1eSAndre Guedes if (wait_on_bit(&hdev->flags, HCI_INQUIRY, wait_inquiry, 12423e13fa1eSAndre Guedes TASK_INTERRUPTIBLE)) 12433e13fa1eSAndre Guedes return -EINTR; 124470f23020SAndrei Emeltchenko } 12451da177e4SLinus Torvalds 12468fc9ced3SGustavo Padovan /* for unlimited number of responses we will use buffer with 12478fc9ced3SGustavo Padovan * 255 entries 12488fc9ced3SGustavo Padovan */ 12491da177e4SLinus Torvalds max_rsp = (ir.num_rsp == 0) ? 255 : ir.num_rsp; 12501da177e4SLinus Torvalds 12511da177e4SLinus Torvalds /* cache_dump can't sleep. Therefore we allocate temp buffer and then 12521da177e4SLinus Torvalds * copy it to the user space. 12531da177e4SLinus Torvalds */ 125470f23020SAndrei Emeltchenko buf = kmalloc(sizeof(struct inquiry_info) * max_rsp, GFP_KERNEL); 125570f23020SAndrei Emeltchenko if (!buf) { 12561da177e4SLinus Torvalds err = -ENOMEM; 12571da177e4SLinus Torvalds goto done; 12581da177e4SLinus Torvalds } 12591da177e4SLinus Torvalds 126009fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 12611da177e4SLinus Torvalds ir.num_rsp = inquiry_cache_dump(hdev, max_rsp, buf); 126209fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 12631da177e4SLinus Torvalds 12641da177e4SLinus Torvalds BT_DBG("num_rsp %d", ir.num_rsp); 12651da177e4SLinus Torvalds 12661da177e4SLinus Torvalds if (!copy_to_user(ptr, &ir, sizeof(ir))) { 12671da177e4SLinus Torvalds ptr += sizeof(ir); 12681da177e4SLinus Torvalds if (copy_to_user(ptr, buf, sizeof(struct inquiry_info) * 12691da177e4SLinus Torvalds ir.num_rsp)) 12701da177e4SLinus Torvalds err = -EFAULT; 12711da177e4SLinus Torvalds } else 12721da177e4SLinus Torvalds err = -EFAULT; 12731da177e4SLinus Torvalds 12741da177e4SLinus Torvalds kfree(buf); 12751da177e4SLinus Torvalds 12761da177e4SLinus Torvalds done: 12771da177e4SLinus Torvalds hci_dev_put(hdev); 12781da177e4SLinus Torvalds return err; 12791da177e4SLinus Torvalds } 12801da177e4SLinus Torvalds 1281cbed0ca1SJohan Hedberg static int hci_dev_do_open(struct hci_dev *hdev) 12821da177e4SLinus Torvalds { 12831da177e4SLinus Torvalds int ret = 0; 12841da177e4SLinus Torvalds 12851da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 12861da177e4SLinus Torvalds 12871da177e4SLinus Torvalds hci_req_lock(hdev); 12881da177e4SLinus Torvalds 128994324962SJohan Hovold if (test_bit(HCI_UNREGISTER, &hdev->dev_flags)) { 129094324962SJohan Hovold ret = -ENODEV; 129194324962SJohan Hovold goto done; 129294324962SJohan Hovold } 129394324962SJohan Hovold 1294a5c8f270SMarcel Holtmann if (!test_bit(HCI_SETUP, &hdev->dev_flags)) { 1295a5c8f270SMarcel Holtmann /* Check for rfkill but allow the HCI setup stage to 1296a5c8f270SMarcel Holtmann * proceed (which in itself doesn't cause any RF activity). 1297bf543036SJohan Hedberg */ 1298a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags)) { 1299611b30f7SMarcel Holtmann ret = -ERFKILL; 1300611b30f7SMarcel Holtmann goto done; 1301611b30f7SMarcel Holtmann } 1302611b30f7SMarcel Holtmann 1303a5c8f270SMarcel Holtmann /* Check for valid public address or a configured static 1304a5c8f270SMarcel Holtmann * random adddress, but let the HCI setup proceed to 1305a5c8f270SMarcel Holtmann * be able to determine if there is a public address 1306a5c8f270SMarcel Holtmann * or not. 1307a5c8f270SMarcel Holtmann * 1308a5c8f270SMarcel Holtmann * This check is only valid for BR/EDR controllers 1309a5c8f270SMarcel Holtmann * since AMP controllers do not have an address. 1310a5c8f270SMarcel Holtmann */ 1311a5c8f270SMarcel Holtmann if (hdev->dev_type == HCI_BREDR && 1312a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1313a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY)) { 1314a5c8f270SMarcel Holtmann ret = -EADDRNOTAVAIL; 1315a5c8f270SMarcel Holtmann goto done; 1316a5c8f270SMarcel Holtmann } 1317a5c8f270SMarcel Holtmann } 1318a5c8f270SMarcel Holtmann 13191da177e4SLinus Torvalds if (test_bit(HCI_UP, &hdev->flags)) { 13201da177e4SLinus Torvalds ret = -EALREADY; 13211da177e4SLinus Torvalds goto done; 13221da177e4SLinus Torvalds } 13231da177e4SLinus Torvalds 13241da177e4SLinus Torvalds if (hdev->open(hdev)) { 13251da177e4SLinus Torvalds ret = -EIO; 13261da177e4SLinus Torvalds goto done; 13271da177e4SLinus Torvalds } 13281da177e4SLinus Torvalds 13291da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 13301da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 1331f41c70c4SMarcel Holtmann 1332f41c70c4SMarcel Holtmann if (hdev->setup && test_bit(HCI_SETUP, &hdev->dev_flags)) 1333f41c70c4SMarcel Holtmann ret = hdev->setup(hdev); 1334f41c70c4SMarcel Holtmann 1335f41c70c4SMarcel Holtmann if (!ret) { 1336f41c70c4SMarcel Holtmann if (test_bit(HCI_QUIRK_RAW_DEVICE, &hdev->quirks)) 1337f41c70c4SMarcel Holtmann set_bit(HCI_RAW, &hdev->flags); 1338f41c70c4SMarcel Holtmann 13390736cfa8SMarcel Holtmann if (!test_bit(HCI_RAW, &hdev->flags) && 13400736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 13412177bab5SJohan Hedberg ret = __hci_init(hdev); 13421da177e4SLinus Torvalds } 13431da177e4SLinus Torvalds 1344f41c70c4SMarcel Holtmann clear_bit(HCI_INIT, &hdev->flags); 1345f41c70c4SMarcel Holtmann 13461da177e4SLinus Torvalds if (!ret) { 13471da177e4SLinus Torvalds hci_dev_hold(hdev); 13481da177e4SLinus Torvalds set_bit(HCI_UP, &hdev->flags); 13491da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UP); 1350bb4b2a9aSAndrei Emeltchenko if (!test_bit(HCI_SETUP, &hdev->dev_flags) && 13510736cfa8SMarcel Holtmann !test_bit(HCI_USER_CHANNEL, &hdev->dev_flags) && 13521514b892SMarcel Holtmann hdev->dev_type == HCI_BREDR) { 135309fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1354744cf19eSJohan Hedberg mgmt_powered(hdev, 1); 135509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 135656e5cb86SJohan Hedberg } 13571da177e4SLinus Torvalds } else { 13581da177e4SLinus Torvalds /* Init failed, cleanup */ 13593eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1360c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 1361b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 13621da177e4SLinus Torvalds 13631da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 13641da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 13651da177e4SLinus Torvalds 13661da177e4SLinus Torvalds if (hdev->flush) 13671da177e4SLinus Torvalds hdev->flush(hdev); 13681da177e4SLinus Torvalds 13691da177e4SLinus Torvalds if (hdev->sent_cmd) { 13701da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 13711da177e4SLinus Torvalds hdev->sent_cmd = NULL; 13721da177e4SLinus Torvalds } 13731da177e4SLinus Torvalds 13741da177e4SLinus Torvalds hdev->close(hdev); 13751da177e4SLinus Torvalds hdev->flags = 0; 13761da177e4SLinus Torvalds } 13771da177e4SLinus Torvalds 13781da177e4SLinus Torvalds done: 13791da177e4SLinus Torvalds hci_req_unlock(hdev); 13801da177e4SLinus Torvalds return ret; 13811da177e4SLinus Torvalds } 13821da177e4SLinus Torvalds 1383cbed0ca1SJohan Hedberg /* ---- HCI ioctl helpers ---- */ 1384cbed0ca1SJohan Hedberg 1385cbed0ca1SJohan Hedberg int hci_dev_open(__u16 dev) 1386cbed0ca1SJohan Hedberg { 1387cbed0ca1SJohan Hedberg struct hci_dev *hdev; 1388cbed0ca1SJohan Hedberg int err; 1389cbed0ca1SJohan Hedberg 1390cbed0ca1SJohan Hedberg hdev = hci_dev_get(dev); 1391cbed0ca1SJohan Hedberg if (!hdev) 1392cbed0ca1SJohan Hedberg return -ENODEV; 1393cbed0ca1SJohan Hedberg 1394e1d08f40SJohan Hedberg /* We need to ensure that no other power on/off work is pending 1395e1d08f40SJohan Hedberg * before proceeding to call hci_dev_do_open. This is 1396e1d08f40SJohan Hedberg * particularly important if the setup procedure has not yet 1397e1d08f40SJohan Hedberg * completed. 1398e1d08f40SJohan Hedberg */ 1399e1d08f40SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 1400e1d08f40SJohan Hedberg cancel_delayed_work(&hdev->power_off); 1401e1d08f40SJohan Hedberg 1402a5c8f270SMarcel Holtmann /* After this call it is guaranteed that the setup procedure 1403a5c8f270SMarcel Holtmann * has finished. This means that error conditions like RFKILL 1404a5c8f270SMarcel Holtmann * or no valid public or static random address apply. 1405a5c8f270SMarcel Holtmann */ 1406e1d08f40SJohan Hedberg flush_workqueue(hdev->req_workqueue); 1407e1d08f40SJohan Hedberg 1408cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 1409cbed0ca1SJohan Hedberg 1410cbed0ca1SJohan Hedberg hci_dev_put(hdev); 1411cbed0ca1SJohan Hedberg 1412cbed0ca1SJohan Hedberg return err; 1413cbed0ca1SJohan Hedberg } 1414cbed0ca1SJohan Hedberg 14151da177e4SLinus Torvalds static int hci_dev_do_close(struct hci_dev *hdev) 14161da177e4SLinus Torvalds { 14171da177e4SLinus Torvalds BT_DBG("%s %p", hdev->name, hdev); 14181da177e4SLinus Torvalds 141978c04c0bSVinicius Costa Gomes cancel_delayed_work(&hdev->power_off); 142078c04c0bSVinicius Costa Gomes 14211da177e4SLinus Torvalds hci_req_cancel(hdev, ENODEV); 14221da177e4SLinus Torvalds hci_req_lock(hdev); 14231da177e4SLinus Torvalds 14241da177e4SLinus Torvalds if (!test_and_clear_bit(HCI_UP, &hdev->flags)) { 1425b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 14261da177e4SLinus Torvalds hci_req_unlock(hdev); 14271da177e4SLinus Torvalds return 0; 14281da177e4SLinus Torvalds } 14291da177e4SLinus Torvalds 14303eff45eaSGustavo F. Padovan /* Flush RX and TX works */ 14313eff45eaSGustavo F. Padovan flush_work(&hdev->tx_work); 1432b78752ccSMarcel Holtmann flush_work(&hdev->rx_work); 14331da177e4SLinus Torvalds 143416ab91abSJohan Hedberg if (hdev->discov_timeout > 0) { 1435e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->discov_off); 143616ab91abSJohan Hedberg hdev->discov_timeout = 0; 14375e5282bbSJohan Hedberg clear_bit(HCI_DISCOVERABLE, &hdev->dev_flags); 1438310a3d48SMarcel Holtmann clear_bit(HCI_LIMITED_DISCOVERABLE, &hdev->dev_flags); 143916ab91abSJohan Hedberg } 144016ab91abSJohan Hedberg 1441a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SERVICE_CACHE, &hdev->dev_flags)) 14427d78525dSJohan Hedberg cancel_delayed_work(&hdev->service_cache); 14437d78525dSJohan Hedberg 14447ba8b4beSAndre Guedes cancel_delayed_work_sync(&hdev->le_scan_disable); 14457ba8b4beSAndre Guedes 144609fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 14471f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 14481da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 144909fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 14501da177e4SLinus Torvalds 14511da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_DOWN); 14521da177e4SLinus Torvalds 14531da177e4SLinus Torvalds if (hdev->flush) 14541da177e4SLinus Torvalds hdev->flush(hdev); 14551da177e4SLinus Torvalds 14561da177e4SLinus Torvalds /* Reset device */ 14571da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 14581da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 14598af59467SJohan Hedberg if (!test_bit(HCI_RAW, &hdev->flags) && 14603a6afbd2SMarcel Holtmann !test_bit(HCI_AUTO_OFF, &hdev->dev_flags) && 1461a6c511c6SSzymon Janc test_bit(HCI_QUIRK_RESET_ON_CLOSE, &hdev->quirks)) { 14621da177e4SLinus Torvalds set_bit(HCI_INIT, &hdev->flags); 146301178cd4SJohan Hedberg __hci_req_sync(hdev, hci_reset_req, 0, HCI_CMD_TIMEOUT); 14641da177e4SLinus Torvalds clear_bit(HCI_INIT, &hdev->flags); 14651da177e4SLinus Torvalds } 14661da177e4SLinus Torvalds 1467c347b765SGustavo F. Padovan /* flush cmd work */ 1468c347b765SGustavo F. Padovan flush_work(&hdev->cmd_work); 14691da177e4SLinus Torvalds 14701da177e4SLinus Torvalds /* Drop queues */ 14711da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 14721da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 14731da177e4SLinus Torvalds skb_queue_purge(&hdev->raw_q); 14741da177e4SLinus Torvalds 14751da177e4SLinus Torvalds /* Drop last sent command */ 14761da177e4SLinus Torvalds if (hdev->sent_cmd) { 1477b79f44c1SVinicius Costa Gomes del_timer_sync(&hdev->cmd_timer); 14781da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 14791da177e4SLinus Torvalds hdev->sent_cmd = NULL; 14801da177e4SLinus Torvalds } 14811da177e4SLinus Torvalds 1482b6ddb638SJohan Hedberg kfree_skb(hdev->recv_evt); 1483b6ddb638SJohan Hedberg hdev->recv_evt = NULL; 1484b6ddb638SJohan Hedberg 14851da177e4SLinus Torvalds /* After this point our queues are empty 14861da177e4SLinus Torvalds * and no tasks are scheduled. */ 14871da177e4SLinus Torvalds hdev->close(hdev); 14881da177e4SLinus Torvalds 148935b973c9SJohan Hedberg /* Clear flags */ 149035b973c9SJohan Hedberg hdev->flags = 0; 149135b973c9SJohan Hedberg hdev->dev_flags &= ~HCI_PERSISTENT_MASK; 149235b973c9SJohan Hedberg 149393c311a0SMarcel Holtmann if (!test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 149493c311a0SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 149509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 1496744cf19eSJohan Hedberg mgmt_powered(hdev, 0); 149709fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 14988ee56540SMarcel Holtmann } 149993c311a0SMarcel Holtmann } 15005add6af8SJohan Hedberg 1501ced5c338SAndrei Emeltchenko /* Controller radio is available but is currently powered down */ 1502536619e8SMarcel Holtmann hdev->amp_status = AMP_STATUS_POWERED_DOWN; 1503ced5c338SAndrei Emeltchenko 1504e59fda8dSJohan Hedberg memset(hdev->eir, 0, sizeof(hdev->eir)); 150509b3c3fbSJohan Hedberg memset(hdev->dev_class, 0, sizeof(hdev->dev_class)); 1506e59fda8dSJohan Hedberg 15071da177e4SLinus Torvalds hci_req_unlock(hdev); 15081da177e4SLinus Torvalds 15091da177e4SLinus Torvalds hci_dev_put(hdev); 15101da177e4SLinus Torvalds return 0; 15111da177e4SLinus Torvalds } 15121da177e4SLinus Torvalds 15131da177e4SLinus Torvalds int hci_dev_close(__u16 dev) 15141da177e4SLinus Torvalds { 15151da177e4SLinus Torvalds struct hci_dev *hdev; 15161da177e4SLinus Torvalds int err; 15171da177e4SLinus Torvalds 151870f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 151970f23020SAndrei Emeltchenko if (!hdev) 15201da177e4SLinus Torvalds return -ENODEV; 15218ee56540SMarcel Holtmann 15220736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 15230736cfa8SMarcel Holtmann err = -EBUSY; 15240736cfa8SMarcel Holtmann goto done; 15250736cfa8SMarcel Holtmann } 15260736cfa8SMarcel Holtmann 15278ee56540SMarcel Holtmann if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 15288ee56540SMarcel Holtmann cancel_delayed_work(&hdev->power_off); 15298ee56540SMarcel Holtmann 15301da177e4SLinus Torvalds err = hci_dev_do_close(hdev); 15318ee56540SMarcel Holtmann 15320736cfa8SMarcel Holtmann done: 15331da177e4SLinus Torvalds hci_dev_put(hdev); 15341da177e4SLinus Torvalds return err; 15351da177e4SLinus Torvalds } 15361da177e4SLinus Torvalds 15371da177e4SLinus Torvalds int hci_dev_reset(__u16 dev) 15381da177e4SLinus Torvalds { 15391da177e4SLinus Torvalds struct hci_dev *hdev; 15401da177e4SLinus Torvalds int ret = 0; 15411da177e4SLinus Torvalds 154270f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 154370f23020SAndrei Emeltchenko if (!hdev) 15441da177e4SLinus Torvalds return -ENODEV; 15451da177e4SLinus Torvalds 15461da177e4SLinus Torvalds hci_req_lock(hdev); 15471da177e4SLinus Torvalds 1548808a049eSMarcel Holtmann if (!test_bit(HCI_UP, &hdev->flags)) { 1549808a049eSMarcel Holtmann ret = -ENETDOWN; 15501da177e4SLinus Torvalds goto done; 1551808a049eSMarcel Holtmann } 15521da177e4SLinus Torvalds 15530736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 15540736cfa8SMarcel Holtmann ret = -EBUSY; 15550736cfa8SMarcel Holtmann goto done; 15560736cfa8SMarcel Holtmann } 15570736cfa8SMarcel Holtmann 15581da177e4SLinus Torvalds /* Drop queues */ 15591da177e4SLinus Torvalds skb_queue_purge(&hdev->rx_q); 15601da177e4SLinus Torvalds skb_queue_purge(&hdev->cmd_q); 15611da177e4SLinus Torvalds 156209fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 15631f9b9a5dSAndre Guedes hci_inquiry_cache_flush(hdev); 15641da177e4SLinus Torvalds hci_conn_hash_flush(hdev); 156509fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 15661da177e4SLinus Torvalds 15671da177e4SLinus Torvalds if (hdev->flush) 15681da177e4SLinus Torvalds hdev->flush(hdev); 15691da177e4SLinus Torvalds 15701da177e4SLinus Torvalds atomic_set(&hdev->cmd_cnt, 1); 15716ed58ec5SVille Tervo hdev->acl_cnt = 0; hdev->sco_cnt = 0; hdev->le_cnt = 0; 15721da177e4SLinus Torvalds 15731da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) 157401178cd4SJohan Hedberg ret = __hci_req_sync(hdev, hci_reset_req, 0, HCI_INIT_TIMEOUT); 15751da177e4SLinus Torvalds 15761da177e4SLinus Torvalds done: 15771da177e4SLinus Torvalds hci_req_unlock(hdev); 15781da177e4SLinus Torvalds hci_dev_put(hdev); 15791da177e4SLinus Torvalds return ret; 15801da177e4SLinus Torvalds } 15811da177e4SLinus Torvalds 15821da177e4SLinus Torvalds int hci_dev_reset_stat(__u16 dev) 15831da177e4SLinus Torvalds { 15841da177e4SLinus Torvalds struct hci_dev *hdev; 15851da177e4SLinus Torvalds int ret = 0; 15861da177e4SLinus Torvalds 158770f23020SAndrei Emeltchenko hdev = hci_dev_get(dev); 158870f23020SAndrei Emeltchenko if (!hdev) 15891da177e4SLinus Torvalds return -ENODEV; 15901da177e4SLinus Torvalds 15910736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 15920736cfa8SMarcel Holtmann ret = -EBUSY; 15930736cfa8SMarcel Holtmann goto done; 15940736cfa8SMarcel Holtmann } 15950736cfa8SMarcel Holtmann 15961da177e4SLinus Torvalds memset(&hdev->stat, 0, sizeof(struct hci_dev_stats)); 15971da177e4SLinus Torvalds 15980736cfa8SMarcel Holtmann done: 15991da177e4SLinus Torvalds hci_dev_put(hdev); 16001da177e4SLinus Torvalds return ret; 16011da177e4SLinus Torvalds } 16021da177e4SLinus Torvalds 16031da177e4SLinus Torvalds int hci_dev_cmd(unsigned int cmd, void __user *arg) 16041da177e4SLinus Torvalds { 16051da177e4SLinus Torvalds struct hci_dev *hdev; 16061da177e4SLinus Torvalds struct hci_dev_req dr; 16071da177e4SLinus Torvalds int err = 0; 16081da177e4SLinus Torvalds 16091da177e4SLinus Torvalds if (copy_from_user(&dr, arg, sizeof(dr))) 16101da177e4SLinus Torvalds return -EFAULT; 16111da177e4SLinus Torvalds 161270f23020SAndrei Emeltchenko hdev = hci_dev_get(dr.dev_id); 161370f23020SAndrei Emeltchenko if (!hdev) 16141da177e4SLinus Torvalds return -ENODEV; 16151da177e4SLinus Torvalds 16160736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 16170736cfa8SMarcel Holtmann err = -EBUSY; 16180736cfa8SMarcel Holtmann goto done; 16190736cfa8SMarcel Holtmann } 16200736cfa8SMarcel Holtmann 16215b69bef5SMarcel Holtmann if (hdev->dev_type != HCI_BREDR) { 16225b69bef5SMarcel Holtmann err = -EOPNOTSUPP; 16235b69bef5SMarcel Holtmann goto done; 16245b69bef5SMarcel Holtmann } 16255b69bef5SMarcel Holtmann 162656f87901SJohan Hedberg if (!test_bit(HCI_BREDR_ENABLED, &hdev->dev_flags)) { 162756f87901SJohan Hedberg err = -EOPNOTSUPP; 162856f87901SJohan Hedberg goto done; 162956f87901SJohan Hedberg } 163056f87901SJohan Hedberg 16311da177e4SLinus Torvalds switch (cmd) { 16321da177e4SLinus Torvalds case HCISETAUTH: 163301178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 16345f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 16351da177e4SLinus Torvalds break; 16361da177e4SLinus Torvalds 16371da177e4SLinus Torvalds case HCISETENCRYPT: 16381da177e4SLinus Torvalds if (!lmp_encrypt_capable(hdev)) { 16391da177e4SLinus Torvalds err = -EOPNOTSUPP; 16401da177e4SLinus Torvalds break; 16411da177e4SLinus Torvalds } 16421da177e4SLinus Torvalds 16431da177e4SLinus Torvalds if (!test_bit(HCI_AUTH, &hdev->flags)) { 16441da177e4SLinus Torvalds /* Auth must be enabled first */ 164501178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_auth_req, dr.dev_opt, 16465f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 16471da177e4SLinus Torvalds if (err) 16481da177e4SLinus Torvalds break; 16491da177e4SLinus Torvalds } 16501da177e4SLinus Torvalds 165101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_encrypt_req, dr.dev_opt, 16525f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 16531da177e4SLinus Torvalds break; 16541da177e4SLinus Torvalds 16551da177e4SLinus Torvalds case HCISETSCAN: 165601178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_scan_req, dr.dev_opt, 16575f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 16581da177e4SLinus Torvalds break; 16591da177e4SLinus Torvalds 16601da177e4SLinus Torvalds case HCISETLINKPOL: 166101178cd4SJohan Hedberg err = hci_req_sync(hdev, hci_linkpol_req, dr.dev_opt, 16625f246e89SAndrei Emeltchenko HCI_INIT_TIMEOUT); 16631da177e4SLinus Torvalds break; 16641da177e4SLinus Torvalds 16651da177e4SLinus Torvalds case HCISETLINKMODE: 1666e4e8e37cSMarcel Holtmann hdev->link_mode = ((__u16) dr.dev_opt) & 1667e4e8e37cSMarcel Holtmann (HCI_LM_MASTER | HCI_LM_ACCEPT); 1668e4e8e37cSMarcel Holtmann break; 1669e4e8e37cSMarcel Holtmann 1670e4e8e37cSMarcel Holtmann case HCISETPTYPE: 1671e4e8e37cSMarcel Holtmann hdev->pkt_type = (__u16) dr.dev_opt; 16721da177e4SLinus Torvalds break; 16731da177e4SLinus Torvalds 16741da177e4SLinus Torvalds case HCISETACLMTU: 16751da177e4SLinus Torvalds hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1); 16761da177e4SLinus Torvalds hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0); 16771da177e4SLinus Torvalds break; 16781da177e4SLinus Torvalds 16791da177e4SLinus Torvalds case HCISETSCOMTU: 16801da177e4SLinus Torvalds hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1); 16811da177e4SLinus Torvalds hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0); 16821da177e4SLinus Torvalds break; 16831da177e4SLinus Torvalds 16841da177e4SLinus Torvalds default: 16851da177e4SLinus Torvalds err = -EINVAL; 16861da177e4SLinus Torvalds break; 16871da177e4SLinus Torvalds } 1688e4e8e37cSMarcel Holtmann 16890736cfa8SMarcel Holtmann done: 16901da177e4SLinus Torvalds hci_dev_put(hdev); 16911da177e4SLinus Torvalds return err; 16921da177e4SLinus Torvalds } 16931da177e4SLinus Torvalds 16941da177e4SLinus Torvalds int hci_get_dev_list(void __user *arg) 16951da177e4SLinus Torvalds { 16968035ded4SLuiz Augusto von Dentz struct hci_dev *hdev; 16971da177e4SLinus Torvalds struct hci_dev_list_req *dl; 16981da177e4SLinus Torvalds struct hci_dev_req *dr; 16991da177e4SLinus Torvalds int n = 0, size, err; 17001da177e4SLinus Torvalds __u16 dev_num; 17011da177e4SLinus Torvalds 17021da177e4SLinus Torvalds if (get_user(dev_num, (__u16 __user *) arg)) 17031da177e4SLinus Torvalds return -EFAULT; 17041da177e4SLinus Torvalds 17051da177e4SLinus Torvalds if (!dev_num || dev_num > (PAGE_SIZE * 2) / sizeof(*dr)) 17061da177e4SLinus Torvalds return -EINVAL; 17071da177e4SLinus Torvalds 17081da177e4SLinus Torvalds size = sizeof(*dl) + dev_num * sizeof(*dr); 17091da177e4SLinus Torvalds 171070f23020SAndrei Emeltchenko dl = kzalloc(size, GFP_KERNEL); 171170f23020SAndrei Emeltchenko if (!dl) 17121da177e4SLinus Torvalds return -ENOMEM; 17131da177e4SLinus Torvalds 17141da177e4SLinus Torvalds dr = dl->dev_req; 17151da177e4SLinus Torvalds 1716f20d09d5SGustavo F. Padovan read_lock(&hci_dev_list_lock); 17178035ded4SLuiz Augusto von Dentz list_for_each_entry(hdev, &hci_dev_list, list) { 1718a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 1719e0f9309fSJohan Hedberg cancel_delayed_work(&hdev->power_off); 1720c542a06cSJohan Hedberg 1721a8b2d5c2SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 1722a8b2d5c2SJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->dev_flags); 1723c542a06cSJohan Hedberg 17241da177e4SLinus Torvalds (dr + n)->dev_id = hdev->id; 17251da177e4SLinus Torvalds (dr + n)->dev_opt = hdev->flags; 1726c542a06cSJohan Hedberg 17271da177e4SLinus Torvalds if (++n >= dev_num) 17281da177e4SLinus Torvalds break; 17291da177e4SLinus Torvalds } 1730f20d09d5SGustavo F. Padovan read_unlock(&hci_dev_list_lock); 17311da177e4SLinus Torvalds 17321da177e4SLinus Torvalds dl->dev_num = n; 17331da177e4SLinus Torvalds size = sizeof(*dl) + n * sizeof(*dr); 17341da177e4SLinus Torvalds 17351da177e4SLinus Torvalds err = copy_to_user(arg, dl, size); 17361da177e4SLinus Torvalds kfree(dl); 17371da177e4SLinus Torvalds 17381da177e4SLinus Torvalds return err ? -EFAULT : 0; 17391da177e4SLinus Torvalds } 17401da177e4SLinus Torvalds 17411da177e4SLinus Torvalds int hci_get_dev_info(void __user *arg) 17421da177e4SLinus Torvalds { 17431da177e4SLinus Torvalds struct hci_dev *hdev; 17441da177e4SLinus Torvalds struct hci_dev_info di; 17451da177e4SLinus Torvalds int err = 0; 17461da177e4SLinus Torvalds 17471da177e4SLinus Torvalds if (copy_from_user(&di, arg, sizeof(di))) 17481da177e4SLinus Torvalds return -EFAULT; 17491da177e4SLinus Torvalds 175070f23020SAndrei Emeltchenko hdev = hci_dev_get(di.dev_id); 175170f23020SAndrei Emeltchenko if (!hdev) 17521da177e4SLinus Torvalds return -ENODEV; 17531da177e4SLinus Torvalds 1754a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_AUTO_OFF, &hdev->dev_flags)) 17553243553fSJohan Hedberg cancel_delayed_work_sync(&hdev->power_off); 1756ab81cbf9SJohan Hedberg 1757a8b2d5c2SJohan Hedberg if (!test_bit(HCI_MGMT, &hdev->dev_flags)) 1758a8b2d5c2SJohan Hedberg set_bit(HCI_PAIRABLE, &hdev->dev_flags); 1759c542a06cSJohan Hedberg 17601da177e4SLinus Torvalds strcpy(di.name, hdev->name); 17611da177e4SLinus Torvalds di.bdaddr = hdev->bdaddr; 176260f2a3edSMarcel Holtmann di.type = (hdev->bus & 0x0f) | ((hdev->dev_type & 0x03) << 4); 17631da177e4SLinus Torvalds di.flags = hdev->flags; 17641da177e4SLinus Torvalds di.pkt_type = hdev->pkt_type; 1765572c7f84SJohan Hedberg if (lmp_bredr_capable(hdev)) { 17661da177e4SLinus Torvalds di.acl_mtu = hdev->acl_mtu; 17671da177e4SLinus Torvalds di.acl_pkts = hdev->acl_pkts; 17681da177e4SLinus Torvalds di.sco_mtu = hdev->sco_mtu; 17691da177e4SLinus Torvalds di.sco_pkts = hdev->sco_pkts; 1770572c7f84SJohan Hedberg } else { 1771572c7f84SJohan Hedberg di.acl_mtu = hdev->le_mtu; 1772572c7f84SJohan Hedberg di.acl_pkts = hdev->le_pkts; 1773572c7f84SJohan Hedberg di.sco_mtu = 0; 1774572c7f84SJohan Hedberg di.sco_pkts = 0; 1775572c7f84SJohan Hedberg } 17761da177e4SLinus Torvalds di.link_policy = hdev->link_policy; 17771da177e4SLinus Torvalds di.link_mode = hdev->link_mode; 17781da177e4SLinus Torvalds 17791da177e4SLinus Torvalds memcpy(&di.stat, &hdev->stat, sizeof(di.stat)); 17801da177e4SLinus Torvalds memcpy(&di.features, &hdev->features, sizeof(di.features)); 17811da177e4SLinus Torvalds 17821da177e4SLinus Torvalds if (copy_to_user(arg, &di, sizeof(di))) 17831da177e4SLinus Torvalds err = -EFAULT; 17841da177e4SLinus Torvalds 17851da177e4SLinus Torvalds hci_dev_put(hdev); 17861da177e4SLinus Torvalds 17871da177e4SLinus Torvalds return err; 17881da177e4SLinus Torvalds } 17891da177e4SLinus Torvalds 17901da177e4SLinus Torvalds /* ---- Interface to HCI drivers ---- */ 17911da177e4SLinus Torvalds 1792611b30f7SMarcel Holtmann static int hci_rfkill_set_block(void *data, bool blocked) 1793611b30f7SMarcel Holtmann { 1794611b30f7SMarcel Holtmann struct hci_dev *hdev = data; 1795611b30f7SMarcel Holtmann 1796611b30f7SMarcel Holtmann BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked); 1797611b30f7SMarcel Holtmann 17980736cfa8SMarcel Holtmann if (test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) 17990736cfa8SMarcel Holtmann return -EBUSY; 18000736cfa8SMarcel Holtmann 18015e130367SJohan Hedberg if (blocked) { 18025e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 1803bf543036SJohan Hedberg if (!test_bit(HCI_SETUP, &hdev->dev_flags)) 1804611b30f7SMarcel Holtmann hci_dev_do_close(hdev); 18055e130367SJohan Hedberg } else { 18065e130367SJohan Hedberg clear_bit(HCI_RFKILLED, &hdev->dev_flags); 18075e130367SJohan Hedberg } 1808611b30f7SMarcel Holtmann 1809611b30f7SMarcel Holtmann return 0; 1810611b30f7SMarcel Holtmann } 1811611b30f7SMarcel Holtmann 1812611b30f7SMarcel Holtmann static const struct rfkill_ops hci_rfkill_ops = { 1813611b30f7SMarcel Holtmann .set_block = hci_rfkill_set_block, 1814611b30f7SMarcel Holtmann }; 1815611b30f7SMarcel Holtmann 1816ab81cbf9SJohan Hedberg static void hci_power_on(struct work_struct *work) 1817ab81cbf9SJohan Hedberg { 1818ab81cbf9SJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, power_on); 181996570ffcSJohan Hedberg int err; 1820ab81cbf9SJohan Hedberg 1821ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 1822ab81cbf9SJohan Hedberg 1823cbed0ca1SJohan Hedberg err = hci_dev_do_open(hdev); 182496570ffcSJohan Hedberg if (err < 0) { 182596570ffcSJohan Hedberg mgmt_set_powered_failed(hdev, err); 1826ab81cbf9SJohan Hedberg return; 182796570ffcSJohan Hedberg } 1828ab81cbf9SJohan Hedberg 1829a5c8f270SMarcel Holtmann /* During the HCI setup phase, a few error conditions are 1830a5c8f270SMarcel Holtmann * ignored and they need to be checked now. If they are still 1831a5c8f270SMarcel Holtmann * valid, it is important to turn the device back off. 1832a5c8f270SMarcel Holtmann */ 1833a5c8f270SMarcel Holtmann if (test_bit(HCI_RFKILLED, &hdev->dev_flags) || 1834a5c8f270SMarcel Holtmann (hdev->dev_type == HCI_BREDR && 1835a5c8f270SMarcel Holtmann !bacmp(&hdev->bdaddr, BDADDR_ANY) && 1836a5c8f270SMarcel Holtmann !bacmp(&hdev->static_addr, BDADDR_ANY))) { 1837bf543036SJohan Hedberg clear_bit(HCI_AUTO_OFF, &hdev->dev_flags); 1838bf543036SJohan Hedberg hci_dev_do_close(hdev); 1839bf543036SJohan Hedberg } else if (test_bit(HCI_AUTO_OFF, &hdev->dev_flags)) { 184019202573SJohan Hedberg queue_delayed_work(hdev->req_workqueue, &hdev->power_off, 184119202573SJohan Hedberg HCI_AUTO_OFF_TIMEOUT); 1842bf543036SJohan Hedberg } 1843ab81cbf9SJohan Hedberg 1844a8b2d5c2SJohan Hedberg if (test_and_clear_bit(HCI_SETUP, &hdev->dev_flags)) 1845744cf19eSJohan Hedberg mgmt_index_added(hdev); 1846ab81cbf9SJohan Hedberg } 1847ab81cbf9SJohan Hedberg 1848ab81cbf9SJohan Hedberg static void hci_power_off(struct work_struct *work) 1849ab81cbf9SJohan Hedberg { 18503243553fSJohan Hedberg struct hci_dev *hdev = container_of(work, struct hci_dev, 18513243553fSJohan Hedberg power_off.work); 1852ab81cbf9SJohan Hedberg 1853ab81cbf9SJohan Hedberg BT_DBG("%s", hdev->name); 1854ab81cbf9SJohan Hedberg 18558ee56540SMarcel Holtmann hci_dev_do_close(hdev); 1856ab81cbf9SJohan Hedberg } 1857ab81cbf9SJohan Hedberg 185816ab91abSJohan Hedberg static void hci_discov_off(struct work_struct *work) 185916ab91abSJohan Hedberg { 186016ab91abSJohan Hedberg struct hci_dev *hdev; 186116ab91abSJohan Hedberg 186216ab91abSJohan Hedberg hdev = container_of(work, struct hci_dev, discov_off.work); 186316ab91abSJohan Hedberg 186416ab91abSJohan Hedberg BT_DBG("%s", hdev->name); 186516ab91abSJohan Hedberg 1866d1967ff8SMarcel Holtmann mgmt_discoverable_timeout(hdev); 186716ab91abSJohan Hedberg } 186816ab91abSJohan Hedberg 18692aeb9a1aSJohan Hedberg int hci_uuids_clear(struct hci_dev *hdev) 18702aeb9a1aSJohan Hedberg { 18714821002cSJohan Hedberg struct bt_uuid *uuid, *tmp; 18722aeb9a1aSJohan Hedberg 18734821002cSJohan Hedberg list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) { 18744821002cSJohan Hedberg list_del(&uuid->list); 18752aeb9a1aSJohan Hedberg kfree(uuid); 18762aeb9a1aSJohan Hedberg } 18772aeb9a1aSJohan Hedberg 18782aeb9a1aSJohan Hedberg return 0; 18792aeb9a1aSJohan Hedberg } 18802aeb9a1aSJohan Hedberg 188155ed8ca1SJohan Hedberg int hci_link_keys_clear(struct hci_dev *hdev) 188255ed8ca1SJohan Hedberg { 188355ed8ca1SJohan Hedberg struct list_head *p, *n; 188455ed8ca1SJohan Hedberg 188555ed8ca1SJohan Hedberg list_for_each_safe(p, n, &hdev->link_keys) { 188655ed8ca1SJohan Hedberg struct link_key *key; 188755ed8ca1SJohan Hedberg 188855ed8ca1SJohan Hedberg key = list_entry(p, struct link_key, list); 188955ed8ca1SJohan Hedberg 189055ed8ca1SJohan Hedberg list_del(p); 189155ed8ca1SJohan Hedberg kfree(key); 189255ed8ca1SJohan Hedberg } 189355ed8ca1SJohan Hedberg 189455ed8ca1SJohan Hedberg return 0; 189555ed8ca1SJohan Hedberg } 189655ed8ca1SJohan Hedberg 1897b899efafSVinicius Costa Gomes int hci_smp_ltks_clear(struct hci_dev *hdev) 1898b899efafSVinicius Costa Gomes { 1899b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 1900b899efafSVinicius Costa Gomes 1901b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 1902b899efafSVinicius Costa Gomes list_del(&k->list); 1903b899efafSVinicius Costa Gomes kfree(k); 1904b899efafSVinicius Costa Gomes } 1905b899efafSVinicius Costa Gomes 1906b899efafSVinicius Costa Gomes return 0; 1907b899efafSVinicius Costa Gomes } 1908b899efafSVinicius Costa Gomes 190955ed8ca1SJohan Hedberg struct link_key *hci_find_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 191055ed8ca1SJohan Hedberg { 191155ed8ca1SJohan Hedberg struct link_key *k; 191255ed8ca1SJohan Hedberg 19138035ded4SLuiz Augusto von Dentz list_for_each_entry(k, &hdev->link_keys, list) 191455ed8ca1SJohan Hedberg if (bacmp(bdaddr, &k->bdaddr) == 0) 191555ed8ca1SJohan Hedberg return k; 191655ed8ca1SJohan Hedberg 191755ed8ca1SJohan Hedberg return NULL; 191855ed8ca1SJohan Hedberg } 191955ed8ca1SJohan Hedberg 1920745c0ce3SVishal Agarwal static bool hci_persistent_key(struct hci_dev *hdev, struct hci_conn *conn, 1921d25e28abSJohan Hedberg u8 key_type, u8 old_key_type) 1922d25e28abSJohan Hedberg { 1923d25e28abSJohan Hedberg /* Legacy key */ 1924d25e28abSJohan Hedberg if (key_type < 0x03) 1925745c0ce3SVishal Agarwal return true; 1926d25e28abSJohan Hedberg 1927d25e28abSJohan Hedberg /* Debug keys are insecure so don't store them persistently */ 1928d25e28abSJohan Hedberg if (key_type == HCI_LK_DEBUG_COMBINATION) 1929745c0ce3SVishal Agarwal return false; 1930d25e28abSJohan Hedberg 1931d25e28abSJohan Hedberg /* Changed combination key and there's no previous one */ 1932d25e28abSJohan Hedberg if (key_type == HCI_LK_CHANGED_COMBINATION && old_key_type == 0xff) 1933745c0ce3SVishal Agarwal return false; 1934d25e28abSJohan Hedberg 1935d25e28abSJohan Hedberg /* Security mode 3 case */ 1936d25e28abSJohan Hedberg if (!conn) 1937745c0ce3SVishal Agarwal return true; 1938d25e28abSJohan Hedberg 1939d25e28abSJohan Hedberg /* Neither local nor remote side had no-bonding as requirement */ 1940d25e28abSJohan Hedberg if (conn->auth_type > 0x01 && conn->remote_auth > 0x01) 1941745c0ce3SVishal Agarwal return true; 1942d25e28abSJohan Hedberg 1943d25e28abSJohan Hedberg /* Local side had dedicated bonding as requirement */ 1944d25e28abSJohan Hedberg if (conn->auth_type == 0x02 || conn->auth_type == 0x03) 1945745c0ce3SVishal Agarwal return true; 1946d25e28abSJohan Hedberg 1947d25e28abSJohan Hedberg /* Remote side had dedicated bonding as requirement */ 1948d25e28abSJohan Hedberg if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03) 1949745c0ce3SVishal Agarwal return true; 1950d25e28abSJohan Hedberg 1951d25e28abSJohan Hedberg /* If none of the above criteria match, then don't store the key 1952d25e28abSJohan Hedberg * persistently */ 1953745c0ce3SVishal Agarwal return false; 1954d25e28abSJohan Hedberg } 1955d25e28abSJohan Hedberg 1956c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk(struct hci_dev *hdev, __le16 ediv, u8 rand[8]) 195775d262c2SVinicius Costa Gomes { 1958c9839a11SVinicius Costa Gomes struct smp_ltk *k; 195975d262c2SVinicius Costa Gomes 1960c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) { 1961c9839a11SVinicius Costa Gomes if (k->ediv != ediv || 1962c9839a11SVinicius Costa Gomes memcmp(rand, k->rand, sizeof(k->rand))) 196375d262c2SVinicius Costa Gomes continue; 196475d262c2SVinicius Costa Gomes 196575d262c2SVinicius Costa Gomes return k; 196675d262c2SVinicius Costa Gomes } 196775d262c2SVinicius Costa Gomes 196875d262c2SVinicius Costa Gomes return NULL; 196975d262c2SVinicius Costa Gomes } 197075d262c2SVinicius Costa Gomes 1971c9839a11SVinicius Costa Gomes struct smp_ltk *hci_find_ltk_by_addr(struct hci_dev *hdev, bdaddr_t *bdaddr, 1972c9839a11SVinicius Costa Gomes u8 addr_type) 197375d262c2SVinicius Costa Gomes { 1974c9839a11SVinicius Costa Gomes struct smp_ltk *k; 197575d262c2SVinicius Costa Gomes 1976c9839a11SVinicius Costa Gomes list_for_each_entry(k, &hdev->long_term_keys, list) 1977c9839a11SVinicius Costa Gomes if (addr_type == k->bdaddr_type && 1978c9839a11SVinicius Costa Gomes bacmp(bdaddr, &k->bdaddr) == 0) 197975d262c2SVinicius Costa Gomes return k; 198075d262c2SVinicius Costa Gomes 198175d262c2SVinicius Costa Gomes return NULL; 198275d262c2SVinicius Costa Gomes } 198375d262c2SVinicius Costa Gomes 1984d25e28abSJohan Hedberg int hci_add_link_key(struct hci_dev *hdev, struct hci_conn *conn, int new_key, 1985d25e28abSJohan Hedberg bdaddr_t *bdaddr, u8 *val, u8 type, u8 pin_len) 198655ed8ca1SJohan Hedberg { 198755ed8ca1SJohan Hedberg struct link_key *key, *old_key; 1988745c0ce3SVishal Agarwal u8 old_key_type; 1989745c0ce3SVishal Agarwal bool persistent; 199055ed8ca1SJohan Hedberg 199155ed8ca1SJohan Hedberg old_key = hci_find_link_key(hdev, bdaddr); 199255ed8ca1SJohan Hedberg if (old_key) { 199355ed8ca1SJohan Hedberg old_key_type = old_key->type; 199455ed8ca1SJohan Hedberg key = old_key; 199555ed8ca1SJohan Hedberg } else { 199612adcf3aSJohan Hedberg old_key_type = conn ? conn->key_type : 0xff; 199755ed8ca1SJohan Hedberg key = kzalloc(sizeof(*key), GFP_ATOMIC); 199855ed8ca1SJohan Hedberg if (!key) 199955ed8ca1SJohan Hedberg return -ENOMEM; 200055ed8ca1SJohan Hedberg list_add(&key->list, &hdev->link_keys); 200155ed8ca1SJohan Hedberg } 200255ed8ca1SJohan Hedberg 20036ed93dc6SAndrei Emeltchenko BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type); 200455ed8ca1SJohan Hedberg 2005d25e28abSJohan Hedberg /* Some buggy controller combinations generate a changed 2006d25e28abSJohan Hedberg * combination key for legacy pairing even when there's no 2007d25e28abSJohan Hedberg * previous key */ 2008d25e28abSJohan Hedberg if (type == HCI_LK_CHANGED_COMBINATION && 2009a8c5fb1aSGustavo Padovan (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) { 2010d25e28abSJohan Hedberg type = HCI_LK_COMBINATION; 2011655fe6ecSJohan Hedberg if (conn) 2012655fe6ecSJohan Hedberg conn->key_type = type; 2013655fe6ecSJohan Hedberg } 2014d25e28abSJohan Hedberg 201555ed8ca1SJohan Hedberg bacpy(&key->bdaddr, bdaddr); 20169b3b4460SAndrei Emeltchenko memcpy(key->val, val, HCI_LINK_KEY_SIZE); 201755ed8ca1SJohan Hedberg key->pin_len = pin_len; 201855ed8ca1SJohan Hedberg 2019b6020ba0SWaldemar Rymarkiewicz if (type == HCI_LK_CHANGED_COMBINATION) 202055ed8ca1SJohan Hedberg key->type = old_key_type; 20214748fed2SJohan Hedberg else 20224748fed2SJohan Hedberg key->type = type; 20234748fed2SJohan Hedberg 20244df378a1SJohan Hedberg if (!new_key) 20254df378a1SJohan Hedberg return 0; 20264df378a1SJohan Hedberg 20274df378a1SJohan Hedberg persistent = hci_persistent_key(hdev, conn, type, old_key_type); 20284df378a1SJohan Hedberg 2029744cf19eSJohan Hedberg mgmt_new_link_key(hdev, key, persistent); 20304df378a1SJohan Hedberg 20316ec5bcadSVishal Agarwal if (conn) 20326ec5bcadSVishal Agarwal conn->flush_key = !persistent; 203355ed8ca1SJohan Hedberg 203455ed8ca1SJohan Hedberg return 0; 203555ed8ca1SJohan Hedberg } 203655ed8ca1SJohan Hedberg 2037c9839a11SVinicius Costa Gomes int hci_add_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 addr_type, u8 type, 20389a006657SAndrei Emeltchenko int new_key, u8 authenticated, u8 tk[16], u8 enc_size, __le16 203904124681SGustavo F. Padovan ediv, u8 rand[8]) 204075d262c2SVinicius Costa Gomes { 2041c9839a11SVinicius Costa Gomes struct smp_ltk *key, *old_key; 204275d262c2SVinicius Costa Gomes 2043c9839a11SVinicius Costa Gomes if (!(type & HCI_SMP_STK) && !(type & HCI_SMP_LTK)) 2044c9839a11SVinicius Costa Gomes return 0; 204575d262c2SVinicius Costa Gomes 2046c9839a11SVinicius Costa Gomes old_key = hci_find_ltk_by_addr(hdev, bdaddr, addr_type); 2047c9839a11SVinicius Costa Gomes if (old_key) 204875d262c2SVinicius Costa Gomes key = old_key; 2049c9839a11SVinicius Costa Gomes else { 2050c9839a11SVinicius Costa Gomes key = kzalloc(sizeof(*key), GFP_ATOMIC); 205175d262c2SVinicius Costa Gomes if (!key) 205275d262c2SVinicius Costa Gomes return -ENOMEM; 2053c9839a11SVinicius Costa Gomes list_add(&key->list, &hdev->long_term_keys); 205475d262c2SVinicius Costa Gomes } 205575d262c2SVinicius Costa Gomes 205675d262c2SVinicius Costa Gomes bacpy(&key->bdaddr, bdaddr); 2057c9839a11SVinicius Costa Gomes key->bdaddr_type = addr_type; 2058c9839a11SVinicius Costa Gomes memcpy(key->val, tk, sizeof(key->val)); 2059c9839a11SVinicius Costa Gomes key->authenticated = authenticated; 2060c9839a11SVinicius Costa Gomes key->ediv = ediv; 2061c9839a11SVinicius Costa Gomes key->enc_size = enc_size; 2062c9839a11SVinicius Costa Gomes key->type = type; 2063c9839a11SVinicius Costa Gomes memcpy(key->rand, rand, sizeof(key->rand)); 206475d262c2SVinicius Costa Gomes 2065c9839a11SVinicius Costa Gomes if (!new_key) 2066c9839a11SVinicius Costa Gomes return 0; 206775d262c2SVinicius Costa Gomes 2068261cc5aaSVinicius Costa Gomes if (type & HCI_SMP_LTK) 2069261cc5aaSVinicius Costa Gomes mgmt_new_ltk(hdev, key, 1); 2070261cc5aaSVinicius Costa Gomes 207175d262c2SVinicius Costa Gomes return 0; 207275d262c2SVinicius Costa Gomes } 207375d262c2SVinicius Costa Gomes 207455ed8ca1SJohan Hedberg int hci_remove_link_key(struct hci_dev *hdev, bdaddr_t *bdaddr) 207555ed8ca1SJohan Hedberg { 207655ed8ca1SJohan Hedberg struct link_key *key; 207755ed8ca1SJohan Hedberg 207855ed8ca1SJohan Hedberg key = hci_find_link_key(hdev, bdaddr); 207955ed8ca1SJohan Hedberg if (!key) 208055ed8ca1SJohan Hedberg return -ENOENT; 208155ed8ca1SJohan Hedberg 20826ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 208355ed8ca1SJohan Hedberg 208455ed8ca1SJohan Hedberg list_del(&key->list); 208555ed8ca1SJohan Hedberg kfree(key); 208655ed8ca1SJohan Hedberg 208755ed8ca1SJohan Hedberg return 0; 208855ed8ca1SJohan Hedberg } 208955ed8ca1SJohan Hedberg 2090b899efafSVinicius Costa Gomes int hci_remove_ltk(struct hci_dev *hdev, bdaddr_t *bdaddr) 2091b899efafSVinicius Costa Gomes { 2092b899efafSVinicius Costa Gomes struct smp_ltk *k, *tmp; 2093b899efafSVinicius Costa Gomes 2094b899efafSVinicius Costa Gomes list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) { 2095b899efafSVinicius Costa Gomes if (bacmp(bdaddr, &k->bdaddr)) 2096b899efafSVinicius Costa Gomes continue; 2097b899efafSVinicius Costa Gomes 20986ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 2099b899efafSVinicius Costa Gomes 2100b899efafSVinicius Costa Gomes list_del(&k->list); 2101b899efafSVinicius Costa Gomes kfree(k); 2102b899efafSVinicius Costa Gomes } 2103b899efafSVinicius Costa Gomes 2104b899efafSVinicius Costa Gomes return 0; 2105b899efafSVinicius Costa Gomes } 2106b899efafSVinicius Costa Gomes 21076bd32326SVille Tervo /* HCI command timer function */ 2108bda4f23aSAndrei Emeltchenko static void hci_cmd_timeout(unsigned long arg) 21096bd32326SVille Tervo { 21106bd32326SVille Tervo struct hci_dev *hdev = (void *) arg; 21116bd32326SVille Tervo 2112bda4f23aSAndrei Emeltchenko if (hdev->sent_cmd) { 2113bda4f23aSAndrei Emeltchenko struct hci_command_hdr *sent = (void *) hdev->sent_cmd->data; 2114bda4f23aSAndrei Emeltchenko u16 opcode = __le16_to_cpu(sent->opcode); 2115bda4f23aSAndrei Emeltchenko 2116bda4f23aSAndrei Emeltchenko BT_ERR("%s command 0x%4.4x tx timeout", hdev->name, opcode); 2117bda4f23aSAndrei Emeltchenko } else { 21186bd32326SVille Tervo BT_ERR("%s command tx timeout", hdev->name); 2119bda4f23aSAndrei Emeltchenko } 2120bda4f23aSAndrei Emeltchenko 21216bd32326SVille Tervo atomic_set(&hdev->cmd_cnt, 1); 2122c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 21236bd32326SVille Tervo } 21246bd32326SVille Tervo 21252763eda6SSzymon Janc struct oob_data *hci_find_remote_oob_data(struct hci_dev *hdev, 21262763eda6SSzymon Janc bdaddr_t *bdaddr) 21272763eda6SSzymon Janc { 21282763eda6SSzymon Janc struct oob_data *data; 21292763eda6SSzymon Janc 21302763eda6SSzymon Janc list_for_each_entry(data, &hdev->remote_oob_data, list) 21312763eda6SSzymon Janc if (bacmp(bdaddr, &data->bdaddr) == 0) 21322763eda6SSzymon Janc return data; 21332763eda6SSzymon Janc 21342763eda6SSzymon Janc return NULL; 21352763eda6SSzymon Janc } 21362763eda6SSzymon Janc 21372763eda6SSzymon Janc int hci_remove_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr) 21382763eda6SSzymon Janc { 21392763eda6SSzymon Janc struct oob_data *data; 21402763eda6SSzymon Janc 21412763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 21422763eda6SSzymon Janc if (!data) 21432763eda6SSzymon Janc return -ENOENT; 21442763eda6SSzymon Janc 21456ed93dc6SAndrei Emeltchenko BT_DBG("%s removing %pMR", hdev->name, bdaddr); 21462763eda6SSzymon Janc 21472763eda6SSzymon Janc list_del(&data->list); 21482763eda6SSzymon Janc kfree(data); 21492763eda6SSzymon Janc 21502763eda6SSzymon Janc return 0; 21512763eda6SSzymon Janc } 21522763eda6SSzymon Janc 21532763eda6SSzymon Janc int hci_remote_oob_data_clear(struct hci_dev *hdev) 21542763eda6SSzymon Janc { 21552763eda6SSzymon Janc struct oob_data *data, *n; 21562763eda6SSzymon Janc 21572763eda6SSzymon Janc list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) { 21582763eda6SSzymon Janc list_del(&data->list); 21592763eda6SSzymon Janc kfree(data); 21602763eda6SSzymon Janc } 21612763eda6SSzymon Janc 21622763eda6SSzymon Janc return 0; 21632763eda6SSzymon Janc } 21642763eda6SSzymon Janc 21652763eda6SSzymon Janc int hci_add_remote_oob_data(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 *hash, 21662763eda6SSzymon Janc u8 *randomizer) 21672763eda6SSzymon Janc { 21682763eda6SSzymon Janc struct oob_data *data; 21692763eda6SSzymon Janc 21702763eda6SSzymon Janc data = hci_find_remote_oob_data(hdev, bdaddr); 21712763eda6SSzymon Janc 21722763eda6SSzymon Janc if (!data) { 21732763eda6SSzymon Janc data = kmalloc(sizeof(*data), GFP_ATOMIC); 21742763eda6SSzymon Janc if (!data) 21752763eda6SSzymon Janc return -ENOMEM; 21762763eda6SSzymon Janc 21772763eda6SSzymon Janc bacpy(&data->bdaddr, bdaddr); 21782763eda6SSzymon Janc list_add(&data->list, &hdev->remote_oob_data); 21792763eda6SSzymon Janc } 21802763eda6SSzymon Janc 21812763eda6SSzymon Janc memcpy(data->hash, hash, sizeof(data->hash)); 21822763eda6SSzymon Janc memcpy(data->randomizer, randomizer, sizeof(data->randomizer)); 21832763eda6SSzymon Janc 21846ed93dc6SAndrei Emeltchenko BT_DBG("%s for %pMR", hdev->name, bdaddr); 21852763eda6SSzymon Janc 21862763eda6SSzymon Janc return 0; 21872763eda6SSzymon Janc } 21882763eda6SSzymon Janc 2189b9ee0a78SMarcel Holtmann struct bdaddr_list *hci_blacklist_lookup(struct hci_dev *hdev, 2190b9ee0a78SMarcel Holtmann bdaddr_t *bdaddr, u8 type) 2191b2a66aadSAntti Julku { 2192b2a66aadSAntti Julku struct bdaddr_list *b; 2193b2a66aadSAntti Julku 2194b9ee0a78SMarcel Holtmann list_for_each_entry(b, &hdev->blacklist, list) { 2195b9ee0a78SMarcel Holtmann if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type) 2196b2a66aadSAntti Julku return b; 2197b9ee0a78SMarcel Holtmann } 2198b2a66aadSAntti Julku 2199b2a66aadSAntti Julku return NULL; 2200b2a66aadSAntti Julku } 2201b2a66aadSAntti Julku 2202b2a66aadSAntti Julku int hci_blacklist_clear(struct hci_dev *hdev) 2203b2a66aadSAntti Julku { 2204b2a66aadSAntti Julku struct list_head *p, *n; 2205b2a66aadSAntti Julku 2206b2a66aadSAntti Julku list_for_each_safe(p, n, &hdev->blacklist) { 2207b9ee0a78SMarcel Holtmann struct bdaddr_list *b = list_entry(p, struct bdaddr_list, list); 2208b2a66aadSAntti Julku 2209b2a66aadSAntti Julku list_del(p); 2210b2a66aadSAntti Julku kfree(b); 2211b2a66aadSAntti Julku } 2212b2a66aadSAntti Julku 2213b2a66aadSAntti Julku return 0; 2214b2a66aadSAntti Julku } 2215b2a66aadSAntti Julku 221688c1fe4bSJohan Hedberg int hci_blacklist_add(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 2217b2a66aadSAntti Julku { 2218b2a66aadSAntti Julku struct bdaddr_list *entry; 2219b2a66aadSAntti Julku 2220b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 2221b2a66aadSAntti Julku return -EBADF; 2222b2a66aadSAntti Julku 2223b9ee0a78SMarcel Holtmann if (hci_blacklist_lookup(hdev, bdaddr, type)) 22245e762444SAntti Julku return -EEXIST; 2225b2a66aadSAntti Julku 2226b2a66aadSAntti Julku entry = kzalloc(sizeof(struct bdaddr_list), GFP_KERNEL); 22275e762444SAntti Julku if (!entry) 22285e762444SAntti Julku return -ENOMEM; 2229b2a66aadSAntti Julku 2230b2a66aadSAntti Julku bacpy(&entry->bdaddr, bdaddr); 2231b9ee0a78SMarcel Holtmann entry->bdaddr_type = type; 2232b2a66aadSAntti Julku 2233b2a66aadSAntti Julku list_add(&entry->list, &hdev->blacklist); 2234b2a66aadSAntti Julku 223588c1fe4bSJohan Hedberg return mgmt_device_blocked(hdev, bdaddr, type); 2236b2a66aadSAntti Julku } 2237b2a66aadSAntti Julku 223888c1fe4bSJohan Hedberg int hci_blacklist_del(struct hci_dev *hdev, bdaddr_t *bdaddr, u8 type) 2239b2a66aadSAntti Julku { 2240b2a66aadSAntti Julku struct bdaddr_list *entry; 2241b2a66aadSAntti Julku 2242b9ee0a78SMarcel Holtmann if (!bacmp(bdaddr, BDADDR_ANY)) 22435e762444SAntti Julku return hci_blacklist_clear(hdev); 2244b2a66aadSAntti Julku 2245b9ee0a78SMarcel Holtmann entry = hci_blacklist_lookup(hdev, bdaddr, type); 22461ec918ceSSzymon Janc if (!entry) 22475e762444SAntti Julku return -ENOENT; 2248b2a66aadSAntti Julku 2249b2a66aadSAntti Julku list_del(&entry->list); 2250b2a66aadSAntti Julku kfree(entry); 2251b2a66aadSAntti Julku 225288c1fe4bSJohan Hedberg return mgmt_device_unblocked(hdev, bdaddr, type); 2253b2a66aadSAntti Julku } 2254b2a66aadSAntti Julku 22554c87eaabSAndre Guedes static void inquiry_complete(struct hci_dev *hdev, u8 status) 22567ba8b4beSAndre Guedes { 22574c87eaabSAndre Guedes if (status) { 22584c87eaabSAndre Guedes BT_ERR("Failed to start inquiry: status %d", status); 22597ba8b4beSAndre Guedes 22604c87eaabSAndre Guedes hci_dev_lock(hdev); 22614c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 22624c87eaabSAndre Guedes hci_dev_unlock(hdev); 22634c87eaabSAndre Guedes return; 22644c87eaabSAndre Guedes } 22657ba8b4beSAndre Guedes } 22667ba8b4beSAndre Guedes 22674c87eaabSAndre Guedes static void le_scan_disable_work_complete(struct hci_dev *hdev, u8 status) 22687ba8b4beSAndre Guedes { 22694c87eaabSAndre Guedes /* General inquiry access code (GIAC) */ 22704c87eaabSAndre Guedes u8 lap[3] = { 0x33, 0x8b, 0x9e }; 22714c87eaabSAndre Guedes struct hci_request req; 22724c87eaabSAndre Guedes struct hci_cp_inquiry cp; 22737ba8b4beSAndre Guedes int err; 22747ba8b4beSAndre Guedes 22754c87eaabSAndre Guedes if (status) { 22764c87eaabSAndre Guedes BT_ERR("Failed to disable LE scanning: status %d", status); 22774c87eaabSAndre Guedes return; 22787ba8b4beSAndre Guedes } 22797ba8b4beSAndre Guedes 22804c87eaabSAndre Guedes switch (hdev->discovery.type) { 22814c87eaabSAndre Guedes case DISCOV_TYPE_LE: 22824c87eaabSAndre Guedes hci_dev_lock(hdev); 22834c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 22844c87eaabSAndre Guedes hci_dev_unlock(hdev); 22854c87eaabSAndre Guedes break; 22867dbfac1dSAndre Guedes 22874c87eaabSAndre Guedes case DISCOV_TYPE_INTERLEAVED: 22884c87eaabSAndre Guedes hci_req_init(&req, hdev); 22897dbfac1dSAndre Guedes 22907dbfac1dSAndre Guedes memset(&cp, 0, sizeof(cp)); 22914c87eaabSAndre Guedes memcpy(&cp.lap, lap, sizeof(cp.lap)); 22924c87eaabSAndre Guedes cp.length = DISCOV_INTERLEAVED_INQUIRY_LEN; 22934c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_INQUIRY, sizeof(cp), &cp); 22944c87eaabSAndre Guedes 22954c87eaabSAndre Guedes hci_dev_lock(hdev); 22964c87eaabSAndre Guedes 22974c87eaabSAndre Guedes hci_inquiry_cache_flush(hdev); 22984c87eaabSAndre Guedes 22994c87eaabSAndre Guedes err = hci_req_run(&req, inquiry_complete); 23004c87eaabSAndre Guedes if (err) { 23014c87eaabSAndre Guedes BT_ERR("Inquiry request failed: err %d", err); 23024c87eaabSAndre Guedes hci_discovery_set_state(hdev, DISCOVERY_STOPPED); 23037dbfac1dSAndre Guedes } 23047dbfac1dSAndre Guedes 23054c87eaabSAndre Guedes hci_dev_unlock(hdev); 23064c87eaabSAndre Guedes break; 23074c87eaabSAndre Guedes } 23087dbfac1dSAndre Guedes } 23097dbfac1dSAndre Guedes 23107ba8b4beSAndre Guedes static void le_scan_disable_work(struct work_struct *work) 23117ba8b4beSAndre Guedes { 23127ba8b4beSAndre Guedes struct hci_dev *hdev = container_of(work, struct hci_dev, 23137ba8b4beSAndre Guedes le_scan_disable.work); 23147ba8b4beSAndre Guedes struct hci_cp_le_set_scan_enable cp; 23154c87eaabSAndre Guedes struct hci_request req; 23164c87eaabSAndre Guedes int err; 23177ba8b4beSAndre Guedes 23187ba8b4beSAndre Guedes BT_DBG("%s", hdev->name); 23197ba8b4beSAndre Guedes 23204c87eaabSAndre Guedes hci_req_init(&req, hdev); 23217ba8b4beSAndre Guedes 23227ba8b4beSAndre Guedes memset(&cp, 0, sizeof(cp)); 23234c87eaabSAndre Guedes cp.enable = LE_SCAN_DISABLE; 23244c87eaabSAndre Guedes hci_req_add(&req, HCI_OP_LE_SET_SCAN_ENABLE, sizeof(cp), &cp); 23257ba8b4beSAndre Guedes 23264c87eaabSAndre Guedes err = hci_req_run(&req, le_scan_disable_work_complete); 23274c87eaabSAndre Guedes if (err) 23284c87eaabSAndre Guedes BT_ERR("Disable LE scanning request failed: err %d", err); 232928b75a89SAndre Guedes } 233028b75a89SAndre Guedes 23319be0dab7SDavid Herrmann /* Alloc HCI device */ 23329be0dab7SDavid Herrmann struct hci_dev *hci_alloc_dev(void) 23339be0dab7SDavid Herrmann { 23349be0dab7SDavid Herrmann struct hci_dev *hdev; 23359be0dab7SDavid Herrmann 23369be0dab7SDavid Herrmann hdev = kzalloc(sizeof(struct hci_dev), GFP_KERNEL); 23379be0dab7SDavid Herrmann if (!hdev) 23389be0dab7SDavid Herrmann return NULL; 23399be0dab7SDavid Herrmann 2340b1b813d4SDavid Herrmann hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1); 2341b1b813d4SDavid Herrmann hdev->esco_type = (ESCO_HV1); 2342b1b813d4SDavid Herrmann hdev->link_mode = (HCI_LM_ACCEPT); 2343b4cb9fb2SMarcel Holtmann hdev->num_iac = 0x01; /* One IAC support is mandatory */ 2344b1b813d4SDavid Herrmann hdev->io_capability = 0x03; /* No Input No Output */ 2345bbaf444aSJohan Hedberg hdev->inq_tx_power = HCI_TX_POWER_INVALID; 2346bbaf444aSJohan Hedberg hdev->adv_tx_power = HCI_TX_POWER_INVALID; 2347b1b813d4SDavid Herrmann 2348b1b813d4SDavid Herrmann hdev->sniff_max_interval = 800; 2349b1b813d4SDavid Herrmann hdev->sniff_min_interval = 80; 2350b1b813d4SDavid Herrmann 2351bef64738SMarcel Holtmann hdev->le_scan_interval = 0x0060; 2352bef64738SMarcel Holtmann hdev->le_scan_window = 0x0030; 2353bef64738SMarcel Holtmann 2354b1b813d4SDavid Herrmann mutex_init(&hdev->lock); 2355b1b813d4SDavid Herrmann mutex_init(&hdev->req_lock); 2356b1b813d4SDavid Herrmann 2357b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->mgmt_pending); 2358b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->blacklist); 2359b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->uuids); 2360b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->link_keys); 2361b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->long_term_keys); 2362b1b813d4SDavid Herrmann INIT_LIST_HEAD(&hdev->remote_oob_data); 23636b536b5eSAndrei Emeltchenko INIT_LIST_HEAD(&hdev->conn_hash.list); 2364b1b813d4SDavid Herrmann 2365b1b813d4SDavid Herrmann INIT_WORK(&hdev->rx_work, hci_rx_work); 2366b1b813d4SDavid Herrmann INIT_WORK(&hdev->cmd_work, hci_cmd_work); 2367b1b813d4SDavid Herrmann INIT_WORK(&hdev->tx_work, hci_tx_work); 2368b1b813d4SDavid Herrmann INIT_WORK(&hdev->power_on, hci_power_on); 2369b1b813d4SDavid Herrmann 2370b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->power_off, hci_power_off); 2371b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->discov_off, hci_discov_off); 2372b1b813d4SDavid Herrmann INIT_DELAYED_WORK(&hdev->le_scan_disable, le_scan_disable_work); 2373b1b813d4SDavid Herrmann 2374b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->rx_q); 2375b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->cmd_q); 2376b1b813d4SDavid Herrmann skb_queue_head_init(&hdev->raw_q); 2377b1b813d4SDavid Herrmann 2378b1b813d4SDavid Herrmann init_waitqueue_head(&hdev->req_wait_q); 2379b1b813d4SDavid Herrmann 2380bda4f23aSAndrei Emeltchenko setup_timer(&hdev->cmd_timer, hci_cmd_timeout, (unsigned long) hdev); 2381b1b813d4SDavid Herrmann 2382b1b813d4SDavid Herrmann hci_init_sysfs(hdev); 2383b1b813d4SDavid Herrmann discovery_init(hdev); 23849be0dab7SDavid Herrmann 23859be0dab7SDavid Herrmann return hdev; 23869be0dab7SDavid Herrmann } 23879be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_alloc_dev); 23889be0dab7SDavid Herrmann 23899be0dab7SDavid Herrmann /* Free HCI device */ 23909be0dab7SDavid Herrmann void hci_free_dev(struct hci_dev *hdev) 23919be0dab7SDavid Herrmann { 23929be0dab7SDavid Herrmann /* will free via device release */ 23939be0dab7SDavid Herrmann put_device(&hdev->dev); 23949be0dab7SDavid Herrmann } 23959be0dab7SDavid Herrmann EXPORT_SYMBOL(hci_free_dev); 23969be0dab7SDavid Herrmann 23971da177e4SLinus Torvalds /* Register HCI device */ 23981da177e4SLinus Torvalds int hci_register_dev(struct hci_dev *hdev) 23991da177e4SLinus Torvalds { 2400b1b813d4SDavid Herrmann int id, error; 24011da177e4SLinus Torvalds 2402010666a1SDavid Herrmann if (!hdev->open || !hdev->close) 24031da177e4SLinus Torvalds return -EINVAL; 24041da177e4SLinus Torvalds 240508add513SMat Martineau /* Do not allow HCI_AMP devices to register at index 0, 240608add513SMat Martineau * so the index can be used as the AMP controller ID. 240708add513SMat Martineau */ 24083df92b31SSasha Levin switch (hdev->dev_type) { 24093df92b31SSasha Levin case HCI_BREDR: 24103df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 0, 0, GFP_KERNEL); 24111da177e4SLinus Torvalds break; 24123df92b31SSasha Levin case HCI_AMP: 24133df92b31SSasha Levin id = ida_simple_get(&hci_index_ida, 1, 0, GFP_KERNEL); 24143df92b31SSasha Levin break; 24153df92b31SSasha Levin default: 24163df92b31SSasha Levin return -EINVAL; 24171da177e4SLinus Torvalds } 24181da177e4SLinus Torvalds 24193df92b31SSasha Levin if (id < 0) 24203df92b31SSasha Levin return id; 24213df92b31SSasha Levin 24221da177e4SLinus Torvalds sprintf(hdev->name, "hci%d", id); 24231da177e4SLinus Torvalds hdev->id = id; 24242d8b3a11SAndrei Emeltchenko 24252d8b3a11SAndrei Emeltchenko BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 24262d8b3a11SAndrei Emeltchenko 2427d8537548SKees Cook hdev->workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 2428d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 242933ca954dSDavid Herrmann if (!hdev->workqueue) { 243033ca954dSDavid Herrmann error = -ENOMEM; 243133ca954dSDavid Herrmann goto err; 243233ca954dSDavid Herrmann } 2433f48fd9c8SMarcel Holtmann 2434d8537548SKees Cook hdev->req_workqueue = alloc_workqueue("%s", WQ_HIGHPRI | WQ_UNBOUND | 2435d8537548SKees Cook WQ_MEM_RECLAIM, 1, hdev->name); 24366ead1bbcSJohan Hedberg if (!hdev->req_workqueue) { 24376ead1bbcSJohan Hedberg destroy_workqueue(hdev->workqueue); 24386ead1bbcSJohan Hedberg error = -ENOMEM; 24396ead1bbcSJohan Hedberg goto err; 24406ead1bbcSJohan Hedberg } 24416ead1bbcSJohan Hedberg 244233ca954dSDavid Herrmann error = hci_add_sysfs(hdev); 244333ca954dSDavid Herrmann if (error < 0) 244433ca954dSDavid Herrmann goto err_wqueue; 24451da177e4SLinus Torvalds 2446611b30f7SMarcel Holtmann hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev, 2447a8c5fb1aSGustavo Padovan RFKILL_TYPE_BLUETOOTH, &hci_rfkill_ops, 2448a8c5fb1aSGustavo Padovan hdev); 2449611b30f7SMarcel Holtmann if (hdev->rfkill) { 2450611b30f7SMarcel Holtmann if (rfkill_register(hdev->rfkill) < 0) { 2451611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 2452611b30f7SMarcel Holtmann hdev->rfkill = NULL; 2453611b30f7SMarcel Holtmann } 2454611b30f7SMarcel Holtmann } 2455611b30f7SMarcel Holtmann 24565e130367SJohan Hedberg if (hdev->rfkill && rfkill_blocked(hdev->rfkill)) 24575e130367SJohan Hedberg set_bit(HCI_RFKILLED, &hdev->dev_flags); 24585e130367SJohan Hedberg 2459a8b2d5c2SJohan Hedberg set_bit(HCI_SETUP, &hdev->dev_flags); 2460004b0258SMarcel Holtmann set_bit(HCI_AUTO_OFF, &hdev->dev_flags); 2461ce2be9acSAndrei Emeltchenko 246201cd3404SMarcel Holtmann if (hdev->dev_type == HCI_BREDR) { 246356f87901SJohan Hedberg /* Assume BR/EDR support until proven otherwise (such as 246456f87901SJohan Hedberg * through reading supported features during init. 246556f87901SJohan Hedberg */ 246656f87901SJohan Hedberg set_bit(HCI_BREDR_ENABLED, &hdev->dev_flags); 246756f87901SJohan Hedberg } 2468ce2be9acSAndrei Emeltchenko 2469fcee3377SGustavo Padovan write_lock(&hci_dev_list_lock); 2470fcee3377SGustavo Padovan list_add(&hdev->list, &hci_dev_list); 2471fcee3377SGustavo Padovan write_unlock(&hci_dev_list_lock); 2472fcee3377SGustavo Padovan 24731da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_REG); 2474dc946bd8SDavid Herrmann hci_dev_hold(hdev); 24751da177e4SLinus Torvalds 247619202573SJohan Hedberg queue_work(hdev->req_workqueue, &hdev->power_on); 2477fbe96d6fSMarcel Holtmann 24781da177e4SLinus Torvalds return id; 2479f48fd9c8SMarcel Holtmann 248033ca954dSDavid Herrmann err_wqueue: 248133ca954dSDavid Herrmann destroy_workqueue(hdev->workqueue); 24826ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 248333ca954dSDavid Herrmann err: 24843df92b31SSasha Levin ida_simple_remove(&hci_index_ida, hdev->id); 2485f48fd9c8SMarcel Holtmann 248633ca954dSDavid Herrmann return error; 24871da177e4SLinus Torvalds } 24881da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_dev); 24891da177e4SLinus Torvalds 24901da177e4SLinus Torvalds /* Unregister HCI device */ 249159735631SDavid Herrmann void hci_unregister_dev(struct hci_dev *hdev) 24921da177e4SLinus Torvalds { 24933df92b31SSasha Levin int i, id; 2494ef222013SMarcel Holtmann 2495c13854ceSMarcel Holtmann BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus); 24961da177e4SLinus Torvalds 249794324962SJohan Hovold set_bit(HCI_UNREGISTER, &hdev->dev_flags); 249894324962SJohan Hovold 24993df92b31SSasha Levin id = hdev->id; 25003df92b31SSasha Levin 2501f20d09d5SGustavo F. Padovan write_lock(&hci_dev_list_lock); 25021da177e4SLinus Torvalds list_del(&hdev->list); 2503f20d09d5SGustavo F. Padovan write_unlock(&hci_dev_list_lock); 25041da177e4SLinus Torvalds 25051da177e4SLinus Torvalds hci_dev_do_close(hdev); 25061da177e4SLinus Torvalds 2507cd4c5391SSuraj Sumangala for (i = 0; i < NUM_REASSEMBLY; i++) 2508ef222013SMarcel Holtmann kfree_skb(hdev->reassembly[i]); 2509ef222013SMarcel Holtmann 2510b9b5ef18SGustavo Padovan cancel_work_sync(&hdev->power_on); 2511b9b5ef18SGustavo Padovan 2512ab81cbf9SJohan Hedberg if (!test_bit(HCI_INIT, &hdev->flags) && 2513a8b2d5c2SJohan Hedberg !test_bit(HCI_SETUP, &hdev->dev_flags)) { 251409fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2515744cf19eSJohan Hedberg mgmt_index_removed(hdev); 251609fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 251756e5cb86SJohan Hedberg } 2518ab81cbf9SJohan Hedberg 25192e58ef3eSJohan Hedberg /* mgmt_index_removed should take care of emptying the 25202e58ef3eSJohan Hedberg * pending list */ 25212e58ef3eSJohan Hedberg BUG_ON(!list_empty(&hdev->mgmt_pending)); 25222e58ef3eSJohan Hedberg 25231da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_UNREG); 25241da177e4SLinus Torvalds 2525611b30f7SMarcel Holtmann if (hdev->rfkill) { 2526611b30f7SMarcel Holtmann rfkill_unregister(hdev->rfkill); 2527611b30f7SMarcel Holtmann rfkill_destroy(hdev->rfkill); 2528611b30f7SMarcel Holtmann } 2529611b30f7SMarcel Holtmann 2530ce242970SDavid Herrmann hci_del_sysfs(hdev); 2531147e2d59SDave Young 2532f48fd9c8SMarcel Holtmann destroy_workqueue(hdev->workqueue); 25336ead1bbcSJohan Hedberg destroy_workqueue(hdev->req_workqueue); 2534f48fd9c8SMarcel Holtmann 253509fd0de5SGustavo F. Padovan hci_dev_lock(hdev); 2536e2e0cacbSJohan Hedberg hci_blacklist_clear(hdev); 25372aeb9a1aSJohan Hedberg hci_uuids_clear(hdev); 253855ed8ca1SJohan Hedberg hci_link_keys_clear(hdev); 2539b899efafSVinicius Costa Gomes hci_smp_ltks_clear(hdev); 25402763eda6SSzymon Janc hci_remote_oob_data_clear(hdev); 254109fd0de5SGustavo F. Padovan hci_dev_unlock(hdev); 2542e2e0cacbSJohan Hedberg 2543dc946bd8SDavid Herrmann hci_dev_put(hdev); 25443df92b31SSasha Levin 25453df92b31SSasha Levin ida_simple_remove(&hci_index_ida, id); 25461da177e4SLinus Torvalds } 25471da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_dev); 25481da177e4SLinus Torvalds 25491da177e4SLinus Torvalds /* Suspend HCI device */ 25501da177e4SLinus Torvalds int hci_suspend_dev(struct hci_dev *hdev) 25511da177e4SLinus Torvalds { 25521da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_SUSPEND); 25531da177e4SLinus Torvalds return 0; 25541da177e4SLinus Torvalds } 25551da177e4SLinus Torvalds EXPORT_SYMBOL(hci_suspend_dev); 25561da177e4SLinus Torvalds 25571da177e4SLinus Torvalds /* Resume HCI device */ 25581da177e4SLinus Torvalds int hci_resume_dev(struct hci_dev *hdev) 25591da177e4SLinus Torvalds { 25601da177e4SLinus Torvalds hci_notify(hdev, HCI_DEV_RESUME); 25611da177e4SLinus Torvalds return 0; 25621da177e4SLinus Torvalds } 25631da177e4SLinus Torvalds EXPORT_SYMBOL(hci_resume_dev); 25641da177e4SLinus Torvalds 256576bca880SMarcel Holtmann /* Receive frame from HCI drivers */ 2566e1a26170SMarcel Holtmann int hci_recv_frame(struct hci_dev *hdev, struct sk_buff *skb) 256776bca880SMarcel Holtmann { 256876bca880SMarcel Holtmann if (!hdev || (!test_bit(HCI_UP, &hdev->flags) 256976bca880SMarcel Holtmann && !test_bit(HCI_INIT, &hdev->flags))) { 257076bca880SMarcel Holtmann kfree_skb(skb); 257176bca880SMarcel Holtmann return -ENXIO; 257276bca880SMarcel Holtmann } 257376bca880SMarcel Holtmann 2574d82603c6SJorrit Schippers /* Incoming skb */ 257576bca880SMarcel Holtmann bt_cb(skb)->incoming = 1; 257676bca880SMarcel Holtmann 257776bca880SMarcel Holtmann /* Time stamp */ 257876bca880SMarcel Holtmann __net_timestamp(skb); 257976bca880SMarcel Holtmann 258076bca880SMarcel Holtmann skb_queue_tail(&hdev->rx_q, skb); 2581b78752ccSMarcel Holtmann queue_work(hdev->workqueue, &hdev->rx_work); 2582c78ae283SMarcel Holtmann 258376bca880SMarcel Holtmann return 0; 258476bca880SMarcel Holtmann } 258576bca880SMarcel Holtmann EXPORT_SYMBOL(hci_recv_frame); 258676bca880SMarcel Holtmann 258733e882a5SSuraj Sumangala static int hci_reassembly(struct hci_dev *hdev, int type, void *data, 25881e429f38SGustavo F. Padovan int count, __u8 index) 258933e882a5SSuraj Sumangala { 259033e882a5SSuraj Sumangala int len = 0; 259133e882a5SSuraj Sumangala int hlen = 0; 259233e882a5SSuraj Sumangala int remain = count; 259333e882a5SSuraj Sumangala struct sk_buff *skb; 259433e882a5SSuraj Sumangala struct bt_skb_cb *scb; 259533e882a5SSuraj Sumangala 259633e882a5SSuraj Sumangala if ((type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) || 259733e882a5SSuraj Sumangala index >= NUM_REASSEMBLY) 259833e882a5SSuraj Sumangala return -EILSEQ; 259933e882a5SSuraj Sumangala 260033e882a5SSuraj Sumangala skb = hdev->reassembly[index]; 260133e882a5SSuraj Sumangala 260233e882a5SSuraj Sumangala if (!skb) { 260333e882a5SSuraj Sumangala switch (type) { 260433e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 260533e882a5SSuraj Sumangala len = HCI_MAX_FRAME_SIZE; 260633e882a5SSuraj Sumangala hlen = HCI_ACL_HDR_SIZE; 260733e882a5SSuraj Sumangala break; 260833e882a5SSuraj Sumangala case HCI_EVENT_PKT: 260933e882a5SSuraj Sumangala len = HCI_MAX_EVENT_SIZE; 261033e882a5SSuraj Sumangala hlen = HCI_EVENT_HDR_SIZE; 261133e882a5SSuraj Sumangala break; 261233e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 261333e882a5SSuraj Sumangala len = HCI_MAX_SCO_SIZE; 261433e882a5SSuraj Sumangala hlen = HCI_SCO_HDR_SIZE; 261533e882a5SSuraj Sumangala break; 261633e882a5SSuraj Sumangala } 261733e882a5SSuraj Sumangala 26181e429f38SGustavo F. Padovan skb = bt_skb_alloc(len, GFP_ATOMIC); 261933e882a5SSuraj Sumangala if (!skb) 262033e882a5SSuraj Sumangala return -ENOMEM; 262133e882a5SSuraj Sumangala 262233e882a5SSuraj Sumangala scb = (void *) skb->cb; 262333e882a5SSuraj Sumangala scb->expect = hlen; 262433e882a5SSuraj Sumangala scb->pkt_type = type; 262533e882a5SSuraj Sumangala 262633e882a5SSuraj Sumangala hdev->reassembly[index] = skb; 262733e882a5SSuraj Sumangala } 262833e882a5SSuraj Sumangala 262933e882a5SSuraj Sumangala while (count) { 263033e882a5SSuraj Sumangala scb = (void *) skb->cb; 263189bb46d0SDan Carpenter len = min_t(uint, scb->expect, count); 263233e882a5SSuraj Sumangala 263333e882a5SSuraj Sumangala memcpy(skb_put(skb, len), data, len); 263433e882a5SSuraj Sumangala 263533e882a5SSuraj Sumangala count -= len; 263633e882a5SSuraj Sumangala data += len; 263733e882a5SSuraj Sumangala scb->expect -= len; 263833e882a5SSuraj Sumangala remain = count; 263933e882a5SSuraj Sumangala 264033e882a5SSuraj Sumangala switch (type) { 264133e882a5SSuraj Sumangala case HCI_EVENT_PKT: 264233e882a5SSuraj Sumangala if (skb->len == HCI_EVENT_HDR_SIZE) { 264333e882a5SSuraj Sumangala struct hci_event_hdr *h = hci_event_hdr(skb); 264433e882a5SSuraj Sumangala scb->expect = h->plen; 264533e882a5SSuraj Sumangala 264633e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 264733e882a5SSuraj Sumangala kfree_skb(skb); 264833e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 264933e882a5SSuraj Sumangala return -ENOMEM; 265033e882a5SSuraj Sumangala } 265133e882a5SSuraj Sumangala } 265233e882a5SSuraj Sumangala break; 265333e882a5SSuraj Sumangala 265433e882a5SSuraj Sumangala case HCI_ACLDATA_PKT: 265533e882a5SSuraj Sumangala if (skb->len == HCI_ACL_HDR_SIZE) { 265633e882a5SSuraj Sumangala struct hci_acl_hdr *h = hci_acl_hdr(skb); 265733e882a5SSuraj Sumangala scb->expect = __le16_to_cpu(h->dlen); 265833e882a5SSuraj Sumangala 265933e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 266033e882a5SSuraj Sumangala kfree_skb(skb); 266133e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 266233e882a5SSuraj Sumangala return -ENOMEM; 266333e882a5SSuraj Sumangala } 266433e882a5SSuraj Sumangala } 266533e882a5SSuraj Sumangala break; 266633e882a5SSuraj Sumangala 266733e882a5SSuraj Sumangala case HCI_SCODATA_PKT: 266833e882a5SSuraj Sumangala if (skb->len == HCI_SCO_HDR_SIZE) { 266933e882a5SSuraj Sumangala struct hci_sco_hdr *h = hci_sco_hdr(skb); 267033e882a5SSuraj Sumangala scb->expect = h->dlen; 267133e882a5SSuraj Sumangala 267233e882a5SSuraj Sumangala if (skb_tailroom(skb) < scb->expect) { 267333e882a5SSuraj Sumangala kfree_skb(skb); 267433e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 267533e882a5SSuraj Sumangala return -ENOMEM; 267633e882a5SSuraj Sumangala } 267733e882a5SSuraj Sumangala } 267833e882a5SSuraj Sumangala break; 267933e882a5SSuraj Sumangala } 268033e882a5SSuraj Sumangala 268133e882a5SSuraj Sumangala if (scb->expect == 0) { 268233e882a5SSuraj Sumangala /* Complete frame */ 268333e882a5SSuraj Sumangala 268433e882a5SSuraj Sumangala bt_cb(skb)->pkt_type = type; 2685e1a26170SMarcel Holtmann hci_recv_frame(hdev, skb); 268633e882a5SSuraj Sumangala 268733e882a5SSuraj Sumangala hdev->reassembly[index] = NULL; 268833e882a5SSuraj Sumangala return remain; 268933e882a5SSuraj Sumangala } 269033e882a5SSuraj Sumangala } 269133e882a5SSuraj Sumangala 269233e882a5SSuraj Sumangala return remain; 269333e882a5SSuraj Sumangala } 269433e882a5SSuraj Sumangala 2695ef222013SMarcel Holtmann int hci_recv_fragment(struct hci_dev *hdev, int type, void *data, int count) 2696ef222013SMarcel Holtmann { 2697f39a3c06SSuraj Sumangala int rem = 0; 2698f39a3c06SSuraj Sumangala 2699ef222013SMarcel Holtmann if (type < HCI_ACLDATA_PKT || type > HCI_EVENT_PKT) 2700ef222013SMarcel Holtmann return -EILSEQ; 2701ef222013SMarcel Holtmann 2702da5f6c37SGustavo F. Padovan while (count) { 27031e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, type - 1); 2704f39a3c06SSuraj Sumangala if (rem < 0) 2705f39a3c06SSuraj Sumangala return rem; 2706ef222013SMarcel Holtmann 2707f39a3c06SSuraj Sumangala data += (count - rem); 2708f39a3c06SSuraj Sumangala count = rem; 2709f81c6224SJoe Perches } 2710ef222013SMarcel Holtmann 2711f39a3c06SSuraj Sumangala return rem; 2712ef222013SMarcel Holtmann } 2713ef222013SMarcel Holtmann EXPORT_SYMBOL(hci_recv_fragment); 2714ef222013SMarcel Holtmann 271599811510SSuraj Sumangala #define STREAM_REASSEMBLY 0 271699811510SSuraj Sumangala 271799811510SSuraj Sumangala int hci_recv_stream_fragment(struct hci_dev *hdev, void *data, int count) 271899811510SSuraj Sumangala { 271999811510SSuraj Sumangala int type; 272099811510SSuraj Sumangala int rem = 0; 272199811510SSuraj Sumangala 2722da5f6c37SGustavo F. Padovan while (count) { 272399811510SSuraj Sumangala struct sk_buff *skb = hdev->reassembly[STREAM_REASSEMBLY]; 272499811510SSuraj Sumangala 272599811510SSuraj Sumangala if (!skb) { 272699811510SSuraj Sumangala struct { char type; } *pkt; 272799811510SSuraj Sumangala 272899811510SSuraj Sumangala /* Start of the frame */ 272999811510SSuraj Sumangala pkt = data; 273099811510SSuraj Sumangala type = pkt->type; 273199811510SSuraj Sumangala 273299811510SSuraj Sumangala data++; 273399811510SSuraj Sumangala count--; 273499811510SSuraj Sumangala } else 273599811510SSuraj Sumangala type = bt_cb(skb)->pkt_type; 273699811510SSuraj Sumangala 27371e429f38SGustavo F. Padovan rem = hci_reassembly(hdev, type, data, count, 27381e429f38SGustavo F. Padovan STREAM_REASSEMBLY); 273999811510SSuraj Sumangala if (rem < 0) 274099811510SSuraj Sumangala return rem; 274199811510SSuraj Sumangala 274299811510SSuraj Sumangala data += (count - rem); 274399811510SSuraj Sumangala count = rem; 2744f81c6224SJoe Perches } 274599811510SSuraj Sumangala 274699811510SSuraj Sumangala return rem; 274799811510SSuraj Sumangala } 274899811510SSuraj Sumangala EXPORT_SYMBOL(hci_recv_stream_fragment); 274999811510SSuraj Sumangala 27501da177e4SLinus Torvalds /* ---- Interface to upper protocols ---- */ 27511da177e4SLinus Torvalds 27521da177e4SLinus Torvalds int hci_register_cb(struct hci_cb *cb) 27531da177e4SLinus Torvalds { 27541da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 27551da177e4SLinus Torvalds 2756f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 27571da177e4SLinus Torvalds list_add(&cb->list, &hci_cb_list); 2758f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 27591da177e4SLinus Torvalds 27601da177e4SLinus Torvalds return 0; 27611da177e4SLinus Torvalds } 27621da177e4SLinus Torvalds EXPORT_SYMBOL(hci_register_cb); 27631da177e4SLinus Torvalds 27641da177e4SLinus Torvalds int hci_unregister_cb(struct hci_cb *cb) 27651da177e4SLinus Torvalds { 27661da177e4SLinus Torvalds BT_DBG("%p name %s", cb, cb->name); 27671da177e4SLinus Torvalds 2768f20d09d5SGustavo F. Padovan write_lock(&hci_cb_list_lock); 27691da177e4SLinus Torvalds list_del(&cb->list); 2770f20d09d5SGustavo F. Padovan write_unlock(&hci_cb_list_lock); 27711da177e4SLinus Torvalds 27721da177e4SLinus Torvalds return 0; 27731da177e4SLinus Torvalds } 27741da177e4SLinus Torvalds EXPORT_SYMBOL(hci_unregister_cb); 27751da177e4SLinus Torvalds 277651086991SMarcel Holtmann static void hci_send_frame(struct hci_dev *hdev, struct sk_buff *skb) 27771da177e4SLinus Torvalds { 27780d48d939SMarcel Holtmann BT_DBG("%s type %d len %d", hdev->name, bt_cb(skb)->pkt_type, skb->len); 27791da177e4SLinus Torvalds 27801da177e4SLinus Torvalds /* Time stamp */ 2781a61bbcf2SPatrick McHardy __net_timestamp(skb); 27821da177e4SLinus Torvalds 2783cd82e61cSMarcel Holtmann /* Send copy to monitor */ 2784cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 2785cd82e61cSMarcel Holtmann 2786cd82e61cSMarcel Holtmann if (atomic_read(&hdev->promisc)) { 2787cd82e61cSMarcel Holtmann /* Send copy to the sockets */ 2788470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 27891da177e4SLinus Torvalds } 27901da177e4SLinus Torvalds 27911da177e4SLinus Torvalds /* Get rid of skb owner, prior to sending to the driver. */ 27921da177e4SLinus Torvalds skb_orphan(skb); 27931da177e4SLinus Torvalds 27947bd8f09fSMarcel Holtmann if (hdev->send(hdev, skb) < 0) 279551086991SMarcel Holtmann BT_ERR("%s sending frame failed", hdev->name); 27961da177e4SLinus Torvalds } 27971da177e4SLinus Torvalds 27983119ae95SJohan Hedberg void hci_req_init(struct hci_request *req, struct hci_dev *hdev) 27993119ae95SJohan Hedberg { 28003119ae95SJohan Hedberg skb_queue_head_init(&req->cmd_q); 28013119ae95SJohan Hedberg req->hdev = hdev; 28025d73e034SAndre Guedes req->err = 0; 28033119ae95SJohan Hedberg } 28043119ae95SJohan Hedberg 28053119ae95SJohan Hedberg int hci_req_run(struct hci_request *req, hci_req_complete_t complete) 28063119ae95SJohan Hedberg { 28073119ae95SJohan Hedberg struct hci_dev *hdev = req->hdev; 28083119ae95SJohan Hedberg struct sk_buff *skb; 28093119ae95SJohan Hedberg unsigned long flags; 28103119ae95SJohan Hedberg 28113119ae95SJohan Hedberg BT_DBG("length %u", skb_queue_len(&req->cmd_q)); 28123119ae95SJohan Hedberg 28135d73e034SAndre Guedes /* If an error occured during request building, remove all HCI 28145d73e034SAndre Guedes * commands queued on the HCI request queue. 28155d73e034SAndre Guedes */ 28165d73e034SAndre Guedes if (req->err) { 28175d73e034SAndre Guedes skb_queue_purge(&req->cmd_q); 28185d73e034SAndre Guedes return req->err; 28195d73e034SAndre Guedes } 28205d73e034SAndre Guedes 28213119ae95SJohan Hedberg /* Do not allow empty requests */ 28223119ae95SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 2823382b0c39SAndre Guedes return -ENODATA; 28243119ae95SJohan Hedberg 28253119ae95SJohan Hedberg skb = skb_peek_tail(&req->cmd_q); 28263119ae95SJohan Hedberg bt_cb(skb)->req.complete = complete; 28273119ae95SJohan Hedberg 28283119ae95SJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 28293119ae95SJohan Hedberg skb_queue_splice_tail(&req->cmd_q, &hdev->cmd_q); 28303119ae95SJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 28313119ae95SJohan Hedberg 28323119ae95SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 28333119ae95SJohan Hedberg 28343119ae95SJohan Hedberg return 0; 28353119ae95SJohan Hedberg } 28363119ae95SJohan Hedberg 28371ca3a9d0SJohan Hedberg static struct sk_buff *hci_prepare_cmd(struct hci_dev *hdev, u16 opcode, 283807dc93ddSJohan Hedberg u32 plen, const void *param) 28391da177e4SLinus Torvalds { 28401da177e4SLinus Torvalds int len = HCI_COMMAND_HDR_SIZE + plen; 28411da177e4SLinus Torvalds struct hci_command_hdr *hdr; 28421da177e4SLinus Torvalds struct sk_buff *skb; 28431da177e4SLinus Torvalds 28441da177e4SLinus Torvalds skb = bt_skb_alloc(len, GFP_ATOMIC); 28451ca3a9d0SJohan Hedberg if (!skb) 28461ca3a9d0SJohan Hedberg return NULL; 28471da177e4SLinus Torvalds 28481da177e4SLinus Torvalds hdr = (struct hci_command_hdr *) skb_put(skb, HCI_COMMAND_HDR_SIZE); 2849a9de9248SMarcel Holtmann hdr->opcode = cpu_to_le16(opcode); 28501da177e4SLinus Torvalds hdr->plen = plen; 28511da177e4SLinus Torvalds 28521da177e4SLinus Torvalds if (plen) 28531da177e4SLinus Torvalds memcpy(skb_put(skb, plen), param, plen); 28541da177e4SLinus Torvalds 28551da177e4SLinus Torvalds BT_DBG("skb len %d", skb->len); 28561da177e4SLinus Torvalds 28570d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_COMMAND_PKT; 2858c78ae283SMarcel Holtmann 28591ca3a9d0SJohan Hedberg return skb; 28601ca3a9d0SJohan Hedberg } 28611ca3a9d0SJohan Hedberg 28621ca3a9d0SJohan Hedberg /* Send HCI command */ 286307dc93ddSJohan Hedberg int hci_send_cmd(struct hci_dev *hdev, __u16 opcode, __u32 plen, 286407dc93ddSJohan Hedberg const void *param) 28651ca3a9d0SJohan Hedberg { 28661ca3a9d0SJohan Hedberg struct sk_buff *skb; 28671ca3a9d0SJohan Hedberg 28681ca3a9d0SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 28691ca3a9d0SJohan Hedberg 28701ca3a9d0SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 28711ca3a9d0SJohan Hedberg if (!skb) { 28721ca3a9d0SJohan Hedberg BT_ERR("%s no memory for command", hdev->name); 28731ca3a9d0SJohan Hedberg return -ENOMEM; 28741ca3a9d0SJohan Hedberg } 28751ca3a9d0SJohan Hedberg 287611714b3dSJohan Hedberg /* Stand-alone HCI commands must be flaged as 287711714b3dSJohan Hedberg * single-command requests. 287811714b3dSJohan Hedberg */ 287911714b3dSJohan Hedberg bt_cb(skb)->req.start = true; 288011714b3dSJohan Hedberg 28811da177e4SLinus Torvalds skb_queue_tail(&hdev->cmd_q, skb); 2882c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 28831da177e4SLinus Torvalds 28841da177e4SLinus Torvalds return 0; 28851da177e4SLinus Torvalds } 28861da177e4SLinus Torvalds 288771c76a17SJohan Hedberg /* Queue a command to an asynchronous HCI request */ 288807dc93ddSJohan Hedberg void hci_req_add_ev(struct hci_request *req, u16 opcode, u32 plen, 288907dc93ddSJohan Hedberg const void *param, u8 event) 289071c76a17SJohan Hedberg { 289171c76a17SJohan Hedberg struct hci_dev *hdev = req->hdev; 289271c76a17SJohan Hedberg struct sk_buff *skb; 289371c76a17SJohan Hedberg 289471c76a17SJohan Hedberg BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen); 289571c76a17SJohan Hedberg 289634739c1eSAndre Guedes /* If an error occured during request building, there is no point in 289734739c1eSAndre Guedes * queueing the HCI command. We can simply return. 289834739c1eSAndre Guedes */ 289934739c1eSAndre Guedes if (req->err) 290034739c1eSAndre Guedes return; 290134739c1eSAndre Guedes 290271c76a17SJohan Hedberg skb = hci_prepare_cmd(hdev, opcode, plen, param); 290371c76a17SJohan Hedberg if (!skb) { 29045d73e034SAndre Guedes BT_ERR("%s no memory for command (opcode 0x%4.4x)", 29055d73e034SAndre Guedes hdev->name, opcode); 29065d73e034SAndre Guedes req->err = -ENOMEM; 2907e348fe6bSAndre Guedes return; 290871c76a17SJohan Hedberg } 290971c76a17SJohan Hedberg 291071c76a17SJohan Hedberg if (skb_queue_empty(&req->cmd_q)) 291171c76a17SJohan Hedberg bt_cb(skb)->req.start = true; 291271c76a17SJohan Hedberg 291302350a72SJohan Hedberg bt_cb(skb)->req.event = event; 291402350a72SJohan Hedberg 291571c76a17SJohan Hedberg skb_queue_tail(&req->cmd_q, skb); 291671c76a17SJohan Hedberg } 291771c76a17SJohan Hedberg 291807dc93ddSJohan Hedberg void hci_req_add(struct hci_request *req, u16 opcode, u32 plen, 291907dc93ddSJohan Hedberg const void *param) 292002350a72SJohan Hedberg { 292102350a72SJohan Hedberg hci_req_add_ev(req, opcode, plen, param, 0); 292202350a72SJohan Hedberg } 292302350a72SJohan Hedberg 29241da177e4SLinus Torvalds /* Get data from the previously sent command */ 2925a9de9248SMarcel Holtmann void *hci_sent_cmd_data(struct hci_dev *hdev, __u16 opcode) 29261da177e4SLinus Torvalds { 29271da177e4SLinus Torvalds struct hci_command_hdr *hdr; 29281da177e4SLinus Torvalds 29291da177e4SLinus Torvalds if (!hdev->sent_cmd) 29301da177e4SLinus Torvalds return NULL; 29311da177e4SLinus Torvalds 29321da177e4SLinus Torvalds hdr = (void *) hdev->sent_cmd->data; 29331da177e4SLinus Torvalds 2934a9de9248SMarcel Holtmann if (hdr->opcode != cpu_to_le16(opcode)) 29351da177e4SLinus Torvalds return NULL; 29361da177e4SLinus Torvalds 2937f0e09510SAndrei Emeltchenko BT_DBG("%s opcode 0x%4.4x", hdev->name, opcode); 29381da177e4SLinus Torvalds 29391da177e4SLinus Torvalds return hdev->sent_cmd->data + HCI_COMMAND_HDR_SIZE; 29401da177e4SLinus Torvalds } 29411da177e4SLinus Torvalds 29421da177e4SLinus Torvalds /* Send ACL data */ 29431da177e4SLinus Torvalds static void hci_add_acl_hdr(struct sk_buff *skb, __u16 handle, __u16 flags) 29441da177e4SLinus Torvalds { 29451da177e4SLinus Torvalds struct hci_acl_hdr *hdr; 29461da177e4SLinus Torvalds int len = skb->len; 29471da177e4SLinus Torvalds 2948badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_ACL_HDR_SIZE); 2949badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 29509c70220bSArnaldo Carvalho de Melo hdr = (struct hci_acl_hdr *)skb_transport_header(skb); 2951aca3192cSYOSHIFUJI Hideaki hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags)); 2952aca3192cSYOSHIFUJI Hideaki hdr->dlen = cpu_to_le16(len); 29531da177e4SLinus Torvalds } 29541da177e4SLinus Torvalds 2955ee22be7eSAndrei Emeltchenko static void hci_queue_acl(struct hci_chan *chan, struct sk_buff_head *queue, 295673d80debSLuiz Augusto von Dentz struct sk_buff *skb, __u16 flags) 29571da177e4SLinus Torvalds { 2958ee22be7eSAndrei Emeltchenko struct hci_conn *conn = chan->conn; 29591da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 29601da177e4SLinus Torvalds struct sk_buff *list; 29611da177e4SLinus Torvalds 2962087bfd99SGustavo Padovan skb->len = skb_headlen(skb); 2963087bfd99SGustavo Padovan skb->data_len = 0; 2964087bfd99SGustavo Padovan 2965087bfd99SGustavo Padovan bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 2966204a6e54SAndrei Emeltchenko 2967204a6e54SAndrei Emeltchenko switch (hdev->dev_type) { 2968204a6e54SAndrei Emeltchenko case HCI_BREDR: 2969087bfd99SGustavo Padovan hci_add_acl_hdr(skb, conn->handle, flags); 2970204a6e54SAndrei Emeltchenko break; 2971204a6e54SAndrei Emeltchenko case HCI_AMP: 2972204a6e54SAndrei Emeltchenko hci_add_acl_hdr(skb, chan->handle, flags); 2973204a6e54SAndrei Emeltchenko break; 2974204a6e54SAndrei Emeltchenko default: 2975204a6e54SAndrei Emeltchenko BT_ERR("%s unknown dev_type %d", hdev->name, hdev->dev_type); 2976204a6e54SAndrei Emeltchenko return; 2977204a6e54SAndrei Emeltchenko } 2978087bfd99SGustavo Padovan 297970f23020SAndrei Emeltchenko list = skb_shinfo(skb)->frag_list; 298070f23020SAndrei Emeltchenko if (!list) { 29811da177e4SLinus Torvalds /* Non fragmented */ 29821da177e4SLinus Torvalds BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len); 29831da177e4SLinus Torvalds 298473d80debSLuiz Augusto von Dentz skb_queue_tail(queue, skb); 29851da177e4SLinus Torvalds } else { 29861da177e4SLinus Torvalds /* Fragmented */ 29871da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 29881da177e4SLinus Torvalds 29891da177e4SLinus Torvalds skb_shinfo(skb)->frag_list = NULL; 29901da177e4SLinus Torvalds 29911da177e4SLinus Torvalds /* Queue all fragments atomically */ 2992af3e6359SGustavo F. Padovan spin_lock(&queue->lock); 29931da177e4SLinus Torvalds 299473d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 2995e702112fSAndrei Emeltchenko 2996e702112fSAndrei Emeltchenko flags &= ~ACL_START; 2997e702112fSAndrei Emeltchenko flags |= ACL_CONT; 29981da177e4SLinus Torvalds do { 29991da177e4SLinus Torvalds skb = list; list = list->next; 30001da177e4SLinus Torvalds 30010d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_ACLDATA_PKT; 3002e702112fSAndrei Emeltchenko hci_add_acl_hdr(skb, conn->handle, flags); 30031da177e4SLinus Torvalds 30041da177e4SLinus Torvalds BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len); 30051da177e4SLinus Torvalds 300673d80debSLuiz Augusto von Dentz __skb_queue_tail(queue, skb); 30071da177e4SLinus Torvalds } while (list); 30081da177e4SLinus Torvalds 3009af3e6359SGustavo F. Padovan spin_unlock(&queue->lock); 30101da177e4SLinus Torvalds } 301173d80debSLuiz Augusto von Dentz } 301273d80debSLuiz Augusto von Dentz 301373d80debSLuiz Augusto von Dentz void hci_send_acl(struct hci_chan *chan, struct sk_buff *skb, __u16 flags) 301473d80debSLuiz Augusto von Dentz { 3015ee22be7eSAndrei Emeltchenko struct hci_dev *hdev = chan->conn->hdev; 301673d80debSLuiz Augusto von Dentz 3017f0e09510SAndrei Emeltchenko BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags); 301873d80debSLuiz Augusto von Dentz 3019ee22be7eSAndrei Emeltchenko hci_queue_acl(chan, &chan->data_q, skb, flags); 30201da177e4SLinus Torvalds 30213eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 30221da177e4SLinus Torvalds } 30231da177e4SLinus Torvalds 30241da177e4SLinus Torvalds /* Send SCO data */ 30250d861d8bSGustavo F. Padovan void hci_send_sco(struct hci_conn *conn, struct sk_buff *skb) 30261da177e4SLinus Torvalds { 30271da177e4SLinus Torvalds struct hci_dev *hdev = conn->hdev; 30281da177e4SLinus Torvalds struct hci_sco_hdr hdr; 30291da177e4SLinus Torvalds 30301da177e4SLinus Torvalds BT_DBG("%s len %d", hdev->name, skb->len); 30311da177e4SLinus Torvalds 3032aca3192cSYOSHIFUJI Hideaki hdr.handle = cpu_to_le16(conn->handle); 30331da177e4SLinus Torvalds hdr.dlen = skb->len; 30341da177e4SLinus Torvalds 3035badff6d0SArnaldo Carvalho de Melo skb_push(skb, HCI_SCO_HDR_SIZE); 3036badff6d0SArnaldo Carvalho de Melo skb_reset_transport_header(skb); 30379c70220bSArnaldo Carvalho de Melo memcpy(skb_transport_header(skb), &hdr, HCI_SCO_HDR_SIZE); 30381da177e4SLinus Torvalds 30390d48d939SMarcel Holtmann bt_cb(skb)->pkt_type = HCI_SCODATA_PKT; 3040c78ae283SMarcel Holtmann 30411da177e4SLinus Torvalds skb_queue_tail(&conn->data_q, skb); 30423eff45eaSGustavo F. Padovan queue_work(hdev->workqueue, &hdev->tx_work); 30431da177e4SLinus Torvalds } 30441da177e4SLinus Torvalds 30451da177e4SLinus Torvalds /* ---- HCI TX task (outgoing data) ---- */ 30461da177e4SLinus Torvalds 30471da177e4SLinus Torvalds /* HCI Connection scheduler */ 30486039aa73SGustavo Padovan static struct hci_conn *hci_low_sent(struct hci_dev *hdev, __u8 type, 3049a8c5fb1aSGustavo Padovan int *quote) 30501da177e4SLinus Torvalds { 30511da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 30528035ded4SLuiz Augusto von Dentz struct hci_conn *conn = NULL, *c; 3053abc5de8fSMikel Astiz unsigned int num = 0, min = ~0; 30541da177e4SLinus Torvalds 30551da177e4SLinus Torvalds /* We don't have to lock device here. Connections are always 30561da177e4SLinus Torvalds * added and removed with TX task disabled. */ 3057bf4c6325SGustavo F. Padovan 3058bf4c6325SGustavo F. Padovan rcu_read_lock(); 3059bf4c6325SGustavo F. Padovan 3060bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3061769be974SMarcel Holtmann if (c->type != type || skb_queue_empty(&c->data_q)) 30621da177e4SLinus Torvalds continue; 3063769be974SMarcel Holtmann 3064769be974SMarcel Holtmann if (c->state != BT_CONNECTED && c->state != BT_CONFIG) 3065769be974SMarcel Holtmann continue; 3066769be974SMarcel Holtmann 30671da177e4SLinus Torvalds num++; 30681da177e4SLinus Torvalds 30691da177e4SLinus Torvalds if (c->sent < min) { 30701da177e4SLinus Torvalds min = c->sent; 30711da177e4SLinus Torvalds conn = c; 30721da177e4SLinus Torvalds } 307352087a79SLuiz Augusto von Dentz 307452087a79SLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 307552087a79SLuiz Augusto von Dentz break; 30761da177e4SLinus Torvalds } 30771da177e4SLinus Torvalds 3078bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3079bf4c6325SGustavo F. Padovan 30801da177e4SLinus Torvalds if (conn) { 30816ed58ec5SVille Tervo int cnt, q; 30826ed58ec5SVille Tervo 30836ed58ec5SVille Tervo switch (conn->type) { 30846ed58ec5SVille Tervo case ACL_LINK: 30856ed58ec5SVille Tervo cnt = hdev->acl_cnt; 30866ed58ec5SVille Tervo break; 30876ed58ec5SVille Tervo case SCO_LINK: 30886ed58ec5SVille Tervo case ESCO_LINK: 30896ed58ec5SVille Tervo cnt = hdev->sco_cnt; 30906ed58ec5SVille Tervo break; 30916ed58ec5SVille Tervo case LE_LINK: 30926ed58ec5SVille Tervo cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 30936ed58ec5SVille Tervo break; 30946ed58ec5SVille Tervo default: 30956ed58ec5SVille Tervo cnt = 0; 30966ed58ec5SVille Tervo BT_ERR("Unknown link type"); 30976ed58ec5SVille Tervo } 30986ed58ec5SVille Tervo 30996ed58ec5SVille Tervo q = cnt / num; 31001da177e4SLinus Torvalds *quote = q ? q : 1; 31011da177e4SLinus Torvalds } else 31021da177e4SLinus Torvalds *quote = 0; 31031da177e4SLinus Torvalds 31041da177e4SLinus Torvalds BT_DBG("conn %p quote %d", conn, *quote); 31051da177e4SLinus Torvalds return conn; 31061da177e4SLinus Torvalds } 31071da177e4SLinus Torvalds 31086039aa73SGustavo Padovan static void hci_link_tx_to(struct hci_dev *hdev, __u8 type) 31091da177e4SLinus Torvalds { 31101da177e4SLinus Torvalds struct hci_conn_hash *h = &hdev->conn_hash; 31111da177e4SLinus Torvalds struct hci_conn *c; 31121da177e4SLinus Torvalds 3113bae1f5d9SVille Tervo BT_ERR("%s link tx timeout", hdev->name); 31141da177e4SLinus Torvalds 3115bf4c6325SGustavo F. Padovan rcu_read_lock(); 3116bf4c6325SGustavo F. Padovan 31171da177e4SLinus Torvalds /* Kill stalled connections */ 3118bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(c, &h->list, list) { 3119bae1f5d9SVille Tervo if (c->type == type && c->sent) { 31206ed93dc6SAndrei Emeltchenko BT_ERR("%s killing stalled connection %pMR", 31216ed93dc6SAndrei Emeltchenko hdev->name, &c->dst); 3122bed71748SAndre Guedes hci_disconnect(c, HCI_ERROR_REMOTE_USER_TERM); 31231da177e4SLinus Torvalds } 31241da177e4SLinus Torvalds } 3125bf4c6325SGustavo F. Padovan 3126bf4c6325SGustavo F. Padovan rcu_read_unlock(); 31271da177e4SLinus Torvalds } 31281da177e4SLinus Torvalds 31296039aa73SGustavo Padovan static struct hci_chan *hci_chan_sent(struct hci_dev *hdev, __u8 type, 313073d80debSLuiz Augusto von Dentz int *quote) 313173d80debSLuiz Augusto von Dentz { 313273d80debSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 313373d80debSLuiz Augusto von Dentz struct hci_chan *chan = NULL; 3134abc5de8fSMikel Astiz unsigned int num = 0, min = ~0, cur_prio = 0; 313573d80debSLuiz Augusto von Dentz struct hci_conn *conn; 313673d80debSLuiz Augusto von Dentz int cnt, q, conn_num = 0; 313773d80debSLuiz Augusto von Dentz 313873d80debSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 313973d80debSLuiz Augusto von Dentz 3140bf4c6325SGustavo F. Padovan rcu_read_lock(); 3141bf4c6325SGustavo F. Padovan 3142bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 314373d80debSLuiz Augusto von Dentz struct hci_chan *tmp; 314473d80debSLuiz Augusto von Dentz 314573d80debSLuiz Augusto von Dentz if (conn->type != type) 314673d80debSLuiz Augusto von Dentz continue; 314773d80debSLuiz Augusto von Dentz 314873d80debSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 314973d80debSLuiz Augusto von Dentz continue; 315073d80debSLuiz Augusto von Dentz 315173d80debSLuiz Augusto von Dentz conn_num++; 315273d80debSLuiz Augusto von Dentz 31538192edefSGustavo F. Padovan list_for_each_entry_rcu(tmp, &conn->chan_list, list) { 315473d80debSLuiz Augusto von Dentz struct sk_buff *skb; 315573d80debSLuiz Augusto von Dentz 315673d80debSLuiz Augusto von Dentz if (skb_queue_empty(&tmp->data_q)) 315773d80debSLuiz Augusto von Dentz continue; 315873d80debSLuiz Augusto von Dentz 315973d80debSLuiz Augusto von Dentz skb = skb_peek(&tmp->data_q); 316073d80debSLuiz Augusto von Dentz if (skb->priority < cur_prio) 316173d80debSLuiz Augusto von Dentz continue; 316273d80debSLuiz Augusto von Dentz 316373d80debSLuiz Augusto von Dentz if (skb->priority > cur_prio) { 316473d80debSLuiz Augusto von Dentz num = 0; 316573d80debSLuiz Augusto von Dentz min = ~0; 316673d80debSLuiz Augusto von Dentz cur_prio = skb->priority; 316773d80debSLuiz Augusto von Dentz } 316873d80debSLuiz Augusto von Dentz 316973d80debSLuiz Augusto von Dentz num++; 317073d80debSLuiz Augusto von Dentz 317173d80debSLuiz Augusto von Dentz if (conn->sent < min) { 317273d80debSLuiz Augusto von Dentz min = conn->sent; 317373d80debSLuiz Augusto von Dentz chan = tmp; 317473d80debSLuiz Augusto von Dentz } 317573d80debSLuiz Augusto von Dentz } 317673d80debSLuiz Augusto von Dentz 317773d80debSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == conn_num) 317873d80debSLuiz Augusto von Dentz break; 317973d80debSLuiz Augusto von Dentz } 318073d80debSLuiz Augusto von Dentz 3181bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3182bf4c6325SGustavo F. Padovan 318373d80debSLuiz Augusto von Dentz if (!chan) 318473d80debSLuiz Augusto von Dentz return NULL; 318573d80debSLuiz Augusto von Dentz 318673d80debSLuiz Augusto von Dentz switch (chan->conn->type) { 318773d80debSLuiz Augusto von Dentz case ACL_LINK: 318873d80debSLuiz Augusto von Dentz cnt = hdev->acl_cnt; 318973d80debSLuiz Augusto von Dentz break; 3190bd1eb66bSAndrei Emeltchenko case AMP_LINK: 3191bd1eb66bSAndrei Emeltchenko cnt = hdev->block_cnt; 3192bd1eb66bSAndrei Emeltchenko break; 319373d80debSLuiz Augusto von Dentz case SCO_LINK: 319473d80debSLuiz Augusto von Dentz case ESCO_LINK: 319573d80debSLuiz Augusto von Dentz cnt = hdev->sco_cnt; 319673d80debSLuiz Augusto von Dentz break; 319773d80debSLuiz Augusto von Dentz case LE_LINK: 319873d80debSLuiz Augusto von Dentz cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt; 319973d80debSLuiz Augusto von Dentz break; 320073d80debSLuiz Augusto von Dentz default: 320173d80debSLuiz Augusto von Dentz cnt = 0; 320273d80debSLuiz Augusto von Dentz BT_ERR("Unknown link type"); 320373d80debSLuiz Augusto von Dentz } 320473d80debSLuiz Augusto von Dentz 320573d80debSLuiz Augusto von Dentz q = cnt / num; 320673d80debSLuiz Augusto von Dentz *quote = q ? q : 1; 320773d80debSLuiz Augusto von Dentz BT_DBG("chan %p quote %d", chan, *quote); 320873d80debSLuiz Augusto von Dentz return chan; 320973d80debSLuiz Augusto von Dentz } 321073d80debSLuiz Augusto von Dentz 321102b20f0bSLuiz Augusto von Dentz static void hci_prio_recalculate(struct hci_dev *hdev, __u8 type) 321202b20f0bSLuiz Augusto von Dentz { 321302b20f0bSLuiz Augusto von Dentz struct hci_conn_hash *h = &hdev->conn_hash; 321402b20f0bSLuiz Augusto von Dentz struct hci_conn *conn; 321502b20f0bSLuiz Augusto von Dentz int num = 0; 321602b20f0bSLuiz Augusto von Dentz 321702b20f0bSLuiz Augusto von Dentz BT_DBG("%s", hdev->name); 321802b20f0bSLuiz Augusto von Dentz 3219bf4c6325SGustavo F. Padovan rcu_read_lock(); 3220bf4c6325SGustavo F. Padovan 3221bf4c6325SGustavo F. Padovan list_for_each_entry_rcu(conn, &h->list, list) { 322202b20f0bSLuiz Augusto von Dentz struct hci_chan *chan; 322302b20f0bSLuiz Augusto von Dentz 322402b20f0bSLuiz Augusto von Dentz if (conn->type != type) 322502b20f0bSLuiz Augusto von Dentz continue; 322602b20f0bSLuiz Augusto von Dentz 322702b20f0bSLuiz Augusto von Dentz if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG) 322802b20f0bSLuiz Augusto von Dentz continue; 322902b20f0bSLuiz Augusto von Dentz 323002b20f0bSLuiz Augusto von Dentz num++; 323102b20f0bSLuiz Augusto von Dentz 32328192edefSGustavo F. Padovan list_for_each_entry_rcu(chan, &conn->chan_list, list) { 323302b20f0bSLuiz Augusto von Dentz struct sk_buff *skb; 323402b20f0bSLuiz Augusto von Dentz 323502b20f0bSLuiz Augusto von Dentz if (chan->sent) { 323602b20f0bSLuiz Augusto von Dentz chan->sent = 0; 323702b20f0bSLuiz Augusto von Dentz continue; 323802b20f0bSLuiz Augusto von Dentz } 323902b20f0bSLuiz Augusto von Dentz 324002b20f0bSLuiz Augusto von Dentz if (skb_queue_empty(&chan->data_q)) 324102b20f0bSLuiz Augusto von Dentz continue; 324202b20f0bSLuiz Augusto von Dentz 324302b20f0bSLuiz Augusto von Dentz skb = skb_peek(&chan->data_q); 324402b20f0bSLuiz Augusto von Dentz if (skb->priority >= HCI_PRIO_MAX - 1) 324502b20f0bSLuiz Augusto von Dentz continue; 324602b20f0bSLuiz Augusto von Dentz 324702b20f0bSLuiz Augusto von Dentz skb->priority = HCI_PRIO_MAX - 1; 324802b20f0bSLuiz Augusto von Dentz 324902b20f0bSLuiz Augusto von Dentz BT_DBG("chan %p skb %p promoted to %d", chan, skb, 325002b20f0bSLuiz Augusto von Dentz skb->priority); 325102b20f0bSLuiz Augusto von Dentz } 325202b20f0bSLuiz Augusto von Dentz 325302b20f0bSLuiz Augusto von Dentz if (hci_conn_num(hdev, type) == num) 325402b20f0bSLuiz Augusto von Dentz break; 325502b20f0bSLuiz Augusto von Dentz } 3256bf4c6325SGustavo F. Padovan 3257bf4c6325SGustavo F. Padovan rcu_read_unlock(); 3258bf4c6325SGustavo F. Padovan 325902b20f0bSLuiz Augusto von Dentz } 326002b20f0bSLuiz Augusto von Dentz 3261b71d385aSAndrei Emeltchenko static inline int __get_blocks(struct hci_dev *hdev, struct sk_buff *skb) 3262b71d385aSAndrei Emeltchenko { 3263b71d385aSAndrei Emeltchenko /* Calculate count of blocks used by this packet */ 3264b71d385aSAndrei Emeltchenko return DIV_ROUND_UP(skb->len - HCI_ACL_HDR_SIZE, hdev->block_len); 3265b71d385aSAndrei Emeltchenko } 3266b71d385aSAndrei Emeltchenko 32676039aa73SGustavo Padovan static void __check_timeout(struct hci_dev *hdev, unsigned int cnt) 32681da177e4SLinus Torvalds { 32691da177e4SLinus Torvalds if (!test_bit(HCI_RAW, &hdev->flags)) { 32701da177e4SLinus Torvalds /* ACL tx timeout must be longer than maximum 32711da177e4SLinus Torvalds * link supervision timeout (40.9 seconds) */ 327263d2bc1bSAndrei Emeltchenko if (!cnt && time_after(jiffies, hdev->acl_last_tx + 32735f246e89SAndrei Emeltchenko HCI_ACL_TX_TIMEOUT)) 3274bae1f5d9SVille Tervo hci_link_tx_to(hdev, ACL_LINK); 32751da177e4SLinus Torvalds } 327663d2bc1bSAndrei Emeltchenko } 32771da177e4SLinus Torvalds 32786039aa73SGustavo Padovan static void hci_sched_acl_pkt(struct hci_dev *hdev) 327963d2bc1bSAndrei Emeltchenko { 328063d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->acl_cnt; 328163d2bc1bSAndrei Emeltchenko struct hci_chan *chan; 328263d2bc1bSAndrei Emeltchenko struct sk_buff *skb; 328363d2bc1bSAndrei Emeltchenko int quote; 328463d2bc1bSAndrei Emeltchenko 328563d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 328604837f64SMarcel Holtmann 328773d80debSLuiz Augusto von Dentz while (hdev->acl_cnt && 328873d80debSLuiz Augusto von Dentz (chan = hci_chan_sent(hdev, ACL_LINK, "e))) { 3289ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3290ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 329173d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 329273d80debSLuiz Augusto von Dentz skb->len, skb->priority); 329373d80debSLuiz Augusto von Dentz 3294ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3295ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3296ec1cce24SLuiz Augusto von Dentz break; 3297ec1cce24SLuiz Augusto von Dentz 3298ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3299ec1cce24SLuiz Augusto von Dentz 330073d80debSLuiz Augusto von Dentz hci_conn_enter_active_mode(chan->conn, 330173d80debSLuiz Augusto von Dentz bt_cb(skb)->force_active); 330204837f64SMarcel Holtmann 330357d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 33041da177e4SLinus Torvalds hdev->acl_last_tx = jiffies; 33051da177e4SLinus Torvalds 33061da177e4SLinus Torvalds hdev->acl_cnt--; 330773d80debSLuiz Augusto von Dentz chan->sent++; 330873d80debSLuiz Augusto von Dentz chan->conn->sent++; 33091da177e4SLinus Torvalds } 33101da177e4SLinus Torvalds } 331102b20f0bSLuiz Augusto von Dentz 331202b20f0bSLuiz Augusto von Dentz if (cnt != hdev->acl_cnt) 331302b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, ACL_LINK); 33141da177e4SLinus Torvalds } 33151da177e4SLinus Torvalds 33166039aa73SGustavo Padovan static void hci_sched_acl_blk(struct hci_dev *hdev) 3317b71d385aSAndrei Emeltchenko { 331863d2bc1bSAndrei Emeltchenko unsigned int cnt = hdev->block_cnt; 3319b71d385aSAndrei Emeltchenko struct hci_chan *chan; 3320b71d385aSAndrei Emeltchenko struct sk_buff *skb; 3321b71d385aSAndrei Emeltchenko int quote; 3322bd1eb66bSAndrei Emeltchenko u8 type; 3323b71d385aSAndrei Emeltchenko 332463d2bc1bSAndrei Emeltchenko __check_timeout(hdev, cnt); 3325b71d385aSAndrei Emeltchenko 3326bd1eb66bSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3327bd1eb66bSAndrei Emeltchenko 3328bd1eb66bSAndrei Emeltchenko if (hdev->dev_type == HCI_AMP) 3329bd1eb66bSAndrei Emeltchenko type = AMP_LINK; 3330bd1eb66bSAndrei Emeltchenko else 3331bd1eb66bSAndrei Emeltchenko type = ACL_LINK; 3332bd1eb66bSAndrei Emeltchenko 3333b71d385aSAndrei Emeltchenko while (hdev->block_cnt > 0 && 3334bd1eb66bSAndrei Emeltchenko (chan = hci_chan_sent(hdev, type, "e))) { 3335b71d385aSAndrei Emeltchenko u32 priority = (skb_peek(&chan->data_q))->priority; 3336b71d385aSAndrei Emeltchenko while (quote > 0 && (skb = skb_peek(&chan->data_q))) { 3337b71d385aSAndrei Emeltchenko int blocks; 3338b71d385aSAndrei Emeltchenko 3339b71d385aSAndrei Emeltchenko BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 3340b71d385aSAndrei Emeltchenko skb->len, skb->priority); 3341b71d385aSAndrei Emeltchenko 3342b71d385aSAndrei Emeltchenko /* Stop if priority has changed */ 3343b71d385aSAndrei Emeltchenko if (skb->priority < priority) 3344b71d385aSAndrei Emeltchenko break; 3345b71d385aSAndrei Emeltchenko 3346b71d385aSAndrei Emeltchenko skb = skb_dequeue(&chan->data_q); 3347b71d385aSAndrei Emeltchenko 3348b71d385aSAndrei Emeltchenko blocks = __get_blocks(hdev, skb); 3349b71d385aSAndrei Emeltchenko if (blocks > hdev->block_cnt) 3350b71d385aSAndrei Emeltchenko return; 3351b71d385aSAndrei Emeltchenko 3352b71d385aSAndrei Emeltchenko hci_conn_enter_active_mode(chan->conn, 3353b71d385aSAndrei Emeltchenko bt_cb(skb)->force_active); 3354b71d385aSAndrei Emeltchenko 335557d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3356b71d385aSAndrei Emeltchenko hdev->acl_last_tx = jiffies; 3357b71d385aSAndrei Emeltchenko 3358b71d385aSAndrei Emeltchenko hdev->block_cnt -= blocks; 3359b71d385aSAndrei Emeltchenko quote -= blocks; 3360b71d385aSAndrei Emeltchenko 3361b71d385aSAndrei Emeltchenko chan->sent += blocks; 3362b71d385aSAndrei Emeltchenko chan->conn->sent += blocks; 3363b71d385aSAndrei Emeltchenko } 3364b71d385aSAndrei Emeltchenko } 3365b71d385aSAndrei Emeltchenko 3366b71d385aSAndrei Emeltchenko if (cnt != hdev->block_cnt) 3367bd1eb66bSAndrei Emeltchenko hci_prio_recalculate(hdev, type); 3368b71d385aSAndrei Emeltchenko } 3369b71d385aSAndrei Emeltchenko 33706039aa73SGustavo Padovan static void hci_sched_acl(struct hci_dev *hdev) 3371b71d385aSAndrei Emeltchenko { 3372b71d385aSAndrei Emeltchenko BT_DBG("%s", hdev->name); 3373b71d385aSAndrei Emeltchenko 3374bd1eb66bSAndrei Emeltchenko /* No ACL link over BR/EDR controller */ 3375bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, ACL_LINK) && hdev->dev_type == HCI_BREDR) 3376bd1eb66bSAndrei Emeltchenko return; 3377bd1eb66bSAndrei Emeltchenko 3378bd1eb66bSAndrei Emeltchenko /* No AMP link over AMP controller */ 3379bd1eb66bSAndrei Emeltchenko if (!hci_conn_num(hdev, AMP_LINK) && hdev->dev_type == HCI_AMP) 3380b71d385aSAndrei Emeltchenko return; 3381b71d385aSAndrei Emeltchenko 3382b71d385aSAndrei Emeltchenko switch (hdev->flow_ctl_mode) { 3383b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_PACKET_BASED: 3384b71d385aSAndrei Emeltchenko hci_sched_acl_pkt(hdev); 3385b71d385aSAndrei Emeltchenko break; 3386b71d385aSAndrei Emeltchenko 3387b71d385aSAndrei Emeltchenko case HCI_FLOW_CTL_MODE_BLOCK_BASED: 3388b71d385aSAndrei Emeltchenko hci_sched_acl_blk(hdev); 3389b71d385aSAndrei Emeltchenko break; 3390b71d385aSAndrei Emeltchenko } 3391b71d385aSAndrei Emeltchenko } 3392b71d385aSAndrei Emeltchenko 33931da177e4SLinus Torvalds /* Schedule SCO */ 33946039aa73SGustavo Padovan static void hci_sched_sco(struct hci_dev *hdev) 33951da177e4SLinus Torvalds { 33961da177e4SLinus Torvalds struct hci_conn *conn; 33971da177e4SLinus Torvalds struct sk_buff *skb; 33981da177e4SLinus Torvalds int quote; 33991da177e4SLinus Torvalds 34001da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 34011da177e4SLinus Torvalds 340252087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, SCO_LINK)) 340352087a79SLuiz Augusto von Dentz return; 340452087a79SLuiz Augusto von Dentz 34051da177e4SLinus Torvalds while (hdev->sco_cnt && (conn = hci_low_sent(hdev, SCO_LINK, "e))) { 34061da177e4SLinus Torvalds while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 34071da177e4SLinus Torvalds BT_DBG("skb %p len %d", skb, skb->len); 340857d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 34091da177e4SLinus Torvalds 34101da177e4SLinus Torvalds conn->sent++; 34111da177e4SLinus Torvalds if (conn->sent == ~0) 34121da177e4SLinus Torvalds conn->sent = 0; 34131da177e4SLinus Torvalds } 34141da177e4SLinus Torvalds } 34151da177e4SLinus Torvalds } 34161da177e4SLinus Torvalds 34176039aa73SGustavo Padovan static void hci_sched_esco(struct hci_dev *hdev) 3418b6a0dc82SMarcel Holtmann { 3419b6a0dc82SMarcel Holtmann struct hci_conn *conn; 3420b6a0dc82SMarcel Holtmann struct sk_buff *skb; 3421b6a0dc82SMarcel Holtmann int quote; 3422b6a0dc82SMarcel Holtmann 3423b6a0dc82SMarcel Holtmann BT_DBG("%s", hdev->name); 3424b6a0dc82SMarcel Holtmann 342552087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, ESCO_LINK)) 342652087a79SLuiz Augusto von Dentz return; 342752087a79SLuiz Augusto von Dentz 34288fc9ced3SGustavo Padovan while (hdev->sco_cnt && (conn = hci_low_sent(hdev, ESCO_LINK, 34298fc9ced3SGustavo Padovan "e))) { 3430b6a0dc82SMarcel Holtmann while (quote-- && (skb = skb_dequeue(&conn->data_q))) { 3431b6a0dc82SMarcel Holtmann BT_DBG("skb %p len %d", skb, skb->len); 343257d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 3433b6a0dc82SMarcel Holtmann 3434b6a0dc82SMarcel Holtmann conn->sent++; 3435b6a0dc82SMarcel Holtmann if (conn->sent == ~0) 3436b6a0dc82SMarcel Holtmann conn->sent = 0; 3437b6a0dc82SMarcel Holtmann } 3438b6a0dc82SMarcel Holtmann } 3439b6a0dc82SMarcel Holtmann } 3440b6a0dc82SMarcel Holtmann 34416039aa73SGustavo Padovan static void hci_sched_le(struct hci_dev *hdev) 34426ed58ec5SVille Tervo { 344373d80debSLuiz Augusto von Dentz struct hci_chan *chan; 34446ed58ec5SVille Tervo struct sk_buff *skb; 344502b20f0bSLuiz Augusto von Dentz int quote, cnt, tmp; 34466ed58ec5SVille Tervo 34476ed58ec5SVille Tervo BT_DBG("%s", hdev->name); 34486ed58ec5SVille Tervo 344952087a79SLuiz Augusto von Dentz if (!hci_conn_num(hdev, LE_LINK)) 345052087a79SLuiz Augusto von Dentz return; 345152087a79SLuiz Augusto von Dentz 34526ed58ec5SVille Tervo if (!test_bit(HCI_RAW, &hdev->flags)) { 34536ed58ec5SVille Tervo /* LE tx timeout must be longer than maximum 34546ed58ec5SVille Tervo * link supervision timeout (40.9 seconds) */ 3455bae1f5d9SVille Tervo if (!hdev->le_cnt && hdev->le_pkts && 34566ed58ec5SVille Tervo time_after(jiffies, hdev->le_last_tx + HZ * 45)) 3457bae1f5d9SVille Tervo hci_link_tx_to(hdev, LE_LINK); 34586ed58ec5SVille Tervo } 34596ed58ec5SVille Tervo 34606ed58ec5SVille Tervo cnt = hdev->le_pkts ? hdev->le_cnt : hdev->acl_cnt; 346102b20f0bSLuiz Augusto von Dentz tmp = cnt; 346273d80debSLuiz Augusto von Dentz while (cnt && (chan = hci_chan_sent(hdev, LE_LINK, "e))) { 3463ec1cce24SLuiz Augusto von Dentz u32 priority = (skb_peek(&chan->data_q))->priority; 3464ec1cce24SLuiz Augusto von Dentz while (quote-- && (skb = skb_peek(&chan->data_q))) { 346573d80debSLuiz Augusto von Dentz BT_DBG("chan %p skb %p len %d priority %u", chan, skb, 346673d80debSLuiz Augusto von Dentz skb->len, skb->priority); 34676ed58ec5SVille Tervo 3468ec1cce24SLuiz Augusto von Dentz /* Stop if priority has changed */ 3469ec1cce24SLuiz Augusto von Dentz if (skb->priority < priority) 3470ec1cce24SLuiz Augusto von Dentz break; 3471ec1cce24SLuiz Augusto von Dentz 3472ec1cce24SLuiz Augusto von Dentz skb = skb_dequeue(&chan->data_q); 3473ec1cce24SLuiz Augusto von Dentz 347457d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 34756ed58ec5SVille Tervo hdev->le_last_tx = jiffies; 34766ed58ec5SVille Tervo 34776ed58ec5SVille Tervo cnt--; 347873d80debSLuiz Augusto von Dentz chan->sent++; 347973d80debSLuiz Augusto von Dentz chan->conn->sent++; 34806ed58ec5SVille Tervo } 34816ed58ec5SVille Tervo } 348273d80debSLuiz Augusto von Dentz 34836ed58ec5SVille Tervo if (hdev->le_pkts) 34846ed58ec5SVille Tervo hdev->le_cnt = cnt; 34856ed58ec5SVille Tervo else 34866ed58ec5SVille Tervo hdev->acl_cnt = cnt; 348702b20f0bSLuiz Augusto von Dentz 348802b20f0bSLuiz Augusto von Dentz if (cnt != tmp) 348902b20f0bSLuiz Augusto von Dentz hci_prio_recalculate(hdev, LE_LINK); 34906ed58ec5SVille Tervo } 34916ed58ec5SVille Tervo 34923eff45eaSGustavo F. Padovan static void hci_tx_work(struct work_struct *work) 34931da177e4SLinus Torvalds { 34943eff45eaSGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, tx_work); 34951da177e4SLinus Torvalds struct sk_buff *skb; 34961da177e4SLinus Torvalds 34976ed58ec5SVille Tervo BT_DBG("%s acl %d sco %d le %d", hdev->name, hdev->acl_cnt, 34986ed58ec5SVille Tervo hdev->sco_cnt, hdev->le_cnt); 34991da177e4SLinus Torvalds 350052de599eSMarcel Holtmann if (!test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 35011da177e4SLinus Torvalds /* Schedule queues and send stuff to HCI driver */ 35021da177e4SLinus Torvalds hci_sched_acl(hdev); 35031da177e4SLinus Torvalds hci_sched_sco(hdev); 3504b6a0dc82SMarcel Holtmann hci_sched_esco(hdev); 35056ed58ec5SVille Tervo hci_sched_le(hdev); 350652de599eSMarcel Holtmann } 35076ed58ec5SVille Tervo 35081da177e4SLinus Torvalds /* Send next queued raw (unknown type) packet */ 35091da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->raw_q))) 351057d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 35111da177e4SLinus Torvalds } 35121da177e4SLinus Torvalds 351325985edcSLucas De Marchi /* ----- HCI RX task (incoming data processing) ----- */ 35141da177e4SLinus Torvalds 35151da177e4SLinus Torvalds /* ACL data packet */ 35166039aa73SGustavo Padovan static void hci_acldata_packet(struct hci_dev *hdev, struct sk_buff *skb) 35171da177e4SLinus Torvalds { 35181da177e4SLinus Torvalds struct hci_acl_hdr *hdr = (void *) skb->data; 35191da177e4SLinus Torvalds struct hci_conn *conn; 35201da177e4SLinus Torvalds __u16 handle, flags; 35211da177e4SLinus Torvalds 35221da177e4SLinus Torvalds skb_pull(skb, HCI_ACL_HDR_SIZE); 35231da177e4SLinus Torvalds 35241da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 35251da177e4SLinus Torvalds flags = hci_flags(handle); 35261da177e4SLinus Torvalds handle = hci_handle(handle); 35271da177e4SLinus Torvalds 3528f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x flags 0x%4.4x", hdev->name, skb->len, 3529a8c5fb1aSGustavo Padovan handle, flags); 35301da177e4SLinus Torvalds 35311da177e4SLinus Torvalds hdev->stat.acl_rx++; 35321da177e4SLinus Torvalds 35331da177e4SLinus Torvalds hci_dev_lock(hdev); 35341da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 35351da177e4SLinus Torvalds hci_dev_unlock(hdev); 35361da177e4SLinus Torvalds 35371da177e4SLinus Torvalds if (conn) { 353865983fc7SMat Martineau hci_conn_enter_active_mode(conn, BT_POWER_FORCE_ACTIVE_OFF); 353904837f64SMarcel Holtmann 35401da177e4SLinus Torvalds /* Send to upper protocol */ 3541686ebf28SUlisses Furquim l2cap_recv_acldata(conn, skb, flags); 35421da177e4SLinus Torvalds return; 35431da177e4SLinus Torvalds } else { 35441da177e4SLinus Torvalds BT_ERR("%s ACL packet for unknown connection handle %d", 35451da177e4SLinus Torvalds hdev->name, handle); 35461da177e4SLinus Torvalds } 35471da177e4SLinus Torvalds 35481da177e4SLinus Torvalds kfree_skb(skb); 35491da177e4SLinus Torvalds } 35501da177e4SLinus Torvalds 35511da177e4SLinus Torvalds /* SCO data packet */ 35526039aa73SGustavo Padovan static void hci_scodata_packet(struct hci_dev *hdev, struct sk_buff *skb) 35531da177e4SLinus Torvalds { 35541da177e4SLinus Torvalds struct hci_sco_hdr *hdr = (void *) skb->data; 35551da177e4SLinus Torvalds struct hci_conn *conn; 35561da177e4SLinus Torvalds __u16 handle; 35571da177e4SLinus Torvalds 35581da177e4SLinus Torvalds skb_pull(skb, HCI_SCO_HDR_SIZE); 35591da177e4SLinus Torvalds 35601da177e4SLinus Torvalds handle = __le16_to_cpu(hdr->handle); 35611da177e4SLinus Torvalds 3562f0e09510SAndrei Emeltchenko BT_DBG("%s len %d handle 0x%4.4x", hdev->name, skb->len, handle); 35631da177e4SLinus Torvalds 35641da177e4SLinus Torvalds hdev->stat.sco_rx++; 35651da177e4SLinus Torvalds 35661da177e4SLinus Torvalds hci_dev_lock(hdev); 35671da177e4SLinus Torvalds conn = hci_conn_hash_lookup_handle(hdev, handle); 35681da177e4SLinus Torvalds hci_dev_unlock(hdev); 35691da177e4SLinus Torvalds 35701da177e4SLinus Torvalds if (conn) { 35711da177e4SLinus Torvalds /* Send to upper protocol */ 3572686ebf28SUlisses Furquim sco_recv_scodata(conn, skb); 35731da177e4SLinus Torvalds return; 35741da177e4SLinus Torvalds } else { 35751da177e4SLinus Torvalds BT_ERR("%s SCO packet for unknown connection handle %d", 35761da177e4SLinus Torvalds hdev->name, handle); 35771da177e4SLinus Torvalds } 35781da177e4SLinus Torvalds 35791da177e4SLinus Torvalds kfree_skb(skb); 35801da177e4SLinus Torvalds } 35811da177e4SLinus Torvalds 35829238f36aSJohan Hedberg static bool hci_req_is_complete(struct hci_dev *hdev) 35839238f36aSJohan Hedberg { 35849238f36aSJohan Hedberg struct sk_buff *skb; 35859238f36aSJohan Hedberg 35869238f36aSJohan Hedberg skb = skb_peek(&hdev->cmd_q); 35879238f36aSJohan Hedberg if (!skb) 35889238f36aSJohan Hedberg return true; 35899238f36aSJohan Hedberg 35909238f36aSJohan Hedberg return bt_cb(skb)->req.start; 35919238f36aSJohan Hedberg } 35929238f36aSJohan Hedberg 359342c6b129SJohan Hedberg static void hci_resend_last(struct hci_dev *hdev) 359442c6b129SJohan Hedberg { 359542c6b129SJohan Hedberg struct hci_command_hdr *sent; 359642c6b129SJohan Hedberg struct sk_buff *skb; 359742c6b129SJohan Hedberg u16 opcode; 359842c6b129SJohan Hedberg 359942c6b129SJohan Hedberg if (!hdev->sent_cmd) 360042c6b129SJohan Hedberg return; 360142c6b129SJohan Hedberg 360242c6b129SJohan Hedberg sent = (void *) hdev->sent_cmd->data; 360342c6b129SJohan Hedberg opcode = __le16_to_cpu(sent->opcode); 360442c6b129SJohan Hedberg if (opcode == HCI_OP_RESET) 360542c6b129SJohan Hedberg return; 360642c6b129SJohan Hedberg 360742c6b129SJohan Hedberg skb = skb_clone(hdev->sent_cmd, GFP_KERNEL); 360842c6b129SJohan Hedberg if (!skb) 360942c6b129SJohan Hedberg return; 361042c6b129SJohan Hedberg 361142c6b129SJohan Hedberg skb_queue_head(&hdev->cmd_q, skb); 361242c6b129SJohan Hedberg queue_work(hdev->workqueue, &hdev->cmd_work); 361342c6b129SJohan Hedberg } 361442c6b129SJohan Hedberg 36159238f36aSJohan Hedberg void hci_req_cmd_complete(struct hci_dev *hdev, u16 opcode, u8 status) 36169238f36aSJohan Hedberg { 36179238f36aSJohan Hedberg hci_req_complete_t req_complete = NULL; 36189238f36aSJohan Hedberg struct sk_buff *skb; 36199238f36aSJohan Hedberg unsigned long flags; 36209238f36aSJohan Hedberg 36219238f36aSJohan Hedberg BT_DBG("opcode 0x%04x status 0x%02x", opcode, status); 36229238f36aSJohan Hedberg 362342c6b129SJohan Hedberg /* If the completed command doesn't match the last one that was 362442c6b129SJohan Hedberg * sent we need to do special handling of it. 36259238f36aSJohan Hedberg */ 362642c6b129SJohan Hedberg if (!hci_sent_cmd_data(hdev, opcode)) { 362742c6b129SJohan Hedberg /* Some CSR based controllers generate a spontaneous 362842c6b129SJohan Hedberg * reset complete event during init and any pending 362942c6b129SJohan Hedberg * command will never be completed. In such a case we 363042c6b129SJohan Hedberg * need to resend whatever was the last sent 363142c6b129SJohan Hedberg * command. 363242c6b129SJohan Hedberg */ 363342c6b129SJohan Hedberg if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET) 363442c6b129SJohan Hedberg hci_resend_last(hdev); 363542c6b129SJohan Hedberg 36369238f36aSJohan Hedberg return; 363742c6b129SJohan Hedberg } 36389238f36aSJohan Hedberg 36399238f36aSJohan Hedberg /* If the command succeeded and there's still more commands in 36409238f36aSJohan Hedberg * this request the request is not yet complete. 36419238f36aSJohan Hedberg */ 36429238f36aSJohan Hedberg if (!status && !hci_req_is_complete(hdev)) 36439238f36aSJohan Hedberg return; 36449238f36aSJohan Hedberg 36459238f36aSJohan Hedberg /* If this was the last command in a request the complete 36469238f36aSJohan Hedberg * callback would be found in hdev->sent_cmd instead of the 36479238f36aSJohan Hedberg * command queue (hdev->cmd_q). 36489238f36aSJohan Hedberg */ 36499238f36aSJohan Hedberg if (hdev->sent_cmd) { 36509238f36aSJohan Hedberg req_complete = bt_cb(hdev->sent_cmd)->req.complete; 365153e21fbcSJohan Hedberg 365253e21fbcSJohan Hedberg if (req_complete) { 365353e21fbcSJohan Hedberg /* We must set the complete callback to NULL to 365453e21fbcSJohan Hedberg * avoid calling the callback more than once if 365553e21fbcSJohan Hedberg * this function gets called again. 365653e21fbcSJohan Hedberg */ 365753e21fbcSJohan Hedberg bt_cb(hdev->sent_cmd)->req.complete = NULL; 365853e21fbcSJohan Hedberg 36599238f36aSJohan Hedberg goto call_complete; 36609238f36aSJohan Hedberg } 366153e21fbcSJohan Hedberg } 36629238f36aSJohan Hedberg 36639238f36aSJohan Hedberg /* Remove all pending commands belonging to this request */ 36649238f36aSJohan Hedberg spin_lock_irqsave(&hdev->cmd_q.lock, flags); 36659238f36aSJohan Hedberg while ((skb = __skb_dequeue(&hdev->cmd_q))) { 36669238f36aSJohan Hedberg if (bt_cb(skb)->req.start) { 36679238f36aSJohan Hedberg __skb_queue_head(&hdev->cmd_q, skb); 36689238f36aSJohan Hedberg break; 36699238f36aSJohan Hedberg } 36709238f36aSJohan Hedberg 36719238f36aSJohan Hedberg req_complete = bt_cb(skb)->req.complete; 36729238f36aSJohan Hedberg kfree_skb(skb); 36739238f36aSJohan Hedberg } 36749238f36aSJohan Hedberg spin_unlock_irqrestore(&hdev->cmd_q.lock, flags); 36759238f36aSJohan Hedberg 36769238f36aSJohan Hedberg call_complete: 36779238f36aSJohan Hedberg if (req_complete) 36789238f36aSJohan Hedberg req_complete(hdev, status); 36799238f36aSJohan Hedberg } 36809238f36aSJohan Hedberg 3681b78752ccSMarcel Holtmann static void hci_rx_work(struct work_struct *work) 36821da177e4SLinus Torvalds { 3683b78752ccSMarcel Holtmann struct hci_dev *hdev = container_of(work, struct hci_dev, rx_work); 36841da177e4SLinus Torvalds struct sk_buff *skb; 36851da177e4SLinus Torvalds 36861da177e4SLinus Torvalds BT_DBG("%s", hdev->name); 36871da177e4SLinus Torvalds 36881da177e4SLinus Torvalds while ((skb = skb_dequeue(&hdev->rx_q))) { 3689cd82e61cSMarcel Holtmann /* Send copy to monitor */ 3690cd82e61cSMarcel Holtmann hci_send_to_monitor(hdev, skb); 3691cd82e61cSMarcel Holtmann 36921da177e4SLinus Torvalds if (atomic_read(&hdev->promisc)) { 36931da177e4SLinus Torvalds /* Send copy to the sockets */ 3694470fe1b5SMarcel Holtmann hci_send_to_sock(hdev, skb); 36951da177e4SLinus Torvalds } 36961da177e4SLinus Torvalds 36970736cfa8SMarcel Holtmann if (test_bit(HCI_RAW, &hdev->flags) || 36980736cfa8SMarcel Holtmann test_bit(HCI_USER_CHANNEL, &hdev->dev_flags)) { 36991da177e4SLinus Torvalds kfree_skb(skb); 37001da177e4SLinus Torvalds continue; 37011da177e4SLinus Torvalds } 37021da177e4SLinus Torvalds 37031da177e4SLinus Torvalds if (test_bit(HCI_INIT, &hdev->flags)) { 37041da177e4SLinus Torvalds /* Don't process data packets in this states. */ 37050d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 37061da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 37071da177e4SLinus Torvalds case HCI_SCODATA_PKT: 37081da177e4SLinus Torvalds kfree_skb(skb); 37091da177e4SLinus Torvalds continue; 37103ff50b79SStephen Hemminger } 37111da177e4SLinus Torvalds } 37121da177e4SLinus Torvalds 37131da177e4SLinus Torvalds /* Process frame */ 37140d48d939SMarcel Holtmann switch (bt_cb(skb)->pkt_type) { 37151da177e4SLinus Torvalds case HCI_EVENT_PKT: 3716b78752ccSMarcel Holtmann BT_DBG("%s Event packet", hdev->name); 37171da177e4SLinus Torvalds hci_event_packet(hdev, skb); 37181da177e4SLinus Torvalds break; 37191da177e4SLinus Torvalds 37201da177e4SLinus Torvalds case HCI_ACLDATA_PKT: 37211da177e4SLinus Torvalds BT_DBG("%s ACL data packet", hdev->name); 37221da177e4SLinus Torvalds hci_acldata_packet(hdev, skb); 37231da177e4SLinus Torvalds break; 37241da177e4SLinus Torvalds 37251da177e4SLinus Torvalds case HCI_SCODATA_PKT: 37261da177e4SLinus Torvalds BT_DBG("%s SCO data packet", hdev->name); 37271da177e4SLinus Torvalds hci_scodata_packet(hdev, skb); 37281da177e4SLinus Torvalds break; 37291da177e4SLinus Torvalds 37301da177e4SLinus Torvalds default: 37311da177e4SLinus Torvalds kfree_skb(skb); 37321da177e4SLinus Torvalds break; 37331da177e4SLinus Torvalds } 37341da177e4SLinus Torvalds } 37351da177e4SLinus Torvalds } 37361da177e4SLinus Torvalds 3737c347b765SGustavo F. Padovan static void hci_cmd_work(struct work_struct *work) 37381da177e4SLinus Torvalds { 3739c347b765SGustavo F. Padovan struct hci_dev *hdev = container_of(work, struct hci_dev, cmd_work); 37401da177e4SLinus Torvalds struct sk_buff *skb; 37411da177e4SLinus Torvalds 37422104786bSAndrei Emeltchenko BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name, 37432104786bSAndrei Emeltchenko atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q)); 37441da177e4SLinus Torvalds 37451da177e4SLinus Torvalds /* Send queued commands */ 37465a08ecceSAndrei Emeltchenko if (atomic_read(&hdev->cmd_cnt)) { 37475a08ecceSAndrei Emeltchenko skb = skb_dequeue(&hdev->cmd_q); 37485a08ecceSAndrei Emeltchenko if (!skb) 37495a08ecceSAndrei Emeltchenko return; 37505a08ecceSAndrei Emeltchenko 37511da177e4SLinus Torvalds kfree_skb(hdev->sent_cmd); 37521da177e4SLinus Torvalds 3753a675d7f1SMarcel Holtmann hdev->sent_cmd = skb_clone(skb, GFP_KERNEL); 375470f23020SAndrei Emeltchenko if (hdev->sent_cmd) { 37551da177e4SLinus Torvalds atomic_dec(&hdev->cmd_cnt); 375657d17d70SMarcel Holtmann hci_send_frame(hdev, skb); 37577bdb8a5cSSzymon Janc if (test_bit(HCI_RESET, &hdev->flags)) 37587bdb8a5cSSzymon Janc del_timer(&hdev->cmd_timer); 37597bdb8a5cSSzymon Janc else 37606bd32326SVille Tervo mod_timer(&hdev->cmd_timer, 37615f246e89SAndrei Emeltchenko jiffies + HCI_CMD_TIMEOUT); 37621da177e4SLinus Torvalds } else { 37631da177e4SLinus Torvalds skb_queue_head(&hdev->cmd_q, skb); 3764c347b765SGustavo F. Padovan queue_work(hdev->workqueue, &hdev->cmd_work); 37651da177e4SLinus Torvalds } 37661da177e4SLinus Torvalds } 37671da177e4SLinus Torvalds } 3768