Branch data Line data Source code
1 : : /*
2 : : * wpa_supplicant - Internal driver interface wrappers
3 : : * Copyright (c) 2003-2009, Jouni Malinen <j@w1.fi>
4 : : *
5 : : * This software may be distributed under the terms of the BSD license.
6 : : * See README for more details.
7 : : */
8 : :
9 : : #ifndef DRIVER_I_H
10 : : #define DRIVER_I_H
11 : :
12 : : #include "drivers/driver.h"
13 : :
14 : : /* driver_ops */
15 : 22 : static inline void * wpa_drv_init(struct wpa_supplicant *wpa_s,
16 : : const char *ifname)
17 : : {
18 [ + - ]: 22 : if (wpa_s->driver->init2)
19 : 22 : return wpa_s->driver->init2(wpa_s, ifname,
20 : : wpa_s->global_drv_priv);
21 [ # # ]: 0 : if (wpa_s->driver->init) {
22 : 0 : return wpa_s->driver->init(wpa_s, ifname);
23 : : }
24 : 22 : return NULL;
25 : : }
26 : :
27 : 22 : static inline void wpa_drv_deinit(struct wpa_supplicant *wpa_s)
28 : : {
29 [ + - ]: 22 : if (wpa_s->driver->deinit)
30 : 22 : wpa_s->driver->deinit(wpa_s->drv_priv);
31 : 22 : }
32 : :
33 : 22 : static inline int wpa_drv_set_param(struct wpa_supplicant *wpa_s,
34 : : const char *param)
35 : : {
36 [ + - ]: 22 : if (wpa_s->driver->set_param)
37 : 22 : return wpa_s->driver->set_param(wpa_s->drv_priv, param);
38 : 22 : return 0;
39 : : }
40 : :
41 : 44 : static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s,
42 : : int enabled)
43 : : {
44 [ - + ]: 44 : if (wpa_s->driver->set_countermeasures) {
45 : 0 : return wpa_s->driver->set_countermeasures(wpa_s->drv_priv,
46 : : enabled);
47 : : }
48 : 44 : return -1;
49 : : }
50 : :
51 : 441 : static inline int wpa_drv_authenticate(struct wpa_supplicant *wpa_s,
52 : : struct wpa_driver_auth_params *params)
53 : : {
54 [ + - ]: 441 : if (wpa_s->driver->authenticate)
55 : 441 : return wpa_s->driver->authenticate(wpa_s->drv_priv, params);
56 : 441 : return -1;
57 : : }
58 : :
59 : 469 : static inline int wpa_drv_associate(struct wpa_supplicant *wpa_s,
60 : : struct wpa_driver_associate_params *params)
61 : : {
62 [ + - ]: 469 : if (wpa_s->driver->associate) {
63 : 469 : return wpa_s->driver->associate(wpa_s->drv_priv, params);
64 : : }
65 : 469 : return -1;
66 : : }
67 : :
68 : 881 : static inline int wpa_drv_scan(struct wpa_supplicant *wpa_s,
69 : : struct wpa_driver_scan_params *params)
70 : : {
71 [ + - ]: 881 : if (wpa_s->driver->scan2)
72 : 881 : return wpa_s->driver->scan2(wpa_s->drv_priv, params);
73 : 881 : return -1;
74 : : }
75 : :
76 : 0 : static inline int wpa_drv_sched_scan(struct wpa_supplicant *wpa_s,
77 : : struct wpa_driver_scan_params *params,
78 : : u32 interval)
79 : : {
80 [ # # ]: 0 : if (wpa_s->driver->sched_scan)
81 : 0 : return wpa_s->driver->sched_scan(wpa_s->drv_priv,
82 : : params, interval);
83 : 0 : return -1;
84 : : }
85 : :
86 : 0 : static inline int wpa_drv_stop_sched_scan(struct wpa_supplicant *wpa_s)
87 : : {
88 [ # # ]: 0 : if (wpa_s->driver->stop_sched_scan)
89 : 0 : return wpa_s->driver->stop_sched_scan(wpa_s->drv_priv);
90 : 0 : return -1;
91 : : }
92 : :
93 : 878 : static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
94 : : struct wpa_supplicant *wpa_s)
95 : : {
96 [ + - ]: 878 : if (wpa_s->driver->get_scan_results2)
97 : 878 : return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
98 : 878 : return NULL;
99 : : }
100 : :
101 : 714 : static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid)
102 : : {
103 [ + - ]: 714 : if (wpa_s->driver->get_bssid) {
104 : 714 : return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
105 : : }
106 : 714 : return -1;
107 : : }
108 : :
109 : 277 : static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid)
110 : : {
111 [ + - ]: 277 : if (wpa_s->driver->get_ssid) {
112 : 277 : return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
113 : : }
114 : 277 : return -1;
115 : : }
116 : :
117 : 5717 : static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s,
118 : : enum wpa_alg alg, const u8 *addr,
119 : : int key_idx, int set_tx,
120 : : const u8 *seq, size_t seq_len,
121 : : const u8 *key, size_t key_len)
122 : : {
123 [ + - ]: 5717 : if (wpa_s->driver->set_key) {
124 : 5717 : wpa_s->keys_cleared = 0;
125 : 5717 : return wpa_s->driver->set_key(wpa_s->ifname, wpa_s->drv_priv,
126 : : alg, addr, key_idx, set_tx,
127 : : seq, seq_len, key, key_len);
128 : : }
129 : 5717 : return -1;
130 : : }
131 : :
132 : 0 : static inline int wpa_drv_sta_deauth(struct wpa_supplicant *wpa_s,
133 : : const u8 *addr, int reason_code)
134 : : {
135 [ # # ]: 0 : if (wpa_s->driver->sta_deauth) {
136 : 0 : return wpa_s->driver->sta_deauth(wpa_s->drv_priv,
137 : 0 : wpa_s->own_addr, addr,
138 : : reason_code);
139 : : }
140 : 0 : return -1;
141 : : }
142 : :
143 : 391 : static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
144 : : const u8 *addr, int reason_code)
145 : : {
146 [ + - ]: 391 : if (wpa_s->driver->deauthenticate) {
147 : 391 : return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
148 : : reason_code);
149 : : }
150 : 391 : return -1;
151 : : }
152 : :
153 : 81 : static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
154 : : const u8 *bssid, const u8 *pmkid)
155 : : {
156 [ + - ]: 81 : if (wpa_s->driver->add_pmkid) {
157 : 81 : return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
158 : : }
159 : 81 : return -1;
160 : : }
161 : :
162 : 81 : static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
163 : : const u8 *bssid, const u8 *pmkid)
164 : : {
165 [ + - ]: 81 : if (wpa_s->driver->remove_pmkid) {
166 : 81 : return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
167 : : pmkid);
168 : : }
169 : 81 : return -1;
170 : : }
171 : :
172 : 22 : static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
173 : : {
174 [ + - ]: 22 : if (wpa_s->driver->flush_pmkid) {
175 : 22 : return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
176 : : }
177 : 22 : return -1;
178 : : }
179 : :
180 : 107 : static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
181 : : struct wpa_driver_capa *capa)
182 : : {
183 [ + - ]: 107 : if (wpa_s->driver->get_capa) {
184 : 107 : return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
185 : : }
186 : 107 : return -1;
187 : : }
188 : :
189 : 529 : static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
190 : : {
191 [ - + ]: 529 : if (wpa_s->driver->poll) {
192 : 0 : wpa_s->driver->poll(wpa_s->drv_priv);
193 : : }
194 : 529 : }
195 : :
196 : 22 : static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
197 : : {
198 [ - + ]: 22 : if (wpa_s->driver->get_ifname) {
199 : 0 : return wpa_s->driver->get_ifname(wpa_s->drv_priv);
200 : : }
201 : 22 : return NULL;
202 : : }
203 : :
204 : 22 : static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
205 : : {
206 [ + - ]: 22 : if (wpa_s->driver->get_mac_addr) {
207 : 22 : return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
208 : : }
209 : 22 : return NULL;
210 : : }
211 : :
212 : 0 : static inline int wpa_drv_send_eapol(struct wpa_supplicant *wpa_s,
213 : : const u8 *dst, u16 proto,
214 : : const u8 *data, size_t data_len)
215 : : {
216 [ # # ]: 0 : if (wpa_s->driver->send_eapol)
217 : 0 : return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto,
218 : : data, data_len);
219 : 0 : return -1;
220 : : }
221 : :
222 : 2526 : static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
223 : : int state)
224 : : {
225 [ + - ]: 2526 : if (wpa_s->driver->set_operstate)
226 : 2526 : return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
227 : 2526 : return 0;
228 : : }
229 : :
230 : 1206 : static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
231 : : const u8 *addr, int protect_type,
232 : : int key_type)
233 : : {
234 [ - + ]: 1206 : if (wpa_s->driver->mlme_setprotection)
235 : 0 : return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
236 : : protect_type,
237 : : key_type);
238 : 1206 : return 0;
239 : : }
240 : :
241 : : static inline struct hostapd_hw_modes *
242 : 1024 : wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
243 : : u16 *flags)
244 : : {
245 [ + - ]: 1024 : if (wpa_s->driver->get_hw_feature_data)
246 : 1024 : return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
247 : : num_modes, flags);
248 : 1024 : return NULL;
249 : : }
250 : :
251 : 0 : static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
252 : : const char *alpha2)
253 : : {
254 [ # # ]: 0 : if (wpa_s->driver->set_country)
255 : 0 : return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
256 : 0 : return 0;
257 : : }
258 : :
259 : 241 : static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
260 : : const u8 *data, size_t data_len, int noack)
261 : : {
262 [ + - ]: 241 : if (wpa_s->driver->send_mlme)
263 : 241 : return wpa_s->driver->send_mlme(wpa_s->drv_priv,
264 : : data, data_len, noack);
265 : 241 : return -1;
266 : : }
267 : :
268 : 0 : static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
269 : : const u8 *md,
270 : : const u8 *ies, size_t ies_len)
271 : : {
272 [ # # ]: 0 : if (wpa_s->driver->update_ft_ies)
273 : 0 : return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
274 : : ies, ies_len);
275 : 0 : return -1;
276 : : }
277 : :
278 : 6 : static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
279 : : u8 action, const u8 *target_ap,
280 : : const u8 *ies, size_t ies_len)
281 : : {
282 [ + - ]: 6 : if (wpa_s->driver->send_ft_action)
283 : 6 : return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
284 : : target_ap, ies, ies_len);
285 : 6 : return -1;
286 : : }
287 : :
288 : : static inline int wpa_drv_set_ap(struct wpa_supplicant *wpa_s,
289 : : struct wpa_driver_ap_params *params)
290 : : {
291 : : if (wpa_s->driver->set_ap)
292 : : return wpa_s->driver->set_ap(wpa_s->drv_priv, params);
293 : : return -1;
294 : : }
295 : :
296 : 81 : static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
297 : : struct hostapd_sta_add_params *params)
298 : : {
299 [ + - ]: 81 : if (wpa_s->driver->sta_add)
300 : 81 : return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
301 : 81 : return -1;
302 : : }
303 : :
304 : : static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
305 : : const u8 *addr)
306 : : {
307 : : if (wpa_s->driver->sta_remove)
308 : : return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
309 : : return -1;
310 : : }
311 : :
312 : : static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
313 : : const u8 *addr, const u8 *data,
314 : : size_t data_len, int encrypt,
315 : : const u8 *own_addr, u32 flags)
316 : : {
317 : : if (wpa_s->driver->hapd_send_eapol)
318 : : return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
319 : : data, data_len, encrypt,
320 : : own_addr, flags);
321 : : return -1;
322 : : }
323 : :
324 : 12 : static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
325 : : const u8 *addr, int total_flags,
326 : : int flags_or, int flags_and)
327 : : {
328 [ + - ]: 12 : if (wpa_s->driver->sta_set_flags)
329 : 12 : return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
330 : : total_flags, flags_or,
331 : : flags_and);
332 : 12 : return -1;
333 : : }
334 : :
335 : 5782 : static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
336 : : int authorized)
337 : : {
338 [ + - ]: 5782 : if (wpa_s->driver->set_supp_port) {
339 : 5782 : return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
340 : : authorized);
341 : : }
342 : 5782 : return 0;
343 : : }
344 : :
345 : 298 : static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
346 : : unsigned int freq,
347 : : unsigned int wait,
348 : : const u8 *dst, const u8 *src,
349 : : const u8 *bssid,
350 : : const u8 *data, size_t data_len,
351 : : int no_cck)
352 : : {
353 [ + - ]: 298 : if (wpa_s->driver->send_action)
354 : 298 : return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
355 : : wait, dst, src, bssid,
356 : : data, data_len, no_cck);
357 : 298 : return -1;
358 : : }
359 : :
360 : 134 : static inline void wpa_drv_send_action_cancel_wait(struct wpa_supplicant *wpa_s)
361 : : {
362 [ + - ]: 134 : if (wpa_s->driver->send_action_cancel_wait)
363 : 134 : wpa_s->driver->send_action_cancel_wait(wpa_s->drv_priv);
364 : 134 : }
365 : :
366 : : static inline int wpa_drv_set_freq(struct wpa_supplicant *wpa_s,
367 : : struct hostapd_freq_params *freq)
368 : : {
369 : : if (wpa_s->driver->set_freq)
370 : : return wpa_s->driver->set_freq(wpa_s->drv_priv, freq);
371 : : return -1;
372 : : }
373 : :
374 : 19 : static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
375 : : enum wpa_driver_if_type type,
376 : : const char *ifname, const u8 *addr,
377 : : void *bss_ctx, char *force_ifname,
378 : : u8 *if_addr, const char *bridge)
379 : : {
380 [ + - ]: 19 : if (wpa_s->driver->if_add)
381 : 19 : return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
382 : : addr, bss_ctx, NULL, force_ifname,
383 : : if_addr, bridge, 0);
384 : 19 : return -1;
385 : : }
386 : :
387 : 19 : static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
388 : : enum wpa_driver_if_type type,
389 : : const char *ifname)
390 : : {
391 [ + - ]: 19 : if (wpa_s->driver->if_remove)
392 : 19 : return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
393 : 19 : return -1;
394 : : }
395 : :
396 : 494 : static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
397 : : unsigned int freq,
398 : : unsigned int duration)
399 : : {
400 [ + - ]: 494 : if (wpa_s->driver->remain_on_channel)
401 : 494 : return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
402 : : duration);
403 : 494 : return -1;
404 : : }
405 : :
406 : 154 : static inline int wpa_drv_cancel_remain_on_channel(
407 : : struct wpa_supplicant *wpa_s)
408 : : {
409 [ + - ]: 154 : if (wpa_s->driver->cancel_remain_on_channel)
410 : 154 : return wpa_s->driver->cancel_remain_on_channel(
411 : : wpa_s->drv_priv);
412 : 154 : return -1;
413 : : }
414 : :
415 : 2458 : static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
416 : : int report)
417 : : {
418 [ + - ]: 2458 : if (wpa_s->driver->probe_req_report)
419 : 2458 : return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
420 : : report);
421 : 2458 : return -1;
422 : : }
423 : :
424 : 55 : static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
425 : : {
426 [ + - ]: 55 : if (wpa_s->driver->deinit_ap)
427 : 55 : return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
428 : 55 : return 0;
429 : : }
430 : :
431 : 50 : static inline int wpa_drv_deinit_p2p_cli(struct wpa_supplicant *wpa_s)
432 : : {
433 [ + - ]: 50 : if (wpa_s->driver->deinit_p2p_cli)
434 : 50 : return wpa_s->driver->deinit_p2p_cli(wpa_s->drv_priv);
435 : 50 : return 0;
436 : : }
437 : :
438 : 0 : static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
439 : : {
440 [ # # ]: 0 : if (wpa_s->driver->suspend)
441 : 0 : wpa_s->driver->suspend(wpa_s->drv_priv);
442 : 0 : }
443 : :
444 : 0 : static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
445 : : {
446 [ # # ]: 0 : if (wpa_s->driver->resume)
447 : 0 : wpa_s->driver->resume(wpa_s->drv_priv);
448 : 0 : }
449 : :
450 : 0 : static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
451 : : int threshold, int hysteresis)
452 : : {
453 [ # # ]: 0 : if (wpa_s->driver->signal_monitor)
454 : 0 : return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
455 : : threshold, hysteresis);
456 : 0 : return -1;
457 : : }
458 : :
459 : 0 : static inline int wpa_drv_signal_poll(struct wpa_supplicant *wpa_s,
460 : : struct wpa_signal_info *si)
461 : : {
462 [ # # ]: 0 : if (wpa_s->driver->signal_poll)
463 : 0 : return wpa_s->driver->signal_poll(wpa_s->drv_priv, si);
464 : 0 : return -1;
465 : : }
466 : :
467 : 0 : static inline int wpa_drv_pktcnt_poll(struct wpa_supplicant *wpa_s,
468 : : struct hostap_sta_driver_data *sta)
469 : : {
470 [ # # ]: 0 : if (wpa_s->driver->read_sta_data)
471 : 0 : return wpa_s->driver->read_sta_data(wpa_s->drv_priv, sta,
472 : 0 : wpa_s->bssid);
473 : 0 : return -1;
474 : : }
475 : :
476 : 2436 : static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
477 : : const struct wpabuf *beacon,
478 : : const struct wpabuf *proberesp,
479 : : const struct wpabuf *assocresp)
480 : : {
481 [ + - ]: 2436 : if (!wpa_s->driver->set_ap_wps_ie)
482 : 2436 : return -1;
483 : 2436 : return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
484 : : proberesp, assocresp);
485 : : }
486 : :
487 : 6 : static inline int wpa_drv_shared_freq(struct wpa_supplicant *wpa_s)
488 : : {
489 [ - + ]: 6 : if (!wpa_s->driver->shared_freq)
490 : 0 : return -1;
491 : 6 : return wpa_s->driver->shared_freq(wpa_s->drv_priv);
492 : : }
493 : :
494 : 0 : static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
495 : : u8 *buf, size_t buf_len)
496 : : {
497 [ # # ]: 0 : if (!wpa_s->driver->get_noa)
498 : 0 : return -1;
499 : 0 : return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
500 : : }
501 : :
502 : 0 : static inline int wpa_drv_set_p2p_powersave(struct wpa_supplicant *wpa_s,
503 : : int legacy_ps, int opp_ps,
504 : : int ctwindow)
505 : : {
506 [ # # ]: 0 : if (!wpa_s->driver->set_p2p_powersave)
507 : 0 : return -1;
508 : 0 : return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
509 : : opp_ps, ctwindow);
510 : : }
511 : :
512 : 0 : static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
513 : : {
514 [ # # ]: 0 : if (!wpa_s->driver->ampdu)
515 : 0 : return -1;
516 : 0 : return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
517 : : }
518 : :
519 : 105 : static inline int wpa_drv_send_tdls_mgmt(struct wpa_supplicant *wpa_s,
520 : : const u8 *dst, u8 action_code,
521 : : u8 dialog_token, u16 status_code,
522 : : const u8 *buf, size_t len)
523 : : {
524 [ + - ]: 105 : if (wpa_s->driver->send_tdls_mgmt) {
525 : 105 : return wpa_s->driver->send_tdls_mgmt(wpa_s->drv_priv, dst,
526 : : action_code, dialog_token,
527 : : status_code, buf, len);
528 : : }
529 : 105 : return -1;
530 : : }
531 : :
532 : 753 : static inline int wpa_drv_tdls_oper(struct wpa_supplicant *wpa_s,
533 : : enum tdls_oper oper, const u8 *peer)
534 : : {
535 [ - + ]: 753 : if (!wpa_s->driver->tdls_oper)
536 : 0 : return -1;
537 : 753 : return wpa_s->driver->tdls_oper(wpa_s->drv_priv, oper, peer);
538 : : }
539 : :
540 : : #ifdef ANDROID
541 : : static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
542 : : char *cmd, char *buf, size_t buf_len)
543 : : {
544 : : if (!wpa_s->driver->driver_cmd)
545 : : return -1;
546 : : return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
547 : : }
548 : : #endif /* ANDROID */
549 : :
550 : 248 : static inline void wpa_drv_set_rekey_info(struct wpa_supplicant *wpa_s,
551 : : const u8 *kek, const u8 *kck,
552 : : const u8 *replay_ctr)
553 : : {
554 [ - + ]: 248 : if (!wpa_s->driver->set_rekey_info)
555 : 248 : return;
556 : 248 : wpa_s->driver->set_rekey_info(wpa_s->drv_priv, kek, kck, replay_ctr);
557 : : }
558 : :
559 : 655 : static inline int wpa_drv_radio_disable(struct wpa_supplicant *wpa_s,
560 : : int disabled)
561 : : {
562 [ + - ]: 655 : if (!wpa_s->driver->radio_disable)
563 : 655 : return -1;
564 : 655 : return wpa_s->driver->radio_disable(wpa_s->drv_priv, disabled);
565 : : }
566 : :
567 : : static inline int wpa_drv_switch_channel(struct wpa_supplicant *wpa_s,
568 : : struct csa_settings *settings)
569 : : {
570 : : if (!wpa_s->driver->switch_channel)
571 : : return -1;
572 : : return wpa_s->driver->switch_channel(wpa_s->drv_priv, settings);
573 : : }
574 : :
575 : 7 : static inline int wpa_drv_wnm_oper(struct wpa_supplicant *wpa_s,
576 : : enum wnm_oper oper, const u8 *peer,
577 : : u8 *buf, u16 *buf_len)
578 : : {
579 [ + - ]: 7 : if (!wpa_s->driver->wnm_oper)
580 : 7 : return -1;
581 : 7 : return wpa_s->driver->wnm_oper(wpa_s->drv_priv, oper, peer, buf,
582 : : buf_len);
583 : : }
584 : :
585 : 668 : static inline int wpa_drv_status(struct wpa_supplicant *wpa_s,
586 : : char *buf, size_t buflen)
587 : : {
588 [ - + ]: 668 : if (!wpa_s->driver->status)
589 : 0 : return -1;
590 : 668 : return wpa_s->driver->status(wpa_s->drv_priv, buf, buflen);
591 : : }
592 : :
593 : 2 : static inline int wpa_drv_set_qos_map(struct wpa_supplicant *wpa_s,
594 : : const u8 *qos_map_set, u8 qos_map_set_len)
595 : : {
596 [ - + ]: 2 : if (!wpa_s->driver->set_qos_map)
597 : 0 : return -1;
598 : 2 : return wpa_s->driver->set_qos_map(wpa_s->drv_priv, qos_map_set,
599 : : qos_map_set_len);
600 : : }
601 : :
602 : : #endif /* DRIVER_I_H */
|
