Line data Source code
1 : /*
2 : * wpa_supplicant - Internal driver interface wrappers
3 : * Copyright (c) 2003-2015, 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 715 : static inline void * wpa_drv_init(struct wpa_supplicant *wpa_s,
16 : const char *ifname)
17 : {
18 715 : if (wpa_s->driver->init2)
19 652 : return wpa_s->driver->init2(wpa_s, ifname,
20 : wpa_s->global_drv_priv);
21 63 : if (wpa_s->driver->init) {
22 63 : return wpa_s->driver->init(wpa_s, ifname);
23 : }
24 0 : return NULL;
25 : }
26 :
27 711 : static inline void wpa_drv_deinit(struct wpa_supplicant *wpa_s)
28 : {
29 711 : if (wpa_s->driver->deinit)
30 711 : wpa_s->driver->deinit(wpa_s->drv_priv);
31 711 : }
32 :
33 711 : static inline int wpa_drv_set_param(struct wpa_supplicant *wpa_s,
34 : const char *param)
35 : {
36 711 : if (wpa_s->driver->set_param)
37 649 : return wpa_s->driver->set_param(wpa_s->drv_priv, param);
38 62 : return 0;
39 : }
40 :
41 1419 : static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s,
42 : int enabled)
43 : {
44 1419 : if (wpa_s->driver->set_countermeasures) {
45 19 : return wpa_s->driver->set_countermeasures(wpa_s->drv_priv,
46 : enabled);
47 : }
48 1400 : return -1;
49 : }
50 :
51 4818 : static inline int wpa_drv_authenticate(struct wpa_supplicant *wpa_s,
52 : struct wpa_driver_auth_params *params)
53 : {
54 4818 : if (wpa_s->driver->authenticate)
55 4818 : return wpa_s->driver->authenticate(wpa_s->drv_priv, params);
56 0 : return -1;
57 : }
58 :
59 5273 : static inline int wpa_drv_associate(struct wpa_supplicant *wpa_s,
60 : struct wpa_driver_associate_params *params)
61 : {
62 5273 : if (wpa_s->driver->associate) {
63 5273 : return wpa_s->driver->associate(wpa_s->drv_priv, params);
64 : }
65 0 : return -1;
66 : }
67 :
68 174 : static inline int wpa_drv_init_mesh(struct wpa_supplicant *wpa_s)
69 : {
70 174 : if (wpa_s->driver->init_mesh)
71 174 : return wpa_s->driver->init_mesh(wpa_s->drv_priv);
72 0 : return -1;
73 : }
74 :
75 168 : static inline int wpa_drv_join_mesh(struct wpa_supplicant *wpa_s,
76 : struct wpa_driver_mesh_join_params *params)
77 : {
78 168 : if (wpa_s->driver->join_mesh)
79 168 : return wpa_s->driver->join_mesh(wpa_s->drv_priv, params);
80 0 : return -1;
81 : }
82 :
83 193 : static inline int wpa_drv_leave_mesh(struct wpa_supplicant *wpa_s)
84 : {
85 193 : if (wpa_s->driver->leave_mesh)
86 193 : return wpa_s->driver->leave_mesh(wpa_s->drv_priv);
87 0 : return -1;
88 : }
89 :
90 5602 : static inline int wpa_drv_scan(struct wpa_supplicant *wpa_s,
91 : struct wpa_driver_scan_params *params)
92 : {
93 : #ifdef CONFIG_TESTING_OPTIONS
94 5602 : if (wpa_s->test_failure == WPAS_TEST_FAILURE_SCAN_TRIGGER)
95 3 : return -EBUSY;
96 : #endif /* CONFIG_TESTING_OPTIONS */
97 5599 : if (wpa_s->driver->scan2)
98 5599 : return wpa_s->driver->scan2(wpa_s->drv_priv, params);
99 0 : return -1;
100 : }
101 :
102 0 : static inline int wpa_drv_sched_scan(struct wpa_supplicant *wpa_s,
103 : struct wpa_driver_scan_params *params)
104 : {
105 0 : if (wpa_s->driver->sched_scan)
106 0 : return wpa_s->driver->sched_scan(wpa_s->drv_priv, params);
107 0 : return -1;
108 : }
109 :
110 0 : static inline int wpa_drv_stop_sched_scan(struct wpa_supplicant *wpa_s)
111 : {
112 0 : if (wpa_s->driver->stop_sched_scan)
113 0 : return wpa_s->driver->stop_sched_scan(wpa_s->drv_priv);
114 0 : return -1;
115 : }
116 :
117 5718 : static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
118 : struct wpa_supplicant *wpa_s)
119 : {
120 5718 : if (wpa_s->driver->get_scan_results2)
121 5718 : return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
122 0 : return NULL;
123 : }
124 :
125 26007 : static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid)
126 : {
127 26007 : if (wpa_s->driver->get_bssid) {
128 26007 : return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
129 : }
130 0 : return -1;
131 : }
132 :
133 6833 : static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid)
134 : {
135 6833 : if (wpa_s->driver->get_ssid) {
136 6833 : return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
137 : }
138 0 : return -1;
139 : }
140 :
141 16694 : static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s,
142 : enum wpa_alg alg, const u8 *addr,
143 : int key_idx, int set_tx,
144 : const u8 *seq, size_t seq_len,
145 : const u8 *key, size_t key_len)
146 : {
147 16694 : if (alg != WPA_ALG_NONE) {
148 5453 : if (key_idx >= 0 && key_idx <= 6)
149 5375 : wpa_s->keys_cleared &= ~BIT(key_idx);
150 : else
151 78 : wpa_s->keys_cleared = 0;
152 : }
153 16694 : if (wpa_s->driver->set_key) {
154 16376 : return wpa_s->driver->set_key(wpa_s->ifname, wpa_s->drv_priv,
155 : alg, addr, key_idx, set_tx,
156 : seq, seq_len, key, key_len);
157 : }
158 318 : return -1;
159 : }
160 :
161 84 : static inline int wpa_drv_get_seqnum(struct wpa_supplicant *wpa_s,
162 : const u8 *addr, int idx, u8 *seq)
163 : {
164 84 : if (wpa_s->driver->get_seqnum)
165 84 : return wpa_s->driver->get_seqnum(wpa_s->ifname, wpa_s->drv_priv,
166 : addr, idx, seq);
167 0 : return -1;
168 : }
169 :
170 2 : static inline int wpa_drv_sta_deauth(struct wpa_supplicant *wpa_s,
171 : const u8 *addr, int reason_code)
172 : {
173 2 : if (wpa_s->driver->sta_deauth) {
174 4 : return wpa_s->driver->sta_deauth(wpa_s->drv_priv,
175 2 : wpa_s->own_addr, addr,
176 : reason_code);
177 : }
178 0 : return -1;
179 : }
180 :
181 4379 : static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
182 : const u8 *addr, int reason_code)
183 : {
184 4379 : if (wpa_s->driver->deauthenticate) {
185 4379 : return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
186 : reason_code);
187 : }
188 0 : return -1;
189 : }
190 :
191 1276 : static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
192 : const u8 *bssid, const u8 *pmkid)
193 : {
194 1276 : if (wpa_s->driver->add_pmkid) {
195 1276 : return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
196 : }
197 0 : return -1;
198 : }
199 :
200 1276 : static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
201 : const u8 *bssid, const u8 *pmkid)
202 : {
203 1276 : if (wpa_s->driver->remove_pmkid) {
204 1276 : return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
205 : pmkid);
206 : }
207 0 : return -1;
208 : }
209 :
210 705 : static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
211 : {
212 705 : if (wpa_s->driver->flush_pmkid) {
213 657 : return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
214 : }
215 48 : return -1;
216 : }
217 :
218 1593 : static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
219 : struct wpa_driver_capa *capa)
220 : {
221 1593 : if (wpa_s->driver->get_capa) {
222 1509 : return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
223 : }
224 84 : return -1;
225 : }
226 :
227 4446 : static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
228 : {
229 4446 : if (wpa_s->driver->poll) {
230 0 : wpa_s->driver->poll(wpa_s->drv_priv);
231 : }
232 4446 : }
233 :
234 711 : static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
235 : {
236 711 : if (wpa_s->driver->get_ifname) {
237 0 : return wpa_s->driver->get_ifname(wpa_s->drv_priv);
238 : }
239 711 : return NULL;
240 : }
241 :
242 : static inline const char *
243 711 : wpa_driver_get_radio_name(struct wpa_supplicant *wpa_s)
244 : {
245 711 : if (wpa_s->driver->get_radio_name)
246 658 : return wpa_s->driver->get_radio_name(wpa_s->drv_priv);
247 53 : return NULL;
248 : }
249 :
250 744 : static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
251 : {
252 744 : if (wpa_s->driver->get_mac_addr) {
253 685 : return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
254 : }
255 59 : return NULL;
256 : }
257 :
258 27469 : static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
259 : int state)
260 : {
261 27469 : if (wpa_s->driver->set_operstate)
262 27381 : return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
263 88 : return 0;
264 : }
265 :
266 6682 : static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
267 : const u8 *addr, int protect_type,
268 : int key_type)
269 : {
270 6682 : if (wpa_s->driver->mlme_setprotection)
271 0 : return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
272 : protect_type,
273 : key_type);
274 6682 : return 0;
275 : }
276 :
277 : static inline struct hostapd_hw_modes *
278 15410 : wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
279 : u16 *flags)
280 : {
281 15410 : if (wpa_s->driver->get_hw_feature_data)
282 15352 : return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
283 : num_modes, flags);
284 58 : return NULL;
285 : }
286 :
287 9 : static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
288 : const char *alpha2)
289 : {
290 9 : if (wpa_s->driver->set_country)
291 9 : return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
292 0 : return 0;
293 : }
294 :
295 763 : static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
296 : const u8 *data, size_t data_len, int noack,
297 : unsigned int freq)
298 : {
299 763 : if (wpa_s->driver->send_mlme)
300 763 : return wpa_s->driver->send_mlme(wpa_s->drv_priv,
301 : data, data_len, noack,
302 : freq, NULL, 0);
303 0 : return -1;
304 : }
305 :
306 0 : static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
307 : const u8 *md,
308 : const u8 *ies, size_t ies_len)
309 : {
310 0 : if (wpa_s->driver->update_ft_ies)
311 0 : return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
312 : ies, ies_len);
313 0 : return -1;
314 : }
315 :
316 : static inline int wpa_drv_set_ap(struct wpa_supplicant *wpa_s,
317 : struct wpa_driver_ap_params *params)
318 : {
319 : if (wpa_s->driver->set_ap)
320 : return wpa_s->driver->set_ap(wpa_s->drv_priv, params);
321 : return -1;
322 : }
323 :
324 896 : static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
325 : struct hostapd_sta_add_params *params)
326 : {
327 896 : if (wpa_s->driver->sta_add)
328 896 : return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
329 0 : return -1;
330 : }
331 :
332 : static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
333 : const u8 *addr)
334 : {
335 : if (wpa_s->driver->sta_remove)
336 : return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
337 : return -1;
338 : }
339 :
340 : static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
341 : const u8 *addr, const u8 *data,
342 : size_t data_len, int encrypt,
343 : const u8 *own_addr, u32 flags)
344 : {
345 : if (wpa_s->driver->hapd_send_eapol)
346 : return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
347 : data, data_len, encrypt,
348 : own_addr, flags);
349 : return -1;
350 : }
351 :
352 36 : static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
353 : const u8 *addr, int total_flags,
354 : int flags_or, int flags_and)
355 : {
356 36 : if (wpa_s->driver->sta_set_flags)
357 36 : return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
358 : total_flags, flags_or,
359 : flags_and);
360 0 : return -1;
361 : }
362 :
363 9611 : static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
364 : int authorized)
365 : {
366 9611 : if (wpa_s->driver->set_supp_port) {
367 9533 : return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
368 : authorized);
369 : }
370 78 : return 0;
371 : }
372 :
373 3926 : static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
374 : unsigned int freq,
375 : unsigned int wait,
376 : const u8 *dst, const u8 *src,
377 : const u8 *bssid,
378 : const u8 *data, size_t data_len,
379 : int no_cck)
380 : {
381 3926 : if (wpa_s->driver->send_action)
382 3926 : return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
383 : wait, dst, src, bssid,
384 : data, data_len, no_cck);
385 0 : return -1;
386 : }
387 :
388 1520 : static inline void wpa_drv_send_action_cancel_wait(struct wpa_supplicant *wpa_s)
389 : {
390 1520 : if (wpa_s->driver->send_action_cancel_wait)
391 1520 : wpa_s->driver->send_action_cancel_wait(wpa_s->drv_priv);
392 1520 : }
393 :
394 : static inline int wpa_drv_set_freq(struct wpa_supplicant *wpa_s,
395 : struct hostapd_freq_params *freq)
396 : {
397 : if (wpa_s->driver->set_freq)
398 : return wpa_s->driver->set_freq(wpa_s->drv_priv, freq);
399 : return -1;
400 : }
401 :
402 236 : static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
403 : enum wpa_driver_if_type type,
404 : const char *ifname, const u8 *addr,
405 : void *bss_ctx, char *force_ifname,
406 : u8 *if_addr, const char *bridge)
407 : {
408 236 : if (wpa_s->driver->if_add)
409 236 : return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
410 : addr, bss_ctx, NULL, force_ifname,
411 : if_addr, bridge, 0, 0);
412 0 : return -1;
413 : }
414 :
415 203 : static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
416 : enum wpa_driver_if_type type,
417 : const char *ifname)
418 : {
419 203 : if (wpa_s->driver->if_remove)
420 203 : return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
421 0 : return -1;
422 : }
423 :
424 2059 : static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
425 : unsigned int freq,
426 : unsigned int duration)
427 : {
428 2059 : if (wpa_s->driver->remain_on_channel)
429 2059 : return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
430 : duration);
431 0 : return -1;
432 : }
433 :
434 1050 : static inline int wpa_drv_cancel_remain_on_channel(
435 : struct wpa_supplicant *wpa_s)
436 : {
437 1050 : if (wpa_s->driver->cancel_remain_on_channel)
438 1050 : return wpa_s->driver->cancel_remain_on_channel(
439 : wpa_s->drv_priv);
440 0 : return -1;
441 : }
442 :
443 35967 : static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
444 : int report)
445 : {
446 35967 : if (wpa_s->driver->probe_req_report)
447 35905 : return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
448 : report);
449 62 : return -1;
450 : }
451 :
452 442 : static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
453 : {
454 442 : if (wpa_s->driver->deinit_ap)
455 442 : return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
456 0 : return 0;
457 : }
458 :
459 239 : static inline int wpa_drv_deinit_p2p_cli(struct wpa_supplicant *wpa_s)
460 : {
461 239 : if (wpa_s->driver->deinit_p2p_cli)
462 239 : return wpa_s->driver->deinit_p2p_cli(wpa_s->drv_priv);
463 0 : return 0;
464 : }
465 :
466 2 : static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
467 : {
468 2 : if (wpa_s->driver->suspend)
469 0 : wpa_s->driver->suspend(wpa_s->drv_priv);
470 2 : }
471 :
472 2 : static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
473 : {
474 2 : if (wpa_s->driver->resume)
475 2 : wpa_s->driver->resume(wpa_s->drv_priv);
476 2 : }
477 :
478 18 : static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
479 : int threshold, int hysteresis)
480 : {
481 18 : if (wpa_s->driver->signal_monitor)
482 18 : return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
483 : threshold, hysteresis);
484 0 : return -1;
485 : }
486 :
487 62 : static inline int wpa_drv_signal_poll(struct wpa_supplicant *wpa_s,
488 : struct wpa_signal_info *si)
489 : {
490 62 : if (wpa_s->driver->signal_poll)
491 62 : return wpa_s->driver->signal_poll(wpa_s->drv_priv, si);
492 0 : return -1;
493 : }
494 :
495 1 : static inline int wpa_drv_pktcnt_poll(struct wpa_supplicant *wpa_s,
496 : struct hostap_sta_driver_data *sta)
497 : {
498 1 : if (wpa_s->driver->read_sta_data)
499 2 : return wpa_s->driver->read_sta_data(wpa_s->drv_priv, sta,
500 1 : wpa_s->bssid);
501 0 : return -1;
502 : }
503 :
504 35252 : static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
505 : const struct wpabuf *beacon,
506 : const struct wpabuf *proberesp,
507 : const struct wpabuf *assocresp)
508 : {
509 35252 : if (!wpa_s->driver->set_ap_wps_ie)
510 35252 : return -1;
511 0 : return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
512 : proberesp, assocresp);
513 : }
514 :
515 10 : static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
516 : u8 *buf, size_t buf_len)
517 : {
518 10 : if (!wpa_s->driver->get_noa)
519 10 : return -1;
520 0 : return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
521 : }
522 :
523 8 : static inline int wpa_drv_set_p2p_powersave(struct wpa_supplicant *wpa_s,
524 : int legacy_ps, int opp_ps,
525 : int ctwindow)
526 : {
527 8 : if (!wpa_s->driver->set_p2p_powersave)
528 0 : return -1;
529 8 : return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
530 : opp_ps, ctwindow);
531 : }
532 :
533 1 : static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
534 : {
535 1 : if (!wpa_s->driver->ampdu)
536 1 : return -1;
537 0 : return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
538 : }
539 :
540 143 : static inline int wpa_drv_send_tdls_mgmt(struct wpa_supplicant *wpa_s,
541 : const u8 *dst, u8 action_code,
542 : u8 dialog_token, u16 status_code,
543 : u32 peer_capab, int initiator,
544 : const u8 *buf, size_t len)
545 : {
546 143 : if (wpa_s->driver->send_tdls_mgmt) {
547 143 : return wpa_s->driver->send_tdls_mgmt(wpa_s->drv_priv, dst,
548 : action_code, dialog_token,
549 : status_code, peer_capab,
550 : initiator, buf, len);
551 : }
552 0 : return -1;
553 : }
554 :
555 6186 : static inline int wpa_drv_tdls_oper(struct wpa_supplicant *wpa_s,
556 : enum tdls_oper oper, const u8 *peer)
557 : {
558 6186 : if (!wpa_s->driver->tdls_oper)
559 0 : return -1;
560 6186 : return wpa_s->driver->tdls_oper(wpa_s->drv_priv, oper, peer);
561 : }
562 :
563 : #ifdef ANDROID
564 : static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
565 : char *cmd, char *buf, size_t buf_len)
566 : {
567 : if (!wpa_s->driver->driver_cmd)
568 : return -1;
569 : return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
570 : }
571 : #endif /* ANDROID */
572 :
573 2156 : static inline void wpa_drv_set_rekey_info(struct wpa_supplicant *wpa_s,
574 : const u8 *kek, size_t kek_len,
575 : const u8 *kck, size_t kck_len,
576 : const u8 *replay_ctr)
577 : {
578 2156 : if (!wpa_s->driver->set_rekey_info)
579 2164 : return;
580 2148 : wpa_s->driver->set_rekey_info(wpa_s->drv_priv, kek, kek_len,
581 : kck, kck_len, replay_ctr);
582 : }
583 :
584 6060 : static inline int wpa_drv_radio_disable(struct wpa_supplicant *wpa_s,
585 : int disabled)
586 : {
587 6060 : if (!wpa_s->driver->radio_disable)
588 6060 : return -1;
589 0 : return wpa_s->driver->radio_disable(wpa_s->drv_priv, disabled);
590 : }
591 :
592 : static inline int wpa_drv_switch_channel(struct wpa_supplicant *wpa_s,
593 : struct csa_settings *settings)
594 : {
595 : if (!wpa_s->driver->switch_channel)
596 : return -1;
597 : return wpa_s->driver->switch_channel(wpa_s->drv_priv, settings);
598 : }
599 :
600 0 : static inline int wpa_drv_add_ts(struct wpa_supplicant *wpa_s, u8 tsid,
601 : const u8 *address, u8 user_priority,
602 : u16 admitted_time)
603 : {
604 0 : if (!wpa_s->driver->add_tx_ts)
605 0 : return -1;
606 0 : return wpa_s->driver->add_tx_ts(wpa_s->drv_priv, tsid, address,
607 : user_priority, admitted_time);
608 : }
609 :
610 0 : static inline int wpa_drv_del_ts(struct wpa_supplicant *wpa_s, u8 tid,
611 : const u8 *address)
612 : {
613 0 : if (!wpa_s->driver->del_tx_ts)
614 0 : return -1;
615 0 : return wpa_s->driver->del_tx_ts(wpa_s->drv_priv, tid, address);
616 : }
617 :
618 1 : static inline int wpa_drv_tdls_enable_channel_switch(
619 : struct wpa_supplicant *wpa_s, const u8 *addr, u8 oper_class,
620 : const struct hostapd_freq_params *freq_params)
621 : {
622 1 : if (!wpa_s->driver->tdls_enable_channel_switch)
623 0 : return -1;
624 1 : return wpa_s->driver->tdls_enable_channel_switch(wpa_s->drv_priv, addr,
625 : oper_class,
626 : freq_params);
627 : }
628 :
629 : static inline int
630 1 : wpa_drv_tdls_disable_channel_switch(struct wpa_supplicant *wpa_s,
631 : const u8 *addr)
632 : {
633 1 : if (!wpa_s->driver->tdls_disable_channel_switch)
634 0 : return -1;
635 1 : return wpa_s->driver->tdls_disable_channel_switch(wpa_s->drv_priv,
636 : addr);
637 : }
638 :
639 39 : static inline int wpa_drv_wnm_oper(struct wpa_supplicant *wpa_s,
640 : enum wnm_oper oper, const u8 *peer,
641 : u8 *buf, u16 *buf_len)
642 : {
643 39 : if (!wpa_s->driver->wnm_oper)
644 39 : return -1;
645 0 : return wpa_s->driver->wnm_oper(wpa_s->drv_priv, oper, peer, buf,
646 : buf_len);
647 : }
648 :
649 8126 : static inline int wpa_drv_status(struct wpa_supplicant *wpa_s,
650 : char *buf, size_t buflen)
651 : {
652 8126 : if (!wpa_s->driver->status)
653 0 : return -1;
654 8126 : return wpa_s->driver->status(wpa_s->drv_priv, buf, buflen);
655 : }
656 :
657 2 : static inline int wpa_drv_set_qos_map(struct wpa_supplicant *wpa_s,
658 : const u8 *qos_map_set, u8 qos_map_set_len)
659 : {
660 2 : if (!wpa_s->driver->set_qos_map)
661 0 : return -1;
662 2 : return wpa_s->driver->set_qos_map(wpa_s->drv_priv, qos_map_set,
663 : qos_map_set_len);
664 : }
665 :
666 0 : static inline int wpa_drv_wowlan(struct wpa_supplicant *wpa_s,
667 : const struct wowlan_triggers *triggers)
668 : {
669 0 : if (!wpa_s->driver->set_wowlan)
670 0 : return -1;
671 0 : return wpa_s->driver->set_wowlan(wpa_s->drv_priv, triggers);
672 : }
673 :
674 5 : static inline int wpa_drv_vendor_cmd(struct wpa_supplicant *wpa_s,
675 : int vendor_id, int subcmd, const u8 *data,
676 : size_t data_len, struct wpabuf *buf)
677 : {
678 5 : if (!wpa_s->driver->vendor_cmd)
679 0 : return -1;
680 5 : return wpa_s->driver->vendor_cmd(wpa_s->drv_priv, vendor_id, subcmd,
681 : data, data_len, buf);
682 : }
683 :
684 12 : static inline int wpa_drv_roaming(struct wpa_supplicant *wpa_s, int allowed,
685 : const u8 *bssid)
686 : {
687 12 : if (!wpa_s->driver->roaming)
688 12 : return -1;
689 0 : return wpa_s->driver->roaming(wpa_s->drv_priv, allowed, bssid);
690 : }
691 :
692 12 : static inline int wpa_drv_set_mac_addr(struct wpa_supplicant *wpa_s,
693 : const u8 *addr)
694 : {
695 12 : if (!wpa_s->driver->set_mac_addr)
696 0 : return -1;
697 12 : return wpa_s->driver->set_mac_addr(wpa_s->drv_priv, addr);
698 : }
699 :
700 :
701 : #ifdef CONFIG_MACSEC
702 :
703 : static inline int wpa_drv_macsec_init(struct wpa_supplicant *wpa_s,
704 : struct macsec_init_params *params)
705 : {
706 : if (!wpa_s->driver->macsec_init)
707 : return -1;
708 : return wpa_s->driver->macsec_init(wpa_s->drv_priv, params);
709 : }
710 :
711 : static inline int wpa_drv_macsec_deinit(struct wpa_supplicant *wpa_s)
712 : {
713 : if (!wpa_s->driver->macsec_deinit)
714 : return -1;
715 : return wpa_s->driver->macsec_deinit(wpa_s->drv_priv);
716 : }
717 :
718 : static inline int wpa_drv_enable_protect_frames(struct wpa_supplicant *wpa_s,
719 : Boolean enabled)
720 : {
721 : if (!wpa_s->driver->enable_protect_frames)
722 : return -1;
723 : return wpa_s->driver->enable_protect_frames(wpa_s->drv_priv, enabled);
724 : }
725 :
726 : static inline int wpa_drv_set_replay_protect(struct wpa_supplicant *wpa_s,
727 : Boolean enabled, u32 window)
728 : {
729 : if (!wpa_s->driver->set_replay_protect)
730 : return -1;
731 : return wpa_s->driver->set_replay_protect(wpa_s->drv_priv, enabled,
732 : window);
733 : }
734 :
735 : static inline int wpa_drv_set_current_cipher_suite(struct wpa_supplicant *wpa_s,
736 : u64 cs)
737 : {
738 : if (!wpa_s->driver->set_current_cipher_suite)
739 : return -1;
740 : return wpa_s->driver->set_current_cipher_suite(wpa_s->drv_priv, cs);
741 : }
742 :
743 : static inline int wpa_drv_enable_controlled_port(struct wpa_supplicant *wpa_s,
744 : Boolean enabled)
745 : {
746 : if (!wpa_s->driver->enable_controlled_port)
747 : return -1;
748 : return wpa_s->driver->enable_controlled_port(wpa_s->drv_priv, enabled);
749 : }
750 :
751 : static inline int wpa_drv_get_receive_lowest_pn(struct wpa_supplicant *wpa_s,
752 : u32 channel, u8 an,
753 : u32 *lowest_pn)
754 : {
755 : if (!wpa_s->driver->get_receive_lowest_pn)
756 : return -1;
757 : return wpa_s->driver->get_receive_lowest_pn(wpa_s->drv_priv, channel,
758 : an, lowest_pn);
759 : }
760 :
761 : static inline int wpa_drv_get_transmit_next_pn(struct wpa_supplicant *wpa_s,
762 : u32 channel, u8 an,
763 : u32 *next_pn)
764 : {
765 : if (!wpa_s->driver->get_transmit_next_pn)
766 : return -1;
767 : return wpa_s->driver->get_transmit_next_pn(wpa_s->drv_priv, channel,
768 : an, next_pn);
769 : }
770 :
771 : static inline int wpa_drv_set_transmit_next_pn(struct wpa_supplicant *wpa_s,
772 : u32 channel, u8 an,
773 : u32 next_pn)
774 : {
775 : if (!wpa_s->driver->set_transmit_next_pn)
776 : return -1;
777 : return wpa_s->driver->set_transmit_next_pn(wpa_s->drv_priv, channel,
778 : an, next_pn);
779 : }
780 :
781 : static inline int wpa_drv_get_available_receive_sc(struct wpa_supplicant *wpa_s,
782 : u32 *channel)
783 : {
784 : if (!wpa_s->driver->get_available_receive_sc)
785 : return -1;
786 : return wpa_s->driver->get_available_receive_sc(wpa_s->drv_priv,
787 : channel);
788 : }
789 :
790 : static inline int
791 : wpa_drv_create_receive_sc(struct wpa_supplicant *wpa_s, u32 channel,
792 : const u8 *sci_addr, u16 sci_port,
793 : unsigned int conf_offset, int validation)
794 : {
795 : if (!wpa_s->driver->create_receive_sc)
796 : return -1;
797 : return wpa_s->driver->create_receive_sc(wpa_s->drv_priv, channel,
798 : sci_addr, sci_port, conf_offset,
799 : validation);
800 : }
801 :
802 : static inline int wpa_drv_delete_receive_sc(struct wpa_supplicant *wpa_s,
803 : u32 channel)
804 : {
805 : if (!wpa_s->driver->delete_receive_sc)
806 : return -1;
807 : return wpa_s->driver->delete_receive_sc(wpa_s->drv_priv, channel);
808 : }
809 :
810 : static inline int wpa_drv_create_receive_sa(struct wpa_supplicant *wpa_s,
811 : u32 channel, u8 an,
812 : u32 lowest_pn, const u8 *sak)
813 : {
814 : if (!wpa_s->driver->create_receive_sa)
815 : return -1;
816 : return wpa_s->driver->create_receive_sa(wpa_s->drv_priv, channel, an,
817 : lowest_pn, sak);
818 : }
819 :
820 : static inline int wpa_drv_enable_receive_sa(struct wpa_supplicant *wpa_s,
821 : u32 channel, u8 an)
822 : {
823 : if (!wpa_s->driver->enable_receive_sa)
824 : return -1;
825 : return wpa_s->driver->enable_receive_sa(wpa_s->drv_priv, channel, an);
826 : }
827 :
828 : static inline int wpa_drv_disable_receive_sa(struct wpa_supplicant *wpa_s,
829 : u32 channel, u8 an)
830 : {
831 : if (!wpa_s->driver->disable_receive_sa)
832 : return -1;
833 : return wpa_s->driver->disable_receive_sa(wpa_s->drv_priv, channel, an);
834 : }
835 :
836 : static inline int
837 : wpa_drv_get_available_transmit_sc(struct wpa_supplicant *wpa_s, u32 *channel)
838 : {
839 : if (!wpa_s->driver->get_available_transmit_sc)
840 : return -1;
841 : return wpa_s->driver->get_available_transmit_sc(wpa_s->drv_priv,
842 : channel);
843 : }
844 :
845 : static inline int
846 : wpa_drv_create_transmit_sc(struct wpa_supplicant *wpa_s, u32 channel,
847 : const u8 *sci_addr, u16 sci_port,
848 : unsigned int conf_offset)
849 : {
850 : if (!wpa_s->driver->create_transmit_sc)
851 : return -1;
852 : return wpa_s->driver->create_transmit_sc(wpa_s->drv_priv, channel,
853 : sci_addr, sci_port,
854 : conf_offset);
855 : }
856 :
857 : static inline int wpa_drv_delete_transmit_sc(struct wpa_supplicant *wpa_s,
858 : u32 channel)
859 : {
860 : if (!wpa_s->driver->delete_transmit_sc)
861 : return -1;
862 : return wpa_s->driver->delete_transmit_sc(wpa_s->drv_priv, channel);
863 : }
864 :
865 : static inline int wpa_drv_create_transmit_sa(struct wpa_supplicant *wpa_s,
866 : u32 channel, u8 an,
867 : u32 next_pn,
868 : Boolean confidentiality,
869 : const u8 *sak)
870 : {
871 : if (!wpa_s->driver->create_transmit_sa)
872 : return -1;
873 : return wpa_s->driver->create_transmit_sa(wpa_s->drv_priv, channel, an,
874 : next_pn, confidentiality, sak);
875 : }
876 :
877 : static inline int wpa_drv_enable_transmit_sa(struct wpa_supplicant *wpa_s,
878 : u32 channel, u8 an)
879 : {
880 : if (!wpa_s->driver->enable_transmit_sa)
881 : return -1;
882 : return wpa_s->driver->enable_transmit_sa(wpa_s->drv_priv, channel, an);
883 : }
884 :
885 : static inline int wpa_drv_disable_transmit_sa(struct wpa_supplicant *wpa_s,
886 : u32 channel, u8 an)
887 : {
888 : if (!wpa_s->driver->disable_transmit_sa)
889 : return -1;
890 : return wpa_s->driver->disable_transmit_sa(wpa_s->drv_priv, channel, an);
891 : }
892 : #endif /* CONFIG_MACSEC */
893 :
894 8 : static inline int wpa_drv_setband(struct wpa_supplicant *wpa_s,
895 : enum set_band band)
896 : {
897 8 : if (!wpa_s->driver->set_band)
898 8 : return -1;
899 0 : return wpa_s->driver->set_band(wpa_s->drv_priv, band);
900 : }
901 :
902 819 : static inline int wpa_drv_get_pref_freq_list(struct wpa_supplicant *wpa_s,
903 : enum wpa_driver_if_type if_type,
904 : unsigned int *num,
905 : unsigned int *freq_list)
906 : {
907 819 : if (!wpa_s->driver->get_pref_freq_list)
908 819 : return -1;
909 0 : return wpa_s->driver->get_pref_freq_list(wpa_s->drv_priv, if_type,
910 : num, freq_list);
911 : }
912 :
913 145 : static inline int wpa_drv_set_prob_oper_freq(struct wpa_supplicant *wpa_s,
914 : unsigned int freq)
915 : {
916 145 : if (!wpa_s->driver->set_prob_oper_freq)
917 145 : return 0;
918 0 : return wpa_s->driver->set_prob_oper_freq(wpa_s->drv_priv, freq);
919 : }
920 :
921 60 : static inline int wpa_drv_abort_scan(struct wpa_supplicant *wpa_s)
922 : {
923 60 : if (!wpa_s->driver->abort_scan)
924 0 : return -1;
925 60 : return wpa_s->driver->abort_scan(wpa_s->drv_priv);
926 : }
927 :
928 11223 : static inline int wpa_drv_configure_frame_filters(struct wpa_supplicant *wpa_s,
929 : u32 filters)
930 : {
931 11223 : if (!wpa_s->driver->configure_data_frame_filters)
932 147 : return -1;
933 11076 : return wpa_s->driver->configure_data_frame_filters(wpa_s->drv_priv,
934 : filters);
935 : }
936 :
937 10918 : static inline int wpa_drv_get_ext_capa(struct wpa_supplicant *wpa_s,
938 : enum wpa_driver_if_type type)
939 : {
940 10918 : if (!wpa_s->driver->get_ext_capab)
941 76 : return -1;
942 10842 : return wpa_s->driver->get_ext_capab(wpa_s->drv_priv, type,
943 : &wpa_s->extended_capa,
944 : &wpa_s->extended_capa_mask,
945 : &wpa_s->extended_capa_len);
946 : }
947 :
948 0 : static inline int wpa_drv_p2p_lo_start(struct wpa_supplicant *wpa_s,
949 : unsigned int channel,
950 : unsigned int period,
951 : unsigned int interval,
952 : unsigned int count,
953 : const u8 *device_types,
954 : size_t dev_types_len,
955 : const u8 *ies, size_t ies_len)
956 : {
957 0 : if (!wpa_s->driver->p2p_lo_start)
958 0 : return -1;
959 0 : return wpa_s->driver->p2p_lo_start(wpa_s->drv_priv, channel, period,
960 : interval, count, device_types,
961 : dev_types_len, ies, ies_len);
962 : }
963 :
964 0 : static inline int wpa_drv_p2p_lo_stop(struct wpa_supplicant *wpa_s)
965 : {
966 0 : if (!wpa_s->driver->p2p_lo_stop)
967 0 : return -1;
968 0 : return wpa_s->driver->p2p_lo_stop(wpa_s->drv_priv);
969 : }
970 :
971 959 : static inline int wpa_drv_set_default_scan_ies(struct wpa_supplicant *wpa_s,
972 : const u8 *ies, size_t len)
973 : {
974 959 : if (!wpa_s->driver->set_default_scan_ies)
975 959 : return -1;
976 0 : return wpa_s->driver->set_default_scan_ies(wpa_s->drv_priv, ies, len);
977 : }
978 :
979 : #endif /* DRIVER_I_H */
|
