« back to all changes in this revision
Viewing changes to plugins/hciops.c
- browse files at revision 27
- compare with another revision
- download diff
- download tarball
- view history from revision 27
- Committer: Package Import Robot
- Author(s): Nobuhiro Iwamatsu
- Date: 2012-01-24 05:35:09 UTC
- mfrom: (1.5.11) (7.1.6 experimental)
- Revision ID: package-import@ubuntu.com-20120124053509-uwpwqi783lz08wm3
Tags: 4.98-1
* New upstream release.
* Update debian/bluetooth-dbus.conf.
* Update debian/control.
Add Multi-Arch: foreign to bluez.
* Update debian/bluetooth-dbus.conf.
* Update debian/control.
Add Multi-Arch: foreign to bluez.
- files added:
- alert
- mgmt
- time
- unit
- files removed:
- plugins/echo.c
- files modified:
- .pc/02_disable_hal.patch/audio/telephony-maemo5.c
added
removed
plugins/hciops.c
40
40
41
41
#include <glib.h>
42
42
43
#include "glib-helper.h"
43
#include "glib-compat.h"
44
44
#include "hcid.h"
45
45
#include "sdpd.h"
46
46
#include "btio.h"
57
57
#define DISCOV_HALTED 0
58
58
#define DISCOV_INQ 1
59
59
#define DISCOV_SCAN 2
60
#define DISCOV_NAMES 3
60
61
61
62
#define TIMEOUT_BR_LE_SCAN 5120 /* TGAP(100)/2 */
62
63
#define TIMEOUT_LE_SCAN 10240 /* TGAP(gen_disc_scan_min) */
64
65
#define LENGTH_BR_INQ 0x08
65
66
#define LENGTH_BR_LE_INQ 0x04
66
67
67
static int hciops_start_scanning(int index, int timeout);
68
static int start_scanning(int index, int timeout);
68
69
69
70
static int child_pipe[2] = { -1, -1 };
70
71
106
107
uint8_t randomizer[16];
107
108
};
108
109
110
enum name_state {
111
NAME_UNKNOWN,
112
NAME_NEEDED,
113
NAME_NOT_NEEDED,
114
NAME_PENDING,
115
};
116
117
struct found_dev {
118
bdaddr_t bdaddr;
119
int8_t rssi;
120
enum name_state name_state;
121
};
122
109
123
static int max_dev = -1;
110
124
static struct dev_info {
111
125
int id;
153
167
154
168
GSList *connections;
155
169
170
GSList *found_devs;
171
GSList *need_name;
172
156
173
guint stop_scan_id;
157
174
} *devs = NULL;
158
175
159
static inline int get_state(int index)
160
{
161
struct dev_info *dev = &devs[index];
162
163
return dev->discov_state;
164
}
165
166
static inline gboolean is_resolvname_enabled(void)
167
{
168
return main_opts.name_resolv ? TRUE : FALSE;
176
static int found_dev_rssi_cmp(gconstpointer a, gconstpointer b)
177
{
178
const struct found_dev *d1 = a, *d2 = b;
179
int rssi1, rssi2;
180
181
if (d2->name_state == NAME_NOT_NEEDED)
182
return -1;
183
184
rssi1 = d1->rssi < 0 ? -d1->rssi : d1->rssi;
185
rssi2 = d2->rssi < 0 ? -d2->rssi : d2->rssi;
186
187
return rssi1 - rssi2;
188
}
189
190
static int found_dev_bda_cmp(gconstpointer a, gconstpointer b)
191
{
192
const struct found_dev *d1 = a, *d2 = b;
193
194
return bacmp(&d1->bdaddr, &d2->bdaddr);
195
}
196
197
static void found_dev_cleanup(struct dev_info *info)
198
{
199
g_slist_free_full(info->found_devs, g_free);
200
info->found_devs = NULL;
201
202
g_slist_free_full(info->need_name, g_free);
203
info->need_name = NULL;
204
}
205
206
static int resolve_name(struct dev_info *info, bdaddr_t *bdaddr)
207
{
208
remote_name_req_cp cp;
209
char addr[18];
210
211
ba2str(bdaddr, addr);
212
DBG("hci%d dba %s", info->id, addr);
213
214
memset(&cp, 0, sizeof(cp));
215
bacpy(&cp.bdaddr, bdaddr);
216
cp.pscan_rep_mode = 0x02;
217
218
if (hci_send_cmd(info->sk, OGF_LINK_CTL, OCF_REMOTE_NAME_REQ,
219
REMOTE_NAME_REQ_CP_SIZE, &cp) < 0)
220
return -errno;
221
222
return 0;
223
}
224
225
static int resolve_names(struct dev_info *info, struct btd_adapter *adapter)
226
{
227
struct found_dev *dev;
228
229
DBG("found_dev %u need_name %u", g_slist_length(info->found_devs),
230
g_slist_length(info->need_name));
231
232
if (g_slist_length(info->need_name) == 0)
233
return -ENOENT;
234
235
dev = info->need_name->data;
236
resolve_name(info, &dev->bdaddr);
237
dev->name_state = NAME_PENDING;
238
239
return 0;
169
240
}
170
241
171
242
static void set_state(int index, int state)
188
259
189
260
switch (dev->discov_state) {
190
261
case DISCOV_HALTED:
191
if (adapter_get_state(adapter) == STATE_SUSPENDED)
192
return;
193
194
if (is_resolvname_enabled() &&
195
adapter_has_discov_sessions(adapter))
196
adapter_set_state(adapter, STATE_RESOLVNAME);
197
else
198
adapter_set_state(adapter, STATE_IDLE);
262
found_dev_cleanup(dev);
263
adapter_set_discovering(adapter, FALSE);
199
264
break;
200
265
case DISCOV_INQ:
201
266
case DISCOV_SCAN:
202
adapter_set_state(adapter, STATE_DISCOV);
267
adapter_set_discovering(adapter, TRUE);
268
break;
269
case DISCOV_NAMES:
270
if (resolve_names(dev, adapter) < 0)
271
set_state(index, DISCOV_HALTED);
203
272
break;
204
273
}
205
274
}
208
277
{
209
278
struct dev_info *dev = &devs[index];
210
279
211
return (main_opts.le && dev->features[4] & LMP_LE &&
280
return (dev->features[4] & LMP_LE &&
212
281
dev->extfeatures[0] & LMP_HOST_LE) ? TRUE : FALSE;
213
282
}
214
283
820
889
static void bonding_complete(struct dev_info *dev, struct bt_conn *conn,
821
890
uint8_t status)
822
891
{
892
struct btd_adapter *adapter;
893
823
894
DBG("status 0x%02x", status);
824
895
825
896
if (conn->io != NULL) {
832
903
833
904
conn->bonding_initiator = FALSE;
834
905
835
btd_event_bonding_complete(&dev->bdaddr, &conn->bdaddr, status);
906
adapter = manager_find_adapter(&dev->bdaddr);
907
if (adapter)
908
adapter_bonding_complete(adapter, &conn->bdaddr, status);
836
909
}
837
910
838
911
static int get_auth_info(int index, bdaddr_t *bdaddr, uint8_t *auth)
1372
1445
write_features_info(&dev->bdaddr, &evt->bdaddr, NULL, evt->features);
1373
1446
}
1374
1447
1375
static void write_le_host_complete(int index, uint8_t status)
1376
{
1377
struct dev_info *dev = &devs[index];
1378
uint8_t page_num = 0x01;
1379
1380
if (status)
1381
return;
1382
1383
if (hci_send_cmd(dev->sk, OGF_INFO_PARAM,
1384
OCF_READ_LOCAL_EXT_FEATURES, 1, &page_num) < 0)
1385
error("Unable to read extended local features: %s (%d)",
1386
strerror(errno), errno);
1387
}
1388
1389
1448
static void read_local_version_complete(int index,
1390
1449
const read_local_version_rp *rp)
1391
1450
{
1471
1530
1472
1531
adapter = manager_find_adapter_by_id(index);
1473
1532
if (adapter)
1474
adapter_update_local_name(adapter, name);
1533
adapter_name_changed(adapter, name);
1475
1534
1476
1535
update_ext_inquiry_response(index);
1477
1536
}
1496
1555
1497
1556
DBG("Got name for hci%d", index);
1498
1557
1499
/* Even though it shouldn't happen (assuming the kernel behaves
1500
* properly) it seems like we might miss the very first
1501
* initialization commands that the kernel sends. So check for
1502
* it here (since read_local_name is one of the last init
1503
* commands) and resend the first ones if we haven't seen
1504
* their results yet */
1505
1506
if (hci_test_bit(PENDING_FEATURES, &dev->pending))
1507
hci_send_cmd(dev->sk, OGF_INFO_PARAM,
1508
OCF_READ_LOCAL_FEATURES, 0, NULL);
1509
1510
if (hci_test_bit(PENDING_VERSION, &dev->pending))
1511
hci_send_cmd(dev->sk, OGF_INFO_PARAM,
1512
OCF_READ_LOCAL_VERSION, 0, NULL);
1513
1514
1558
if (!dev->pending && dev->up)
1515
1559
init_adapter(index);
1516
1560
}
1739
1783
adapter_type = get_adapter_type(index);
1740
1784
1741
1785
if (adapter_type == BR_EDR_LE &&
1742
adapter_has_discov_sessions(adapter)) {
1743
int err = hciops_start_scanning(index, TIMEOUT_BR_LE_SCAN);
1744
if (err < 0)
1745
set_state(index, DISCOV_HALTED);
1746
} else {
1747
set_state(index, DISCOV_HALTED);
1748
}
1786
start_scanning(index, TIMEOUT_BR_LE_SCAN) == 0)
1787
return;
1788
1789
set_state(index, DISCOV_NAMES);
1749
1790
}
1750
1791
1751
1792
static inline void cc_inquiry_cancel(int index, uint8_t status)
1760
1801
1761
1802
static inline void cc_le_set_scan_enable(int index, uint8_t status)
1762
1803
{
1763
int state;
1804
struct dev_info *info = &devs[index];
1764
1805
1765
1806
if (status) {
1766
1807
error("LE Set Scan Enable Failed with status 0x%02x", status);
1767
1808
return;
1768
1809
}
1769
1810
1770
state = get_state(index);
1771
if (state == DISCOV_SCAN)
1811
if (info->discov_state == DISCOV_SCAN)
1772
1812
set_state(index, DISCOV_HALTED);
1773
1813
else
1774
1814
set_state(index, DISCOV_SCAN);
1801
1841
case cmd_opcode_pack(OGF_LINK_CTL, OCF_INQUIRY_CANCEL):
1802
1842
cc_inquiry_cancel(index, status);
1803
1843
break;
1804
case cmd_opcode_pack(OGF_HOST_CTL, OCF_WRITE_LE_HOST_SUPPORTED):
1805
write_le_host_complete(index, status);
1806
break;
1807
1844
case cmd_opcode_pack(OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE):
1808
1845
cc_le_set_scan_enable(index, status);
1809
1846
break;
1852
1889
{
1853
1890
struct dev_info *dev = &devs[index];
1854
1891
evt_remote_name_req_complete *evt = ptr;
1892
struct btd_adapter *adapter;
1855
1893
char name[MAX_NAME_LENGTH + 1];
1894
struct found_dev *found;
1895
1896
GSList *match;
1856
1897
1857
1898
DBG("hci%d status %u", index, evt->status);
1858
1899
1859
1900
memset(name, 0, sizeof(name));
1860
1901
1861
if (!evt->status)
1902
if (evt->status == 0) {
1862
1903
memcpy(name, evt->name, MAX_NAME_LENGTH);
1863
1864
btd_event_remote_name(&dev->bdaddr, &evt->bdaddr, evt->status, name);
1904
btd_event_remote_name(&dev->bdaddr, &evt->bdaddr, name);
1905
}
1906
1907
adapter = manager_find_adapter_by_id(index);
1908
if (!adapter) {
1909
error("No matching adapter found");
1910
return;
1911
}
1912
1913
match = g_slist_find_custom(dev->need_name, &evt->bdaddr,
1914
found_dev_bda_cmp);
1915
if (match == NULL)
1916
return;
1917
1918
found = match->data;
1919
found->name_state = NAME_NOT_NEEDED;
1920
1921
dev->need_name = g_slist_remove_link(dev->need_name, match);
1922
1923
match->next = dev->found_devs;
1924
dev->found_devs = match;
1925
dev->found_devs = g_slist_sort(dev->found_devs, found_dev_rssi_cmp);
1926
1927
if (resolve_names(dev, adapter) < 0)
1928
set_state(index, DISCOV_HALTED);
1865
1929
}
1866
1930
1867
1931
static inline void remote_version_information(int index, void *ptr)
1884
1948
btohs(evt->lmp_subver));
1885
1949
}
1886
1950
1951
static void dev_found(struct dev_info *info, bdaddr_t *dba, addr_type_t type,
1952
uint32_t cod, int8_t rssi, uint8_t cfm_name,
1953
uint8_t *eir, uint8_t eir_len)
1954
{
1955
struct found_dev *dev;
1956
GSList *match;
1957
1958
match = g_slist_find_custom(info->found_devs, dba, found_dev_bda_cmp);
1959
if (match != NULL) {
1960
cfm_name = 0;
1961
goto event;
1962
}
1963
1964
dev = g_new0(struct found_dev, 1);
1965
bacpy(&dev->bdaddr, dba);
1966
dev->rssi = rssi;
1967
if (cfm_name)
1968
dev->name_state = NAME_UNKNOWN;
1969
else
1970
dev->name_state = NAME_NOT_NEEDED;
1971
1972
info->found_devs = g_slist_prepend(info->found_devs, dev);
1973
1974
event:
1975
btd_event_device_found(&info->bdaddr, dba, type, cod, rssi, cfm_name,
1976
eir, eir_len);
1977
}
1978
1887
1979
static inline void inquiry_result(int index, int plen, void *ptr)
1888
1980
{
1889
1981
struct dev_info *dev = &devs[index];
1890
1982
uint8_t num = *(uint8_t *) ptr++;
1891
1983
int i;
1892
1984
1893
/* Skip if it is not in Inquiry state */
1894
if (get_state(index) != DISCOV_INQ)
1895
return;
1896
1897
1985
for (i = 0; i < num; i++) {
1898
1986
inquiry_info *info = ptr;
1899
1987
uint32_t class = info->dev_class[0] |
1900
1988
(info->dev_class[1] << 8) |
1901
1989
(info->dev_class[2] << 16);
1902
1990
1903
btd_event_device_found(&dev->bdaddr, &info->bdaddr, class,
1904
0, NULL);
1991
dev_found(dev, &info->bdaddr, ADDR_TYPE_BREDR, class, 0, 1,
1992
NULL, 0);
1905
1993
ptr += INQUIRY_INFO_SIZE;
1906
1994
}
1907
1995
}
1922
2010
| (info->dev_class[1] << 8)
1923
2011
| (info->dev_class[2] << 16);
1924
2012
1925
btd_event_device_found(&dev->bdaddr, &info->bdaddr,
1926
class, info->rssi, NULL);
2013
dev_found(dev, &info->bdaddr, ADDR_TYPE_BREDR, class,
2014
info->rssi, 1, NULL, 0);
1927
2015
ptr += INQUIRY_INFO_WITH_RSSI_AND_PSCAN_MODE_SIZE;
1928
2016
}
1929
2017
} else {
1933
2021
| (info->dev_class[1] << 8)
1934
2022
| (info->dev_class[2] << 16);
1935
2023
1936
btd_event_device_found(&dev->bdaddr, &info->bdaddr,
1937
class, info->rssi, NULL);
2024
dev_found(dev, &info->bdaddr, ADDR_TYPE_BREDR, class,
2025
info->rssi, 1, NULL, 0);
1938
2026
ptr += INQUIRY_INFO_WITH_RSSI_SIZE;
1939
2027
}
1940
2028
}
1951
2039
uint32_t class = info->dev_class[0]
1952
2040
| (info->dev_class[1] << 8)
1953
2041
| (info->dev_class[2] << 16);
1954
1955
btd_event_device_found(&dev->bdaddr, &info->bdaddr, class,
1956
info->rssi, info->data);
2042
gboolean cfm_name;
2043
2044
if (eir_has_complete_name(info->data, sizeof(info->data)))
2045
cfm_name = FALSE;
2046
else
2047
cfm_name = TRUE;
2048
2049
dev_found(dev, &info->bdaddr, ADDR_TYPE_BREDR, class,
2050
info->rssi, cfm_name,
2051
info->data, sizeof(info->data));
1957
2052
ptr += EXTENDED_INQUIRY_INFO_SIZE;
1958
2053
}
1959
2054
}
2168
2263
btd_event_remote_class(&dev->bdaddr, &evt->bdaddr, class);
2169
2264
}
2170
2265
2266
static inline addr_type_t le_addr_type(uint8_t bdaddr_type)
2267
{
2268
switch (bdaddr_type) {
2269
case LE_RANDOM_ADDRESS:
2270
return ADDR_TYPE_LE_RANDOM;
2271
case LE_PUBLIC_ADDRESS:
2272
default:
2273
return ADDR_TYPE_LE_PUBLIC;
2274
}
2275
}
2276
2171
2277
static inline void le_advertising_report(int index, evt_le_meta_event *meta)
2172
2278
{
2173
2279
struct dev_info *dev = &devs[index];
2174
2280
le_advertising_info *info;
2175
uint8_t num_reports, rssi, eir[HCI_MAX_EIR_LENGTH];
2281
uint8_t num_reports, rssi;
2176
2282
const uint8_t RSSI_SIZE = 1;
2177
2283
2178
2284
num_reports = meta->data[0];
2180
2286
info = (le_advertising_info *) &meta->data[1];
2181
2287
rssi = *(info->data + info->length);
2182
2288
2183
memset(eir, 0, sizeof(eir));
2184
memcpy(eir, info->data, info->length);
2185
2186
btd_event_device_found(&dev->bdaddr, &info->bdaddr, 0, rssi, eir);
2289
dev_found(dev, &info->bdaddr, le_addr_type(info->bdaddr_type), 0, rssi,
2290
0, info->data, info->length);
2187
2291
2188
2292
num_reports--;
2189
2293
2192
2296
RSSI_SIZE);
2193
2297
rssi = *(info->data + info->length);
2194
2298
2195
memset(eir, 0, sizeof(eir));
2196
memcpy(eir, info->data, info->length);
2197
2198
btd_event_device_found(&dev->bdaddr, &info->bdaddr, 0, rssi,
2199
eir);
2299
dev_found(dev, &info->bdaddr, le_addr_type(info->bdaddr_type),
2300
0, rssi, 0, info->data, info->length);
2200
2301
}
2201
2302
}
2202
2303
2498
2599
bacpy(&dev->bdaddr, &di.bdaddr);
2499
2600
memcpy(dev->features, di.features, 8);
2500
2601
2602
if (dev->features[7] & LMP_EXT_FEAT) {
2603
uint8_t page_num = 0x01;
2604
2605
hci_send_cmd(dev->sk, OGF_INFO_PARAM,
2606
OCF_READ_LOCAL_EXT_FEATURES, 1, &page_num);
2607
}
2608
2501
2609
/* Set page timeout */
2502
2610
if ((main_opts.flags & (1 << HCID_SET_PAGETO))) {
2503
2611
write_page_timeout_cp cp;
2512
2620
hci_send_cmd(dev->sk, OGF_HOST_CTL, OCF_READ_STORED_LINK_KEY,
2513
2621
READ_STORED_LINK_KEY_CP_SIZE, &cp);
2514
2622
2515
if (!dev->pending)
2623
if (!dev->pending) {
2516
2624
init_adapter(index);
2625
return;
2626
}
2627
2628
/* Even though it shouldn't happen (assuming the kernel behaves
2629
* properly) it seems like we might miss the very first
2630
* initialization commands that the kernel sends. So check for
2631
* it here and resend the ones we haven't seen their results yet */
2632
2633
if (hci_test_bit(PENDING_FEATURES, &dev->pending))
2634
hci_send_cmd(dev->sk, OGF_INFO_PARAM,
2635
OCF_READ_LOCAL_FEATURES, 0, NULL);
2636
2637
if (hci_test_bit(PENDING_VERSION, &dev->pending))
2638
hci_send_cmd(dev->sk, OGF_INFO_PARAM,
2639
OCF_READ_LOCAL_VERSION, 0, NULL);
2640
2641
if (hci_test_bit(PENDING_NAME, &dev->pending))
2642
hci_send_cmd(dev->sk, OGF_HOST_CTL,
2643
OCF_READ_LOCAL_NAME, 0, 0);
2644
2645
if (hci_test_bit(PENDING_BDADDR, &dev->pending))
2646
hci_send_cmd(dev->sk, OGF_INFO_PARAM,
2647
OCF_READ_BD_ADDR, 0, NULL);
2517
2648
}
2518
2649
2519
2650
static void init_pending(int index)
2654
2785
devs[index].up = FALSE;
2655
2786
devs[index].pending_cod = 0;
2656
2787
devs[index].cache_enable = TRUE;
2788
devs[index].discov_state = DISCOV_HALTED;
2657
2789
if (!devs[index].pending) {
2658
2790
struct btd_adapter *adapter;
2659
2791
2915
3047
return err;
2916
3048
}
2917
3049
2918
static int hciops_start_inquiry(int index, uint8_t length)
3050
static int start_inquiry(int index, uint8_t length)
2919
3051
{
2920
3052
struct dev_info *dev = &devs[index];
2921
3053
uint8_t lap[3] = { 0x33, 0x8b, 0x9e };
2967
3099
return FALSE;
2968
3100
}
2969
3101
2970
static int hciops_start_scanning(int index, int timeout)
3102
static int start_scanning(int index, int timeout)
2971
3103
{
2972
3104
struct dev_info *dev = &devs[index];
2973
3105
le_set_scan_parameters_cp cp;
3012
3144
return le_set_scan_enable(index, 0);
3013
3145
}
3014
3146
3015
static int hciops_resolve_name(int index, bdaddr_t *bdaddr)
3016
{
3017
struct dev_info *dev = &devs[index];
3018
remote_name_req_cp cp;
3019
char addr[18];
3020
3021
ba2str(bdaddr, addr);
3022
DBG("hci%d dba %s", index, addr);
3023
3024
memset(&cp, 0, sizeof(cp));
3025
bacpy(&cp.bdaddr, bdaddr);
3026
cp.pscan_rep_mode = 0x02;
3027
3028
if (hci_send_cmd(dev->sk, OGF_LINK_CTL, OCF_REMOTE_NAME_REQ,
3029
REMOTE_NAME_REQ_CP_SIZE, &cp) < 0)
3030
return -errno;
3031
3032
return 0;
3033
}
3034
3035
3147
static int hciops_set_name(int index, const char *name)
3036
3148
{
3037
3149
struct dev_info *dev = &devs[index];
3052
3164
return 0;
3053
3165
}
3054
3166
3055
static int hciops_cancel_resolve_name(int index, bdaddr_t *bdaddr)
3167
static int cancel_resolve_name(int index)
3056
3168
{
3057
struct dev_info *dev = &devs[index];
3169
struct dev_info *info = &devs[index];
3170
struct found_dev *dev;
3058
3171
remote_name_req_cancel_cp cp;
3059
char addr[18];
3060
3061
ba2str(bdaddr, addr);
3062
DBG("hci%d dba %s", index, addr);
3172
struct btd_adapter *adapter;
3173
3174
DBG("hci%d", index);
3175
3176
if (g_slist_length(info->need_name) == 0)
3177
return 0;
3178
3179
dev = info->need_name->data;
3180
if (dev->name_state != NAME_PENDING)
3181
return 0;
3063
3182
3064
3183
memset(&cp, 0, sizeof(cp));
3065
bacpy(&cp.bdaddr, bdaddr);
3066
3067
if (hci_send_cmd(dev->sk, OGF_LINK_CTL, OCF_REMOTE_NAME_REQ_CANCEL,
3184
bacpy(&cp.bdaddr, &dev->bdaddr);
3185
3186
adapter = manager_find_adapter_by_id(index);
3187
if (adapter)
3188
adapter_set_discovering(adapter, FALSE);
3189
3190
found_dev_cleanup(info);
3191
3192
if (hci_send_cmd(info->sk, OGF_LINK_CTL, OCF_REMOTE_NAME_REQ_CANCEL,
3068
3193
REMOTE_NAME_REQ_CANCEL_CP_SIZE, &cp) < 0)
3069
3194
return -errno;
3070
3195
3075
3200
{
3076
3201
int adapter_type = get_adapter_type(index);
3077
3202
3203
DBG("hci%u", index);
3204
3078
3205
switch (adapter_type) {
3079
3206
case BR_EDR_LE:
3080
return hciops_start_inquiry(index, LENGTH_BR_LE_INQ);
3207
return start_inquiry(index, LENGTH_BR_LE_INQ);
3081
3208
case BR_EDR:
3082
return hciops_start_inquiry(index, LENGTH_BR_INQ);
3209
return start_inquiry(index, LENGTH_BR_INQ);
3083
3210
case LE_ONLY:
3084
return hciops_start_scanning(index, TIMEOUT_LE_SCAN);
3211
return start_scanning(index, TIMEOUT_LE_SCAN);
3085
3212
default:
3086
3213
return -EINVAL;
3087
3214
}
3098
3225
return hciops_stop_inquiry(index);
3099
3226
case DISCOV_SCAN:
3100
3227
return hciops_stop_scanning(index);
3228
case DISCOV_NAMES:
3229
cancel_resolve_name(index);
3101
3230
default:
3102
3231
return -EINVAL;
3103
3232
}
3104
3233
}
3105
3234
3106
static int hciops_fast_connectable(int index, gboolean enable)
3235
static int hciops_set_fast_connectable(int index, gboolean enable)
3107
3236
{
3108
3237
struct dev_info *dev = &devs[index];
3109
3238
write_page_activity_cp cp;
3307
3436
return err;
3308
3437
}
3309
3438
3310
static int hciops_enable_le(int index)
3311
{
3312
struct dev_info *dev = &devs[index];
3313
write_le_host_supported_cp cp;
3314
3315
DBG("hci%d", index);
3316
3317
if (!(dev->features[4] & LMP_LE))
3318
return -ENOTSUP;
3319
3320
cp.le = 0x01;
3321
cp.simul = (dev->features[6] & LMP_LE_BREDR) ? 0x01 : 0x00;
3322
3323
if (hci_send_cmd(dev->sk, OGF_HOST_CTL,
3324
OCF_WRITE_LE_HOST_SUPPORTED,
3325
WRITE_LE_HOST_SUPPORTED_CP_SIZE, &cp) < 0)
3326
return -errno;
3327
3328
return 0;
3329
}
3330
3331
3439
static uint8_t generate_service_class(int index)
3332
3440
{
3333
3441
struct dev_info *dev = &devs[index];
3598
3706
ba2str(bdaddr, addr);
3599
3707
DBG("hci%d bdaddr %s", index, addr);
3600
3708
3601
match = g_slist_find_custom(dev->oob_data, &bdaddr, oob_bdaddr_cmp);
3709
match = g_slist_find_custom(dev->oob_data, bdaddr, oob_bdaddr_cmp);
3602
3710
3603
3711
if (match) {
3604
3712
data = match->data;
3623
3731
ba2str(bdaddr, addr);
3624
3732
DBG("hci%d bdaddr %s", index, addr);
3625
3733
3626
match = g_slist_find_custom(dev->oob_data, &bdaddr, oob_bdaddr_cmp);
3734
match = g_slist_find_custom(dev->oob_data, bdaddr, oob_bdaddr_cmp);
3627
3735
3628
3736
if (!match)
3629
3737
return -ENOENT;
3634
3742
return 0;
3635
3743
}
3636
3744
3745
static int hciops_confirm_name(int index, bdaddr_t *bdaddr,
3746
gboolean name_known)
3747
{
3748
struct dev_info *info = &devs[index];
3749
struct found_dev *dev;
3750
GSList *match;
3751
char addr[18];
3752
3753
ba2str(bdaddr, addr);
3754
DBG("hci%u %s name_known %u", index, addr, name_known);
3755
3756
match = g_slist_find_custom(info->found_devs, bdaddr,
3757
found_dev_bda_cmp);
3758
if (match == NULL)
3759
return -ENOENT;
3760
3761
dev = match->data;
3762
3763
if (name_known) {
3764
dev->name_state = NAME_NOT_NEEDED;
3765
info->found_devs = g_slist_sort(info->found_devs,
3766
found_dev_rssi_cmp);
3767
return 0;
3768
}
3769
3770
dev->name_state = NAME_NEEDED;
3771
info->found_devs = g_slist_remove_link(info->found_devs, match);
3772
3773
match->next = info->need_name;
3774
info->need_name = match;
3775
info->need_name = g_slist_sort(info->need_name, found_dev_rssi_cmp);
3776
3777
return 0;
3778
}
3779
3637
3780
static struct btd_adapter_ops hci_ops = {
3638
3781
.setup = hciops_setup,
3639
3782
.cleanup = hciops_cleanup,
3643
3786
.set_limited_discoverable = hciops_set_limited_discoverable,
3644
3787
.start_discovery = hciops_start_discovery,
3645
3788
.stop_discovery = hciops_stop_discovery,
3646
.resolve_name = hciops_resolve_name,
3647
.cancel_resolve_name = hciops_cancel_resolve_name,
3648
3789
.set_name = hciops_set_name,
3649
3790
.set_dev_class = hciops_set_dev_class,
3650
.set_fast_connectable = hciops_fast_connectable,
3791
.set_fast_connectable = hciops_set_fast_connectable,
3651
3792
.read_clock = hciops_read_clock,
3652
3793
.read_bdaddr = hciops_read_bdaddr,
3653
3794
.block_device = hciops_block_device,
3658
3799
.pincode_reply = hciops_pincode_reply,
3659
3800
.confirm_reply = hciops_confirm_reply,
3660
3801
.passkey_reply = hciops_passkey_reply,
3661
.enable_le = hciops_enable_le,
3662
3802
.encrypt_link = hciops_encrypt_link,
3663
3803
.set_did = hciops_set_did,
3664
3804
.add_uuid = hciops_add_uuid,
3672
3812
.read_local_oob_data = hciops_read_local_oob_data,
3673
3813
.add_remote_oob_data = hciops_add_remote_oob_data,
3674
3814
.remove_remote_oob_data = hciops_remove_remote_oob_data,
3815
.confirm_name = hciops_confirm_name,
3675
3816
};
3676
3817
3677
3818
static int hciops_init(void)
Loggerhead is a web-based interface for Breezy
Version: 2.0.1