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