Lines Matching +full:timing +full:- +full:role
2 BlueZ - Bluetooth protocol stack for Linux
3 Copyright (C) 2000-2001 Qualcomm Incorporated
78 if (d->id == index) {
81 *srcu_index = srcu_read_lock(&d->srcu);
101 srcu_read_unlock(&hdev->srcu, srcu_index);
105 /* ---- Inquiry support ---- */
109 struct discovery_state *discov = &hdev->discovery;
111 switch (discov->state) {
123 int old_state = hdev->discovery.state;
128 hdev->discovery.state = state;
148 bt_dev_dbg(hdev, "state %u -> %u", old_state, state);
153 struct discovery_state *cache = &hdev->discovery;
156 list_for_each_entry_safe(p, n, &cache->all, all) {
157 list_del(&p->all);
161 INIT_LIST_HEAD(&cache->unknown);
162 INIT_LIST_HEAD(&cache->resolve);
168 struct discovery_state *cache = &hdev->discovery;
173 list_for_each_entry(e, &cache->all, all) {
174 if (!bacmp(&e->data.bdaddr, bdaddr))
184 struct discovery_state *cache = &hdev->discovery;
189 list_for_each_entry(e, &cache->unknown, list) {
190 if (!bacmp(&e->data.bdaddr, bdaddr))
201 struct discovery_state *cache = &hdev->discovery;
206 list_for_each_entry(e, &cache->resolve, list) {
207 if (!bacmp(bdaddr, BDADDR_ANY) && e->name_state == state)
209 if (!bacmp(&e->data.bdaddr, bdaddr))
219 struct discovery_state *cache = &hdev->discovery;
220 struct list_head *pos = &cache->resolve;
223 list_del(&ie->list);
225 list_for_each_entry(p, &cache->resolve, list) {
226 if (p->name_state != NAME_PENDING &&
227 abs(p->data.rssi) >= abs(ie->data.rssi))
229 pos = &p->list;
232 list_add(&ie->list, pos);
238 struct discovery_state *cache = &hdev->discovery;
242 BT_DBG("cache %p, %pMR", cache, &data->bdaddr);
244 hci_remove_remote_oob_data(hdev, &data->bdaddr, BDADDR_BREDR);
246 if (!data->ssp_mode)
249 ie = hci_inquiry_cache_lookup(hdev, &data->bdaddr);
251 if (!ie->data.ssp_mode)
254 if (ie->name_state == NAME_NEEDED &&
255 data->rssi != ie->data.rssi) {
256 ie->data.rssi = data->rssi;
270 list_add(&ie->all, &cache->all);
273 ie->name_state = NAME_KNOWN;
275 ie->name_state = NAME_NOT_KNOWN;
276 list_add(&ie->list, &cache->unknown);
280 if (name_known && ie->name_state != NAME_KNOWN &&
281 ie->name_state != NAME_PENDING) {
282 ie->name_state = NAME_KNOWN;
283 list_del(&ie->list);
286 memcpy(&ie->data, data, sizeof(*data));
287 ie->timestamp = jiffies;
288 cache->timestamp = jiffies;
290 if (ie->name_state == NAME_NOT_KNOWN)
299 struct discovery_state *cache = &hdev->discovery;
304 list_for_each_entry(e, &cache->all, all) {
305 struct inquiry_data *data = &e->data;
310 bacpy(&info->bdaddr, &data->bdaddr);
311 info->pscan_rep_mode = data->pscan_rep_mode;
312 info->pscan_period_mode = data->pscan_period_mode;
313 info->pscan_mode = data->pscan_mode;
314 memcpy(info->dev_class, data->dev_class, 3);
315 info->clock_offset = data->clock_offset;
334 return -EFAULT;
338 return -ENODEV;
341 err = -EBUSY;
346 err = -EOPNOTSUPP;
351 err = -EOPNOTSUPP;
357 err = -EINVAL;
378 * cleared). If it is interrupted by a signal, return -EINTR.
380 if (wait_on_bit(&hdev->flags, HCI_INQUIRY,
382 err = -EINTR;
397 err = -ENOMEM;
411 err = -EFAULT;
413 err = -EFAULT;
426 BT_DBG("%s %p", hdev->name, hdev);
436 /* ---- HCI ioctl helpers ---- */
445 return -ENODEV;
458 err = -EOPNOTSUPP;
468 cancel_delayed_work(&hdev->power_off);
474 flush_workqueue(hdev->req_workqueue);
497 BT_DBG("%s %p", hdev->name, hdev);
515 return -ENODEV;
518 err = -EBUSY;
522 cancel_work_sync(&hdev->power_on);
524 cancel_delayed_work(&hdev->power_off);
537 BT_DBG("%s %p", hdev->name, hdev);
542 skb_queue_purge(&hdev->rx_q);
543 skb_queue_purge(&hdev->cmd_q);
545 /* Cancel these to avoid queueing non-chained pending work */
550 * queue_delayed_work(&hdev->{cmd,ncmd}_timer)
556 cancel_delayed_work(&hdev->cmd_timer);
557 cancel_delayed_work(&hdev->ncmd_timer);
562 drain_workqueue(hdev->workqueue);
569 if (hdev->flush)
570 hdev->flush(hdev);
574 atomic_set(&hdev->cmd_cnt, 1);
575 hdev->acl_cnt = 0;
576 hdev->sco_cnt = 0;
577 hdev->le_cnt = 0;
578 hdev->iso_cnt = 0;
593 return -ENODEV;
595 if (!test_bit(HCI_UP, &hdev->flags)) {
596 err = -ENETDOWN;
601 err = -EBUSY;
606 err = -EOPNOTSUPP;
624 return -ENODEV;
627 ret = -EBUSY;
632 ret = -EOPNOTSUPP;
636 memset(&hdev->stat, 0, sizeof(struct hci_dev_stats));
647 BT_DBG("%s scan 0x%02x", hdev->name, scan);
673 hci_update_adv_data(hdev, hdev->cur_adv_instance);
687 return -EFAULT;
691 return -ENODEV;
694 err = -EBUSY;
699 err = -EOPNOTSUPP;
704 err = -EOPNOTSUPP;
716 err = -EOPNOTSUPP;
720 if (!test_bit(HCI_AUTH, &hdev->flags)) {
739 * get correctly modified as this was a non-mgmt change.
753 hdev->link_mode = ((__u16) dr.dev_opt) &
758 if (hdev->pkt_type == (__u16) dr.dev_opt)
761 hdev->pkt_type = (__u16) dr.dev_opt;
766 hdev->acl_mtu = *((__u16 *) &dr.dev_opt + 1);
767 hdev->acl_pkts = *((__u16 *) &dr.dev_opt + 0);
771 hdev->sco_mtu = *((__u16 *) &dr.dev_opt + 1);
772 hdev->sco_pkts = *((__u16 *) &dr.dev_opt + 0);
776 err = -EINVAL;
794 return -EFAULT;
797 return -EINVAL;
801 return -ENOMEM;
803 dl->dev_num = dev_num;
804 dr = dl->dev_req;
808 unsigned long flags = hdev->flags;
810 /* When the auto-off is configured it means the transport
817 dr[n].dev_id = hdev->id;
825 dl->dev_num = n;
829 return err ? -EFAULT : 0;
840 return -EFAULT;
844 return -ENODEV;
846 /* When the auto-off is configured it means the transport
851 flags = hdev->flags & ~BIT(HCI_UP);
853 flags = hdev->flags;
855 strscpy(di.name, hdev->name, sizeof(di.name));
856 di.bdaddr = hdev->bdaddr;
857 di.type = (hdev->bus & 0x0f);
859 di.pkt_type = hdev->pkt_type;
861 di.acl_mtu = hdev->acl_mtu;
862 di.acl_pkts = hdev->acl_pkts;
863 di.sco_mtu = hdev->sco_mtu;
864 di.sco_pkts = hdev->sco_pkts;
866 di.acl_mtu = hdev->le_mtu;
867 di.acl_pkts = hdev->le_pkts;
871 di.link_policy = hdev->link_policy;
872 di.link_mode = hdev->link_mode;
874 memcpy(&di.stat, &hdev->stat, sizeof(di.stat));
875 memcpy(&di.features, &hdev->features, sizeof(di.features));
878 err = -EFAULT;
885 /* ---- Interface to HCI drivers ---- */
891 BT_DBG("%s %p", hdev->name, hdev);
907 BT_DBG("%p name %s blocked %d", hdev, hdev->name, blocked);
910 return -EBUSY;
948 BT_DBG("%s", hdev->name);
950 if (test_bit(HCI_UP, &hdev->flags) &&
953 cancel_delayed_work(&hdev->power_off);
973 (!bacmp(&hdev->bdaddr, BDADDR_ANY) &&
974 !bacmp(&hdev->static_addr, BDADDR_ANY))) {
978 queue_delayed_work(hdev->req_workqueue, &hdev->power_off,
987 set_bit(HCI_RAW, &hdev->flags);
1002 clear_bit(HCI_RAW, &hdev->flags);
1017 BT_DBG("%s", hdev->name);
1027 BT_DBG("%s", hdev->name);
1029 if (hdev->hw_error)
1030 hdev->hw_error(hdev, hdev->hw_error_code);
1032 bt_dev_err(hdev, "hardware error 0x%2.2x", hdev->hw_error_code);
1044 list_for_each_entry_safe(uuid, tmp, &hdev->uuids, list) {
1045 list_del(&uuid->list);
1054 list_for_each_entry_safe(key, tmp, &hdev->link_keys, list) {
1055 list_del_rcu(&key->list);
1064 list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) {
1065 list_del_rcu(&k->list);
1074 list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) {
1075 list_del_rcu(&k->list);
1084 list_for_each_entry_safe(b, tmp, &hdev->blocked_keys, list) {
1085 list_del_rcu(&b->list);
1096 list_for_each_entry_rcu(b, &hdev->blocked_keys, list) {
1097 if (b->type == type && !memcmp(b->val, val, sizeof(b->val))) {
1112 list_for_each_entry_rcu(k, &hdev->link_keys, list) {
1113 if (bacmp(bdaddr, &k->bdaddr) == 0) {
1118 k->val)) {
1121 &k->bdaddr);
1153 if (conn->type == LE_LINK)
1156 /* Neither local nor remote side had no-bonding as requirement */
1157 if (conn->auth_type > 0x01 && conn->remote_auth > 0x01)
1161 if (conn->auth_type == 0x02 || conn->auth_type == 0x03)
1165 if (conn->remote_auth == 0x02 || conn->remote_auth == 0x03)
1182 u8 addr_type, u8 role)
1187 list_for_each_entry_rcu(k, &hdev->long_term_keys, list) {
1188 if (addr_type != k->bdaddr_type || bacmp(bdaddr, &k->bdaddr))
1191 if (smp_ltk_is_sc(k) || ltk_role(k->type) == role) {
1195 k->val)) {
1198 &k->bdaddr);
1216 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) {
1217 if (!bacmp(&irk->rpa, rpa)) {
1223 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) {
1224 if (smp_irk_matches(hdev, irk->val, rpa)) {
1225 bacpy(&irk->rpa, rpa);
1233 irk_to_return->val)) {
1235 &irk_to_return->bdaddr);
1251 if (addr_type == ADDR_LE_DEV_RANDOM && (bdaddr->b[5] & 0xc0) != 0xc0)
1255 list_for_each_entry_rcu(irk, &hdev->identity_resolving_keys, list) {
1256 if (addr_type == irk->addr_type &&
1257 bacmp(bdaddr, &irk->bdaddr) == 0) {
1264 irk_to_return->val)) {
1266 &irk_to_return->bdaddr);
1284 old_key_type = old_key->type;
1287 old_key_type = conn ? conn->key_type : 0xff;
1291 list_add_rcu(&key->list, &hdev->link_keys);
1294 BT_DBG("%s key for %pMR type %u", hdev->name, bdaddr, type);
1300 (!conn || conn->remote_auth == 0xff) && old_key_type == 0xff) {
1303 conn->key_type = type;
1306 bacpy(&key->bdaddr, bdaddr);
1307 memcpy(key->val, val, HCI_LINK_KEY_SIZE);
1308 key->pin_len = pin_len;
1311 key->type = old_key_type;
1313 key->type = type;
1327 u8 role = ltk_role(type);
1329 old_key = hci_find_ltk(hdev, bdaddr, addr_type, role);
1336 list_add_rcu(&key->list, &hdev->long_term_keys);
1339 bacpy(&key->bdaddr, bdaddr);
1340 key->bdaddr_type = addr_type;
1341 memcpy(key->val, tk, sizeof(key->val));
1342 key->authenticated = authenticated;
1343 key->ediv = ediv;
1344 key->rand = rand;
1345 key->enc_size = enc_size;
1346 key->type = type;
1362 bacpy(&irk->bdaddr, bdaddr);
1363 irk->addr_type = addr_type;
1365 list_add_rcu(&irk->list, &hdev->identity_resolving_keys);
1368 memcpy(irk->val, val, 16);
1369 bacpy(&irk->rpa, rpa);
1380 return -ENOENT;
1382 BT_DBG("%s removing %pMR", hdev->name, bdaddr);
1384 list_del_rcu(&key->list);
1395 list_for_each_entry_safe(k, tmp, &hdev->long_term_keys, list) {
1396 if (bacmp(bdaddr, &k->bdaddr) || k->bdaddr_type != bdaddr_type)
1399 BT_DBG("%s removing %pMR", hdev->name, bdaddr);
1401 list_del_rcu(&k->list);
1406 return removed ? 0 : -ENOENT;
1413 list_for_each_entry_safe(k, tmp, &hdev->identity_resolving_keys, list) {
1414 if (bacmp(bdaddr, &k->bdaddr) || k->addr_type != addr_type)
1417 BT_DBG("%s removing %pMR", hdev->name, bdaddr);
1419 list_del_rcu(&k->list);
1444 bdaddr = &irk->bdaddr;
1445 addr_type = irk->addr_type;
1449 list_for_each_entry_rcu(k, &hdev->long_term_keys, list) {
1450 if (k->bdaddr_type == addr_type && !bacmp(bdaddr, &k->bdaddr)) {
1466 if (hdev->req_skb) {
1467 u16 opcode = hci_skb_opcode(hdev->req_skb);
1476 if (hdev->reset)
1477 hdev->reset(hdev);
1479 atomic_set(&hdev->cmd_cnt, 1);
1480 queue_work(hdev->workqueue, &hdev->cmd_work);
1494 if (test_bit(HCI_INIT, &hdev->flags))
1506 list_for_each_entry(data, &hdev->remote_oob_data, list) {
1507 if (bacmp(bdaddr, &data->bdaddr) != 0)
1509 if (data->bdaddr_type != bdaddr_type)
1524 return -ENOENT;
1526 BT_DBG("%s removing %pMR (%u)", hdev->name, bdaddr, bdaddr_type);
1528 list_del(&data->list);
1538 list_for_each_entry_safe(data, n, &hdev->remote_oob_data, list) {
1539 list_del(&data->list);
1554 return -ENOMEM;
1556 bacpy(&data->bdaddr, bdaddr);
1557 data->bdaddr_type = bdaddr_type;
1558 list_add(&data->list, &hdev->remote_oob_data);
1562 memcpy(data->hash192, hash192, sizeof(data->hash192));
1563 memcpy(data->rand192, rand192, sizeof(data->rand192));
1565 data->present = 0x03;
1567 memset(data->hash192, 0, sizeof(data->hash192));
1568 memset(data->rand192, 0, sizeof(data->rand192));
1570 data->present = 0x02;
1572 data->present = 0x00;
1576 memcpy(data->hash256, hash256, sizeof(data->hash256));
1577 memcpy(data->rand256, rand256, sizeof(data->rand256));
1579 memset(data->hash256, 0, sizeof(data->hash256));
1580 memset(data->rand256, 0, sizeof(data->rand256));
1582 data->present = 0x01;
1585 BT_DBG("%s for %pMR", hdev->name, bdaddr);
1590 /* This function requires the caller holds hdev->lock */
1595 list_for_each_entry(adv_instance, &hdev->adv_instances, list) {
1596 if (adv_instance->instance == instance)
1603 /* This function requires the caller holds hdev->lock */
1608 list_for_each_entry(adv, &hdev->adv_instances, list) {
1609 if (adv->sid == sid)
1616 /* This function requires the caller holds hdev->lock */
1625 if (cur_instance == list_last_entry(&hdev->adv_instances,
1627 return list_first_entry(&hdev->adv_instances,
1633 /* This function requires the caller holds hdev->lock */
1640 return -ENOENT;
1642 BT_DBG("%s removing %dMR", hdev->name, instance);
1644 if (hdev->cur_adv_instance == instance) {
1645 if (hdev->adv_instance_timeout) {
1646 cancel_delayed_work(&hdev->adv_instance_expire);
1647 hdev->adv_instance_timeout = 0;
1649 hdev->cur_adv_instance = 0x00;
1652 cancel_delayed_work_sync(&adv_instance->rpa_expired_cb);
1654 list_del(&adv_instance->list);
1657 hdev->adv_instance_cnt--;
1666 list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list)
1667 adv_instance->rpa_expired = rpa_expired;
1670 /* This function requires the caller holds hdev->lock */
1675 if (hdev->adv_instance_timeout) {
1676 disable_delayed_work(&hdev->adv_instance_expire);
1677 hdev->adv_instance_timeout = 0;
1680 list_for_each_entry_safe(adv_instance, n, &hdev->adv_instances, list) {
1681 disable_delayed_work_sync(&adv_instance->rpa_expired_cb);
1682 list_del(&adv_instance->list);
1686 hdev->adv_instance_cnt = 0;
1687 hdev->cur_adv_instance = 0x00;
1697 adv_instance->rpa_expired = true;
1700 /* This function requires the caller holds hdev->lock */
1712 memset(adv->adv_data, 0, sizeof(adv->adv_data));
1713 memset(adv->scan_rsp_data, 0, sizeof(adv->scan_rsp_data));
1714 memset(adv->per_adv_data, 0, sizeof(adv->per_adv_data));
1716 if (hdev->adv_instance_cnt >= hdev->le_num_of_adv_sets ||
1717 instance < 1 || instance > hdev->le_num_of_adv_sets + 1)
1718 return ERR_PTR(-EOVERFLOW);
1722 return ERR_PTR(-ENOMEM);
1724 adv->pending = true;
1725 adv->instance = instance;
1730 if (hdev->le_num_of_adv_sets == 1 && instance == 1)
1731 adv->handle = 0x00;
1733 adv->handle = instance;
1735 list_add(&adv->list, &hdev->adv_instances);
1736 hdev->adv_instance_cnt++;
1739 adv->flags = flags;
1740 adv->min_interval = min_interval;
1741 adv->max_interval = max_interval;
1742 adv->tx_power = tx_power;
1743 /* Defining a mesh_handle changes the timing units to ms,
1747 adv->mesh = mesh_handle;
1752 adv->timeout = timeout;
1753 adv->remaining_time = timeout;
1756 adv->duration = hdev->def_multi_adv_rotation_duration;
1758 adv->duration = duration;
1760 INIT_DELAYED_WORK(&adv->rpa_expired_cb, adv_instance_rpa_expired);
1762 BT_DBG("%s for %dMR", hdev->name, instance);
1767 /* This function requires the caller holds hdev->lock */
1780 adv->sid = sid;
1781 adv->periodic = true;
1782 adv->per_adv_data_len = data_len;
1785 memcpy(adv->per_adv_data, data, data_len);
1790 /* This function requires the caller holds hdev->lock */
1801 return -ENOENT;
1804 memset(adv->adv_data, 0, sizeof(adv->adv_data));
1805 memcpy(adv->adv_data, adv_data, adv_data_len);
1806 adv->adv_data_len = adv_data_len;
1807 adv->adv_data_changed = true;
1811 memset(adv->scan_rsp_data, 0, sizeof(adv->scan_rsp_data));
1812 memcpy(adv->scan_rsp_data, scan_rsp_data, scan_rsp_len);
1813 adv->scan_rsp_len = scan_rsp_len;
1814 adv->scan_rsp_changed = true;
1818 if (((adv->flags & MGMT_ADV_FLAG_APPEARANCE) && hdev->appearance) ||
1819 adv->flags & MGMT_ADV_FLAG_LOCAL_NAME)
1820 adv->scan_rsp_changed = true;
1825 /* This function requires the caller holds hdev->lock */
1857 return adv->flags;
1872 if (adv->flags & MGMT_ADV_FLAG_APPEARANCE ||
1873 adv->flags & MGMT_ADV_FLAG_LOCAL_NAME)
1876 return adv->scan_rsp_len ? true : false;
1879 /* This function requires the caller holds hdev->lock */
1885 idr_for_each_entry(&hdev->adv_monitors_idr, monitor, handle)
1888 idr_destroy(&hdev->adv_monitors_idr);
1892 * This function requires the caller holds hdev->lock.
1902 list_for_each_entry_safe(pattern, tmp, &monitor->patterns, list) {
1903 list_del(&pattern->list);
1907 if (monitor->handle)
1908 idr_remove(&hdev->adv_monitors_idr, monitor->handle);
1910 if (monitor->state != ADV_MONITOR_STATE_NOT_REGISTERED)
1911 hdev->adv_monitors_cnt--;
1926 return -EINVAL;
1932 handle = idr_alloc(&hdev->adv_monitors_idr, monitor, min, max,
1940 monitor->handle = handle;
1948 monitor->handle, status);
1949 /* Message was not forwarded to controller - not an error */
1975 monitor->handle, status);
1979 handle = monitor->handle;
1987 if (status == -ENOENT)
1993 if (status == -ENOENT)
1995 monitor->handle);
2004 struct adv_monitor *monitor = idr_find(&hdev->adv_monitors_idr, handle);
2007 return -EINVAL;
2020 monitor = idr_get_next(&hdev->adv_monitors_idr, &idr_next_id);
2034 /* This function requires the caller holds hdev->lock */
2037 return !idr_is_empty(&hdev->adv_monitors_idr);
2054 if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type)
2068 if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type)
2082 if (!bacmp(&b->bdaddr, bdaddr) && b->bdaddr_type == type)
2094 list_del(&b->list);
2104 return -EBADF;
2107 return -EEXIST;
2111 return -ENOMEM;
2113 bacpy(&entry->bdaddr, bdaddr);
2114 entry->bdaddr_type = type;
2116 list_add(&entry->list, list);
2127 return -EBADF;
2130 return -EEXIST;
2134 return -ENOMEM;
2136 bacpy(&entry->bdaddr, bdaddr);
2137 entry->bdaddr_type = type;
2140 memcpy(entry->peer_irk, peer_irk, 16);
2143 memcpy(entry->local_irk, local_irk, 16);
2145 list_add(&entry->list, list);
2156 return -EBADF;
2159 return -EEXIST;
2163 return -ENOMEM;
2165 bacpy(&entry->bdaddr, bdaddr);
2166 entry->bdaddr_type = type;
2167 entry->flags = flags;
2169 list_add(&entry->list, list);
2185 return -ENOENT;
2187 list_del(&entry->list);
2205 return -ENOENT;
2207 list_del(&entry->list);
2213 /* This function requires the caller holds hdev->lock */
2219 list_for_each_entry(params, &hdev->le_conn_params, list) {
2220 if (bacmp(¶ms->addr, addr) == 0 &&
2221 params->addr_type == addr_type) {
2229 /* This function requires the caller holds hdev->lock or rcu_read_lock */
2238 if (bacmp(¶m->addr, addr) == 0 &&
2239 param->addr_type == addr_type) {
2250 /* This function requires the caller holds hdev->lock */
2253 if (list_empty(¶m->action))
2256 list_del_rcu(¶m->action);
2258 INIT_LIST_HEAD(¶m->action);
2261 /* This function requires the caller holds hdev->lock */
2265 list_add_rcu(¶m->action, list);
2268 /* This function requires the caller holds hdev->lock */
2284 bacpy(¶ms->addr, addr);
2285 params->addr_type = addr_type;
2287 list_add(¶ms->list, &hdev->le_conn_params);
2288 INIT_LIST_HEAD(¶ms->action);
2290 params->conn_min_interval = hdev->le_conn_min_interval;
2291 params->conn_max_interval = hdev->le_conn_max_interval;
2292 params->conn_latency = hdev->le_conn_latency;
2293 params->supervision_timeout = hdev->le_supv_timeout;
2294 params->auto_connect = HCI_AUTO_CONN_DISABLED;
2305 if (params->conn) {
2306 hci_conn_drop(params->conn);
2307 hci_conn_put(params->conn);
2310 list_del(¶ms->list);
2314 /* This function requires the caller holds hdev->lock */
2330 /* This function requires the caller holds hdev->lock */
2335 list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list) {
2336 if (params->auto_connect != HCI_AUTO_CONN_DISABLED)
2342 if (params->explicit_connect) {
2343 params->auto_connect = HCI_AUTO_CONN_EXPLICIT;
2353 /* This function requires the caller holds hdev->lock */
2358 list_for_each_entry_safe(params, tmp, &hdev->le_conn_params, list)
2373 * In case BR/EDR has been disabled on a dual-mode controller and
2381 !bacmp(&hdev->bdaddr, BDADDR_ANY) ||
2383 bacmp(&hdev->static_addr, BDADDR_ANY))) {
2384 bacpy(bdaddr, &hdev->static_addr);
2387 bacpy(bdaddr, &hdev->bdaddr);
2396 hdev->wake_reason = 0;
2397 bacpy(&hdev->wake_addr, BDADDR_ANY);
2398 hdev->wake_addr_type = 0;
2444 /* Fixme: May need ALIGN-ment? */
2452 if (init_srcu_struct(&hdev->srcu)) {
2457 hdev->pkt_type = (HCI_DM1 | HCI_DH1 | HCI_HV1);
2458 hdev->esco_type = (ESCO_HV1);
2459 hdev->link_mode = (HCI_LM_ACCEPT);
2460 hdev->num_iac = 0x01; /* One IAC support is mandatory */
2461 hdev->io_capability = 0x03; /* No Input No Output */
2462 hdev->manufacturer = 0xffff; /* Default to internal use */
2463 hdev->inq_tx_power = HCI_TX_POWER_INVALID;
2464 hdev->adv_tx_power = HCI_TX_POWER_INVALID;
2465 hdev->adv_instance_cnt = 0;
2466 hdev->cur_adv_instance = 0x00;
2467 hdev->adv_instance_timeout = 0;
2469 hdev->advmon_allowlist_duration = 300;
2470 hdev->advmon_no_filter_duration = 500;
2471 hdev->enable_advmon_interleave_scan = 0x00; /* Default to disable */
2473 hdev->sniff_max_interval = 800;
2474 hdev->sniff_min_interval = 80;
2476 hdev->le_adv_channel_map = 0x07;
2477 hdev->le_adv_min_interval = 0x0800;
2478 hdev->le_adv_max_interval = 0x0800;
2479 hdev->le_scan_interval = DISCOV_LE_SCAN_INT_FAST;
2480 hdev->le_scan_window = DISCOV_LE_SCAN_WIN_FAST;
2481 hdev->le_scan_int_suspend = DISCOV_LE_SCAN_INT_SLOW1;
2482 hdev->le_scan_window_suspend = DISCOV_LE_SCAN_WIN_SLOW1;
2483 hdev->le_scan_int_discovery = DISCOV_LE_SCAN_INT;
2484 hdev->le_scan_window_discovery = DISCOV_LE_SCAN_WIN;
2485 hdev->le_scan_int_adv_monitor = DISCOV_LE_SCAN_INT_FAST;
2486 hdev->le_scan_window_adv_monitor = DISCOV_LE_SCAN_WIN_FAST;
2487 hdev->le_scan_int_connect = DISCOV_LE_SCAN_INT_CONN;
2488 hdev->le_scan_window_connect = DISCOV_LE_SCAN_WIN_CONN;
2489 hdev->le_conn_min_interval = 0x0018;
2490 hdev->le_conn_max_interval = 0x0028;
2491 hdev->le_conn_latency = 0x0000;
2492 hdev->le_supv_timeout = 0x002a;
2493 hdev->le_def_tx_len = 0x001b;
2494 hdev->le_def_tx_time = 0x0148;
2495 hdev->le_max_tx_len = 0x001b;
2496 hdev->le_max_tx_time = 0x0148;
2497 hdev->le_max_rx_len = 0x001b;
2498 hdev->le_max_rx_time = 0x0148;
2499 hdev->le_max_key_size = SMP_MAX_ENC_KEY_SIZE;
2500 hdev->le_min_key_size = SMP_MIN_ENC_KEY_SIZE;
2501 hdev->le_tx_def_phys = HCI_LE_SET_PHY_1M;
2502 hdev->le_rx_def_phys = HCI_LE_SET_PHY_1M;
2503 hdev->le_num_of_adv_sets = HCI_MAX_ADV_INSTANCES;
2504 hdev->def_multi_adv_rotation_duration = HCI_DEFAULT_ADV_DURATION;
2505 hdev->def_le_autoconnect_timeout = HCI_LE_CONN_TIMEOUT;
2506 hdev->min_le_tx_power = HCI_TX_POWER_INVALID;
2507 hdev->max_le_tx_power = HCI_TX_POWER_INVALID;
2509 hdev->rpa_timeout = HCI_DEFAULT_RPA_TIMEOUT;
2510 hdev->discov_interleaved_timeout = DISCOV_INTERLEAVED_TIMEOUT;
2511 hdev->conn_info_min_age = DEFAULT_CONN_INFO_MIN_AGE;
2512 hdev->conn_info_max_age = DEFAULT_CONN_INFO_MAX_AGE;
2513 hdev->auth_payload_timeout = DEFAULT_AUTH_PAYLOAD_TIMEOUT;
2514 hdev->min_enc_key_size = HCI_MIN_ENC_KEY_SIZE;
2517 hdev->def_page_scan_type = PAGE_SCAN_TYPE_STANDARD;
2518 hdev->def_page_scan_int = 0x0800;
2519 hdev->def_page_scan_window = 0x0012;
2521 mutex_init(&hdev->lock);
2522 mutex_init(&hdev->req_lock);
2523 mutex_init(&hdev->mgmt_pending_lock);
2525 ida_init(&hdev->unset_handle_ida);
2527 INIT_LIST_HEAD(&hdev->mesh_pending);
2528 INIT_LIST_HEAD(&hdev->mgmt_pending);
2529 INIT_LIST_HEAD(&hdev->reject_list);
2530 INIT_LIST_HEAD(&hdev->accept_list);
2531 INIT_LIST_HEAD(&hdev->uuids);
2532 INIT_LIST_HEAD(&hdev->link_keys);
2533 INIT_LIST_HEAD(&hdev->long_term_keys);
2534 INIT_LIST_HEAD(&hdev->identity_resolving_keys);
2535 INIT_LIST_HEAD(&hdev->remote_oob_data);
2536 INIT_LIST_HEAD(&hdev->le_accept_list);
2537 INIT_LIST_HEAD(&hdev->le_resolv_list);
2538 INIT_LIST_HEAD(&hdev->le_conn_params);
2539 INIT_LIST_HEAD(&hdev->pend_le_conns);
2540 INIT_LIST_HEAD(&hdev->pend_le_reports);
2541 INIT_LIST_HEAD(&hdev->conn_hash.list);
2542 INIT_LIST_HEAD(&hdev->adv_instances);
2543 INIT_LIST_HEAD(&hdev->blocked_keys);
2544 INIT_LIST_HEAD(&hdev->monitored_devices);
2546 INIT_LIST_HEAD(&hdev->local_codecs);
2547 INIT_WORK(&hdev->rx_work, hci_rx_work);
2548 INIT_WORK(&hdev->cmd_work, hci_cmd_work);
2549 INIT_WORK(&hdev->tx_work, hci_tx_work);
2550 INIT_WORK(&hdev->power_on, hci_power_on);
2551 INIT_WORK(&hdev->error_reset, hci_error_reset);
2555 INIT_DELAYED_WORK(&hdev->power_off, hci_power_off);
2557 skb_queue_head_init(&hdev->rx_q);
2558 skb_queue_head_init(&hdev->cmd_q);
2559 skb_queue_head_init(&hdev->raw_q);
2561 init_waitqueue_head(&hdev->req_wait_q);
2563 INIT_DELAYED_WORK(&hdev->cmd_timer, hci_cmd_timeout);
2564 INIT_DELAYED_WORK(&hdev->ncmd_timer, hci_ncmd_timeout);
2579 put_device(&hdev->dev);
2588 if (!hdev->open || !hdev->close || !hdev->send)
2589 return -EINVAL;
2591 id = ida_alloc_max(&hci_index_ida, HCI_MAX_ID - 1, GFP_KERNEL);
2595 error = dev_set_name(&hdev->dev, "hci%u", id);
2599 hdev->name = dev_name(&hdev->dev);
2600 hdev->id = id;
2602 BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
2604 hdev->workqueue = alloc_ordered_workqueue("%s", WQ_HIGHPRI, hdev->name);
2605 if (!hdev->workqueue) {
2606 error = -ENOMEM;
2610 hdev->req_workqueue = alloc_ordered_workqueue("%s", WQ_HIGHPRI,
2611 hdev->name);
2612 if (!hdev->req_workqueue) {
2613 destroy_workqueue(hdev->workqueue);
2614 error = -ENOMEM;
2619 hdev->debugfs = debugfs_create_dir(hdev->name, bt_debugfs);
2621 error = device_add(&hdev->dev);
2627 hdev->rfkill = rfkill_alloc(hdev->name, &hdev->dev,
2630 if (hdev->rfkill) {
2631 if (rfkill_register(hdev->rfkill) < 0) {
2632 rfkill_destroy(hdev->rfkill);
2633 hdev->rfkill = NULL;
2637 if (hdev->rfkill && rfkill_blocked(hdev->rfkill))
2649 list_add(&hdev->list, &hci_dev_list);
2652 /* Devices that are marked for raw-only usage are unconfigured
2661 if (hdev->wakeup)
2662 hdev->conn_flags |= HCI_CONN_FLAG_REMOTE_WAKEUP;
2671 queue_work(hdev->req_workqueue, &hdev->power_on);
2673 idr_init(&hdev->adv_monitors_idr);
2679 debugfs_remove_recursive(hdev->debugfs);
2680 destroy_workqueue(hdev->workqueue);
2681 destroy_workqueue(hdev->req_workqueue);
2683 ida_free(&hci_index_ida, hdev->id);
2692 BT_DBG("%p name %s bus %d", hdev, hdev->name, hdev->bus);
2694 mutex_lock(&hdev->unregister_lock);
2696 mutex_unlock(&hdev->unregister_lock);
2699 list_del(&hdev->list);
2702 synchronize_srcu(&hdev->srcu);
2703 cleanup_srcu_struct(&hdev->srcu);
2705 disable_work_sync(&hdev->rx_work);
2706 disable_work_sync(&hdev->cmd_work);
2707 disable_work_sync(&hdev->tx_work);
2708 disable_work_sync(&hdev->power_on);
2709 disable_work_sync(&hdev->error_reset);
2717 if (!test_bit(HCI_INIT, &hdev->flags) &&
2727 BUG_ON(!list_empty(&hdev->mgmt_pending));
2731 if (hdev->rfkill) {
2732 rfkill_unregister(hdev->rfkill);
2733 rfkill_destroy(hdev->rfkill);
2736 device_del(&hdev->dev);
2745 debugfs_remove_recursive(hdev->debugfs);
2746 kfree_const(hdev->hw_info);
2747 kfree_const(hdev->fw_info);
2749 destroy_workqueue(hdev->workqueue);
2750 destroy_workqueue(hdev->req_workqueue);
2753 hci_bdaddr_list_clear(&hdev->reject_list);
2754 hci_bdaddr_list_clear(&hdev->accept_list);
2762 hci_bdaddr_list_clear(&hdev->le_accept_list);
2763 hci_bdaddr_list_clear(&hdev->le_resolv_list);
2767 hci_codec_list_clear(&hdev->local_codecs);
2771 ida_destroy(&hdev->unset_handle_ida);
2772 ida_free(&hci_index_ida, hdev->id);
2773 kfree_skb(hdev->sent_cmd);
2774 kfree_skb(hdev->req_skb);
2775 kfree_skb(hdev->recv_event);
2784 if (!hdev->suspend_notifier.notifier_call &&
2786 hdev->suspend_notifier.notifier_call = hci_suspend_notifier;
2787 ret = register_pm_notifier(&hdev->suspend_notifier);
2797 if (hdev->suspend_notifier.notifier_call) {
2798 ret = unregister_pm_notifier(&hdev->suspend_notifier);
2800 hdev->suspend_notifier.notifier_call = NULL;
2808 * - Cancel command timer
2809 * - Reset command counter
2810 * - Cancel command request
2817 disable_delayed_work_sync(&hdev->cmd_timer);
2818 disable_delayed_work_sync(&hdev->ncmd_timer);
2820 cancel_delayed_work_sync(&hdev->cmd_timer);
2821 cancel_delayed_work_sync(&hdev->ncmd_timer);
2824 atomic_set(&hdev->cmd_cnt, 1);
2853 mgmt_suspending(hdev, hdev->suspend_state);
2880 mgmt_resuming(hdev, hdev->wake_reason, &hdev->wake_addr,
2881 hdev->wake_addr_type);
2896 return -ENOMEM;
2910 if (hdev->classify_pkt_type)
2911 return hdev->classify_pkt_type(hdev, skb);
2921 if (!hdev || (!test_bit(HCI_UP, &hdev->flags)
2922 && !test_bit(HCI_INIT, &hdev->flags))) {
2924 return -ENXIO;
2941 __u16 handle = __le16_to_cpu(hci_acl_hdr(skb)->handle);
2958 return -EINVAL;
2962 bt_cb(skb)->incoming = 1;
2967 skb_queue_tail(&hdev->rx_q, skb);
2968 queue_work(hdev->workqueue, &hdev->rx_work);
2983 skb_queue_tail(&hdev->rx_q, skb);
2984 queue_work(hdev->workqueue, &hdev->rx_work);
2995 kfree_const(hdev->hw_info);
2996 hdev->hw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs);
3006 kfree_const(hdev->fw_info);
3007 hdev->fw_info = kvasprintf_const(GFP_KERNEL, fmt, vargs);
3012 /* ---- Interface to upper protocols ---- */
3016 BT_DBG("%p name %s", cb, cb->name);
3019 list_add_tail(&cb->list, &hci_cb_list);
3028 BT_DBG("%p name %s", cb, cb->name);
3031 list_del(&cb->list);
3042 BT_DBG("%s type %d len %d", hdev->name, hci_skb_pkt_type(skb),
3043 skb->len);
3051 if (atomic_read(&hdev->promisc)) {
3059 if (!test_bit(HCI_RUNNING, &hdev->flags)) {
3061 return -EINVAL;
3065 /* Intercept HCI Drv packet here and don't go with hdev->send
3073 err = hdev->send(hdev, skb);
3096 BT_DBG("%s opcode 0x%4.4x plen %d", hdev->name, opcode, plen);
3101 return -ENOMEM;
3104 /* Stand-alone HCI commands must be flagged as
3105 * single-command requests.
3107 bt_cb(skb)->hci.req_flags |= HCI_REQ_START;
3109 skb_queue_tail(&hdev->cmd_q, skb);
3110 queue_work(hdev->workqueue, &hdev->cmd_work);
3125 * Some vendors do not comply with this rule for vendor-specific
3130 return -EINVAL;
3137 return -ENOMEM;
3151 if (!skb || skb->len < HCI_COMMAND_HDR_SIZE)
3154 hdr = (void *)skb->data;
3156 if (hdr->opcode != cpu_to_le16(opcode))
3159 return skb->data + HCI_COMMAND_HDR_SIZE;
3168 data = hci_cmd_data(hdev->sent_cmd, opcode);
3171 data = hci_cmd_data(hdev->req_skb, opcode);
3182 if (!hdev->recv_event)
3185 hdr = (void *)hdev->recv_event->data;
3188 if (hdr->evt != event) {
3190 if (hdr->evt == HCI_EV_LE_META) {
3193 ev = (void *)hdev->recv_event->data + offset;
3195 if (ev->subevent == event)
3204 return hdev->recv_event->data + offset;
3211 int len = skb->len;
3216 hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags));
3217 hdr->dlen = cpu_to_le16(len);
3223 struct hci_conn *conn = chan->conn;
3224 struct hci_dev *hdev = conn->hdev;
3227 skb->len = skb_headlen(skb);
3228 skb->data_len = 0;
3232 hci_add_acl_hdr(skb, conn->handle, flags);
3234 list = skb_shinfo(skb)->frag_list;
3237 BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len);
3242 BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len);
3244 skb_shinfo(skb)->frag_list = NULL;
3251 spin_lock_bh(&queue->lock);
3258 skb = list; list = list->next;
3261 hci_add_acl_hdr(skb, conn->handle, flags);
3263 BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len);
3268 spin_unlock_bh(&queue->lock);
3276 struct hci_dev *hdev = chan->conn->hdev;
3278 BT_DBG("%s chan %p flags 0x%4.4x", hdev->name, chan, flags);
3280 hci_queue_acl(chan, &chan->data_q, skb, flags);
3282 queue_work(hdev->workqueue, &hdev->tx_work);
3288 struct hci_dev *hdev = conn->hdev;
3291 BT_DBG("%s len %d", hdev->name, skb->len);
3293 hdr.handle = cpu_to_le16(conn->handle);
3294 hdr.dlen = skb->len;
3302 skb_queue_tail(&conn->data_q, skb);
3305 skb_queue_len(&conn->data_q));
3307 queue_work(hdev->workqueue, &hdev->tx_work);
3314 int len = skb->len;
3319 hdr->handle = cpu_to_le16(hci_handle_pack(handle, flags));
3320 hdr->dlen = cpu_to_le16(len);
3326 struct hci_dev *hdev = conn->hdev;
3330 skb->len = skb_headlen(skb);
3331 skb->data_len = 0;
3335 list = skb_shinfo(skb)->frag_list;
3338 hci_add_iso_hdr(skb, conn->handle, flags);
3342 BT_DBG("%s nonfrag skb %p len %d", hdev->name, skb, skb->len);
3347 BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len);
3349 skb_shinfo(skb)->frag_list = NULL;
3354 skb = list; list = list->next;
3359 hci_add_iso_hdr(skb, conn->handle, flags);
3361 BT_DBG("%s frag %p len %d", hdev->name, skb, skb->len);
3372 struct hci_dev *hdev = conn->hdev;
3374 BT_DBG("%s len %d", hdev->name, skb->len);
3376 hci_queue_iso(conn, &conn->data_q, skb);
3378 queue_work(hdev->workqueue, &hdev->tx_work);
3381 /* ---- HCI TX task (outgoing data) ---- */
3394 hdev = conn->hdev;
3396 switch (conn->type) {
3398 cnt = hdev->acl_cnt;
3402 cnt = hdev->sco_cnt;
3405 cnt = hdev->le_mtu ? hdev->le_cnt : hdev->acl_cnt;
3410 cnt = hdev->iso_cnt;
3414 bt_dev_err(hdev, "unknown link type %d", conn->type);
3424 struct hci_conn_hash *h = &hdev->conn_hash;
3433 list_for_each_entry_rcu(c, &h->list, list) {
3434 if (c->type != type ||
3435 skb_queue_empty(&c->data_q))
3439 state_to_string(c->state),
3440 skb_queue_len(&c->data_q));
3442 if (c->state != BT_CONNECTED && c->state != BT_CONFIG)
3447 if (c->sent < min) {
3448 min = c->sent;
3466 struct hci_conn_hash *h = &hdev->conn_hash;
3474 list_for_each_entry(c, &h->list, list) {
3475 if (c->type == type && c->sent) {
3477 &c->dst);
3488 struct hci_conn_hash *h = &hdev->conn_hash;
3494 BT_DBG("%s", hdev->name);
3498 list_for_each_entry_rcu(conn, &h->list, list) {
3501 if (conn->type != type)
3504 if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG)
3509 list_for_each_entry_rcu(tmp, &conn->chan_list, list) {
3512 if (skb_queue_empty(&tmp->data_q))
3515 skb = skb_peek(&tmp->data_q);
3516 if (skb->priority < cur_prio)
3519 if (skb->priority > cur_prio) {
3522 cur_prio = skb->priority;
3527 if (conn->sent < min) {
3528 min = conn->sent;
3542 hci_quote_sent(chan->conn, num, quote);
3550 struct hci_conn_hash *h = &hdev->conn_hash;
3554 BT_DBG("%s", hdev->name);
3558 list_for_each_entry_rcu(conn, &h->list, list) {
3561 if (conn->type != type)
3564 if (conn->state != BT_CONNECTED && conn->state != BT_CONFIG)
3569 list_for_each_entry_rcu(chan, &conn->chan_list, list) {
3572 if (chan->sent) {
3573 chan->sent = 0;
3577 if (skb_queue_empty(&chan->data_q))
3580 skb = skb_peek(&chan->data_q);
3581 if (skb->priority >= HCI_PRIO_MAX - 1)
3584 skb->priority = HCI_PRIO_MAX - 1;
3587 skb->priority);
3610 timeout = hdev->acl_last_tx + HCI_ACL_TX_TIMEOUT;
3616 timeout = hdev->le_last_tx + HCI_ACL_TX_TIMEOUT;
3624 timeout = hdev->iso_last_tx + HCI_ISO_TX_TIMEOUT;
3640 unsigned int pkts = hdev->sco_pkts;
3653 cnt = &hdev->sco_cnt;
3656 while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
3657 BT_DBG("skb %p len %d", skb, skb->len);
3660 conn->sent++;
3661 if (conn->sent == ~0)
3662 conn->sent = 0;
3663 (*cnt)--;
3673 queue_work(hdev->workqueue, &hdev->tx_work);
3678 unsigned int cnt = hdev->acl_cnt;
3685 while (hdev->acl_cnt &&
3687 u32 priority = (skb_peek(&chan->data_q))->priority;
3688 while (quote-- && (skb = skb_peek(&chan->data_q))) {
3690 skb->len, skb->priority);
3693 if (skb->priority < priority)
3696 skb = skb_dequeue(&chan->data_q);
3698 hci_conn_enter_active_mode(chan->conn,
3699 bt_cb(skb)->force_active);
3701 hci_send_conn_frame(hdev, chan->conn, skb);
3702 hdev->acl_last_tx = jiffies;
3704 hdev->acl_cnt--;
3705 chan->sent++;
3706 chan->conn->sent++;
3714 if (cnt != hdev->acl_cnt)
3720 BT_DBG("%s", hdev->name);
3735 BT_DBG("%s", hdev->name);
3740 cnt = hdev->le_pkts ? &hdev->le_cnt : &hdev->acl_cnt;
3746 u32 priority = (skb_peek(&chan->data_q))->priority;
3747 while (quote-- && (skb = skb_peek(&chan->data_q))) {
3749 skb->len, skb->priority);
3752 if (skb->priority < priority)
3755 skb = skb_dequeue(&chan->data_q);
3757 hci_send_conn_frame(hdev, chan->conn, skb);
3758 hdev->le_last_tx = jiffies;
3760 (*cnt)--;
3761 chan->sent++;
3762 chan->conn->sent++;
3781 BT_DBG("%s", hdev->name);
3786 cnt = &hdev->iso_cnt;
3791 while (quote-- && (skb = skb_dequeue(&conn->data_q))) {
3792 BT_DBG("skb %p len %d", skb, skb->len);
3795 hdev->iso_last_tx = jiffies;
3797 conn->sent++;
3798 if (conn->sent == ~0)
3799 conn->sent = 0;
3800 (*cnt)--;
3810 BT_DBG("%s acl %d sco %d le %d iso %d", hdev->name, hdev->acl_cnt,
3811 hdev->sco_cnt, hdev->le_cnt, hdev->iso_cnt);
3825 while ((skb = skb_dequeue(&hdev->raw_q)))
3829 /* ----- HCI RX task (incoming data processing) ----- */
3844 handle = __le16_to_cpu(hdr->handle);
3848 bt_dev_dbg(hdev, "len %d handle 0x%4.4x flags 0x%4.4x", skb->len,
3851 hdev->stat.acl_rx++;
3885 handle = __le16_to_cpu(hdr->handle);
3889 bt_dev_dbg(hdev, "len %d handle 0x%4.4x flags 0x%4.4x", skb->len,
3892 hdev->stat.sco_rx++;
3924 handle = __le16_to_cpu(hdr->handle);
3928 bt_dev_dbg(hdev, "len %d handle 0x%4.4x flags 0x%4.4x", skb->len,
3953 skb = skb_peek(&hdev->cmd_q);
3957 return (bt_cb(skb)->hci.req_flags & HCI_REQ_START);
3966 if (!hdev->sent_cmd)
3969 sent = (void *) hdev->sent_cmd->data;
3970 opcode = __le16_to_cpu(sent->opcode);
3974 skb = skb_clone(hdev->sent_cmd, GFP_KERNEL);
3978 skb_queue_head(&hdev->cmd_q, skb);
3979 queue_work(hdev->workqueue, &hdev->cmd_work);
4001 if (test_bit(HCI_INIT, &hdev->flags) && opcode == HCI_OP_RESET)
4016 skb = hdev->req_skb;
4019 * callback would be found in hdev->req_skb instead of the
4020 * command queue (hdev->cmd_q).
4022 if (skb && bt_cb(skb)->hci.req_flags & HCI_REQ_SKB) {
4023 *req_complete_skb = bt_cb(skb)->hci.req_complete_skb;
4027 if (skb && bt_cb(skb)->hci.req_complete) {
4028 *req_complete = bt_cb(skb)->hci.req_complete;
4033 spin_lock_irqsave(&hdev->cmd_q.lock, flags);
4034 while ((skb = __skb_dequeue(&hdev->cmd_q))) {
4035 if (bt_cb(skb)->hci.req_flags & HCI_REQ_START) {
4036 __skb_queue_head(&hdev->cmd_q, skb);
4040 if (bt_cb(skb)->hci.req_flags & HCI_REQ_SKB)
4041 *req_complete_skb = bt_cb(skb)->hci.req_complete_skb;
4043 *req_complete = bt_cb(skb)->hci.req_complete;
4046 spin_unlock_irqrestore(&hdev->cmd_q.lock, flags);
4054 BT_DBG("%s", hdev->name);
4061 for (; (skb = skb_dequeue(&hdev->rx_q)); kcov_remote_stop()) {
4067 if (atomic_read(&hdev->promisc)) {
4079 !test_bit(HCI_INIT, &hdev->flags)) {
4084 if (test_bit(HCI_INIT, &hdev->flags)) {
4098 BT_DBG("%s Event packet", hdev->name);
4103 BT_DBG("%s ACL data packet", hdev->name);
4108 BT_DBG("%s SCO data packet", hdev->name);
4113 BT_DBG("%s ISO data packet", hdev->name);
4130 kfree_skb(hdev->sent_cmd);
4132 hdev->sent_cmd = skb_clone(skb, GFP_KERNEL);
4133 if (!hdev->sent_cmd) {
4134 skb_queue_head(&hdev->cmd_q, skb);
4135 queue_work(hdev->workqueue, &hdev->cmd_work);
4142 hci_cmd_sync_cancel_sync(hdev, -err);
4145 atomic_dec(&hdev->cmd_cnt);
4148 if (hdev->req_status == HCI_REQ_PEND &&
4150 kfree_skb(hdev->req_skb);
4151 hdev->req_skb = skb_clone(hdev->sent_cmd, GFP_KERNEL);
4160 BT_DBG("%s cmd_cnt %d cmd queued %d", hdev->name,
4161 atomic_read(&hdev->cmd_cnt), skb_queue_len(&hdev->cmd_q));
4164 if (atomic_read(&hdev->cmd_cnt)) {
4165 skb = skb_dequeue(&hdev->cmd_q);
4172 if (test_bit(HCI_RESET, &hdev->flags) ||
4174 cancel_delayed_work(&hdev->cmd_timer);
4176 queue_delayed_work(hdev->workqueue, &hdev->cmd_timer,