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 static inline void * wpa_drv_init(struct wpa_supplicant *wpa_s,
16 				  const char *ifname)
17 {
18 	if (wpa_s->driver->init2)
19 		return wpa_s->driver->init2(wpa_s, ifname,
20 					    wpa_s->global_drv_priv);
21 	if (wpa_s->driver->init) {
22 		return wpa_s->driver->init(wpa_s, ifname);
23 	}
24 	return NULL;
25 }
26 
27 static inline void wpa_drv_deinit(struct wpa_supplicant *wpa_s)
28 {
29 	if (wpa_s->driver->deinit)
30 		wpa_s->driver->deinit(wpa_s->drv_priv);
31 }
32 
33 static inline int wpa_drv_set_param(struct wpa_supplicant *wpa_s,
34 				    const char *param)
35 {
36 	if (wpa_s->driver->set_param)
37 		return wpa_s->driver->set_param(wpa_s->drv_priv, param);
38 	return 0;
39 }
40 
41 static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s,
42 					      int enabled)
43 {
44 	if (wpa_s->driver->set_countermeasures) {
45 		return wpa_s->driver->set_countermeasures(wpa_s->drv_priv,
46 							  enabled);
47 	}
48 	return -1;
49 }
50 
51 static inline int wpa_drv_authenticate(struct wpa_supplicant *wpa_s,
52 				       struct wpa_driver_auth_params *params)
53 {
54 	if (wpa_s->driver->authenticate)
55 		return wpa_s->driver->authenticate(wpa_s->drv_priv, params);
56 	return -1;
57 }
58 
59 static inline int wpa_drv_associate(struct wpa_supplicant *wpa_s,
60 				    struct wpa_driver_associate_params *params)
61 {
62 	if (wpa_s->driver->associate) {
63 		return wpa_s->driver->associate(wpa_s->drv_priv, params);
64 	}
65 	return -1;
66 }
67 
68 static inline int wpa_drv_init_mesh(struct wpa_supplicant *wpa_s)
69 {
70 	if (wpa_s->driver->init_mesh)
71 		return wpa_s->driver->init_mesh(wpa_s->drv_priv);
72 	return -1;
73 }
74 
75 static inline int wpa_drv_join_mesh(struct wpa_supplicant *wpa_s,
76 				    struct wpa_driver_mesh_join_params *params)
77 {
78 	if (wpa_s->driver->join_mesh)
79 		return wpa_s->driver->join_mesh(wpa_s->drv_priv, params);
80 	return -1;
81 }
82 
83 static inline int wpa_drv_leave_mesh(struct wpa_supplicant *wpa_s)
84 {
85 	if (wpa_s->driver->leave_mesh)
86 		return wpa_s->driver->leave_mesh(wpa_s->drv_priv);
87 	return -1;
88 }
89 
90 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 	if (wpa_s->test_failure == WPAS_TEST_FAILURE_SCAN_TRIGGER)
95 		return -EBUSY;
96 #endif /* CONFIG_TESTING_OPTIONS */
97 	if (wpa_s->driver->scan2)
98 		return wpa_s->driver->scan2(wpa_s->drv_priv, params);
99 	return -1;
100 }
101 
102 static inline int wpa_drv_sched_scan(struct wpa_supplicant *wpa_s,
103 				     struct wpa_driver_scan_params *params)
104 {
105 	if (wpa_s->driver->sched_scan)
106 		return wpa_s->driver->sched_scan(wpa_s->drv_priv, params);
107 	return -1;
108 }
109 
110 static inline int wpa_drv_stop_sched_scan(struct wpa_supplicant *wpa_s)
111 {
112 	if (wpa_s->driver->stop_sched_scan)
113 		return wpa_s->driver->stop_sched_scan(wpa_s->drv_priv);
114 	return -1;
115 }
116 
117 static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
118 	struct wpa_supplicant *wpa_s)
119 {
120 	if (wpa_s->driver->get_scan_results2)
121 		return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
122 	return NULL;
123 }
124 
125 static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid)
126 {
127 	if (wpa_s->driver->get_bssid) {
128 		return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
129 	}
130 	return -1;
131 }
132 
133 static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid)
134 {
135 	if (wpa_s->driver->get_ssid) {
136 		return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
137 	}
138 	return -1;
139 }
140 
141 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 	if (alg != WPA_ALG_NONE) {
148 		if (key_idx >= 0 && key_idx <= 6)
149 			wpa_s->keys_cleared &= ~BIT(key_idx);
150 		else
151 			wpa_s->keys_cleared = 0;
152 	}
153 	if (wpa_s->driver->set_key) {
154 		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 	return -1;
159 }
160 
161 static inline int wpa_drv_get_seqnum(struct wpa_supplicant *wpa_s,
162 				     const u8 *addr, int idx, u8 *seq)
163 {
164 	if (wpa_s->driver->get_seqnum)
165 		return wpa_s->driver->get_seqnum(wpa_s->ifname, wpa_s->drv_priv,
166 						 addr, idx, seq);
167 	return -1;
168 }
169 
170 static inline int wpa_drv_sta_deauth(struct wpa_supplicant *wpa_s,
171 				     const u8 *addr, int reason_code)
172 {
173 	if (wpa_s->driver->sta_deauth) {
174 		return wpa_s->driver->sta_deauth(wpa_s->drv_priv,
175 						 wpa_s->own_addr, addr,
176 						 reason_code);
177 	}
178 	return -1;
179 }
180 
181 static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
182 					 const u8 *addr, int reason_code)
183 {
184 	if (wpa_s->driver->deauthenticate) {
185 		return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
186 						     reason_code);
187 	}
188 	return -1;
189 }
190 
191 static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
192 				    struct wpa_pmkid_params *params)
193 {
194 	if (wpa_s->driver->add_pmkid) {
195 		return wpa_s->driver->add_pmkid(wpa_s->drv_priv, params);
196 	}
197 	return -1;
198 }
199 
200 static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
201 				       struct wpa_pmkid_params *params)
202 {
203 	if (wpa_s->driver->remove_pmkid) {
204 		return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, params);
205 	}
206 	return -1;
207 }
208 
209 static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
210 {
211 	if (wpa_s->driver->flush_pmkid) {
212 		return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
213 	}
214 	return -1;
215 }
216 
217 static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
218 				   struct wpa_driver_capa *capa)
219 {
220 	if (wpa_s->driver->get_capa) {
221 		return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
222 	}
223 	return -1;
224 }
225 
226 static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
227 {
228 	if (wpa_s->driver->poll) {
229 		wpa_s->driver->poll(wpa_s->drv_priv);
230 	}
231 }
232 
233 static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
234 {
235 	if (wpa_s->driver->get_ifname) {
236 		return wpa_s->driver->get_ifname(wpa_s->drv_priv);
237 	}
238 	return NULL;
239 }
240 
241 static inline const char *
242 wpa_driver_get_radio_name(struct wpa_supplicant *wpa_s)
243 {
244 	if (wpa_s->driver->get_radio_name)
245 		return wpa_s->driver->get_radio_name(wpa_s->drv_priv);
246 	return NULL;
247 }
248 
249 static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
250 {
251 	if (wpa_s->driver->get_mac_addr) {
252 		return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
253 	}
254 	return NULL;
255 }
256 
257 static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
258 					int state)
259 {
260 	if (wpa_s->driver->set_operstate)
261 		return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
262 	return 0;
263 }
264 
265 static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
266 					     const u8 *addr, int protect_type,
267 					     int key_type)
268 {
269 	if (wpa_s->driver->mlme_setprotection)
270 		return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
271 							 protect_type,
272 							 key_type);
273 	return 0;
274 }
275 
276 static inline struct hostapd_hw_modes *
277 wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
278 			    u16 *flags, u8 *dfs_domain)
279 {
280 	if (wpa_s->driver->get_hw_feature_data)
281 		return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
282 							  num_modes, flags,
283 							  dfs_domain);
284 	return NULL;
285 }
286 
287 static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
288 				      const char *alpha2)
289 {
290 	if (wpa_s->driver->set_country)
291 		return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
292 	return 0;
293 }
294 
295 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 	if (wpa_s->driver->send_mlme)
300 		return wpa_s->driver->send_mlme(wpa_s->drv_priv,
301 						data, data_len, noack,
302 						freq, NULL, 0);
303 	return -1;
304 }
305 
306 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 	if (wpa_s->driver->update_ft_ies)
311 		return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
312 						    ies, ies_len);
313 	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 static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
325 				  struct hostapd_sta_add_params *params)
326 {
327 	if (wpa_s->driver->sta_add)
328 		return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
329 	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 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 	if (wpa_s->driver->sta_set_flags)
357 		return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
358 						    total_flags, flags_or,
359 						    flags_and);
360 	return -1;
361 }
362 
363 static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
364 					int authorized)
365 {
366 	if (wpa_s->driver->set_supp_port) {
367 		return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
368 						    authorized);
369 	}
370 	return 0;
371 }
372 
373 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 	if (wpa_s->driver->send_action)
382 		return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
383 						  wait, dst, src, bssid,
384 						  data, data_len, no_cck);
385 	return -1;
386 }
387 
388 static inline void wpa_drv_send_action_cancel_wait(struct wpa_supplicant *wpa_s)
389 {
390 	if (wpa_s->driver->send_action_cancel_wait)
391 		wpa_s->driver->send_action_cancel_wait(wpa_s->drv_priv);
392 }
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 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 	if (wpa_s->driver->if_add)
409 		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 	return -1;
413 }
414 
415 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 	if (wpa_s->driver->if_remove)
420 		return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
421 	return -1;
422 }
423 
424 static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
425 					    unsigned int freq,
426 					    unsigned int duration)
427 {
428 	if (wpa_s->driver->remain_on_channel)
429 		return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
430 							duration);
431 	return -1;
432 }
433 
434 static inline int wpa_drv_cancel_remain_on_channel(
435 	struct wpa_supplicant *wpa_s)
436 {
437 	if (wpa_s->driver->cancel_remain_on_channel)
438 		return wpa_s->driver->cancel_remain_on_channel(
439 			wpa_s->drv_priv);
440 	return -1;
441 }
442 
443 static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
444 					   int report)
445 {
446 	if (wpa_s->driver->probe_req_report)
447 		return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
448 						       report);
449 	return -1;
450 }
451 
452 static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
453 {
454 	if (wpa_s->driver->deinit_ap)
455 		return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
456 	return 0;
457 }
458 
459 static inline int wpa_drv_deinit_p2p_cli(struct wpa_supplicant *wpa_s)
460 {
461 	if (wpa_s->driver->deinit_p2p_cli)
462 		return wpa_s->driver->deinit_p2p_cli(wpa_s->drv_priv);
463 	return 0;
464 }
465 
466 static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
467 {
468 	if (wpa_s->driver->suspend)
469 		wpa_s->driver->suspend(wpa_s->drv_priv);
470 }
471 
472 static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
473 {
474 	if (wpa_s->driver->resume)
475 		wpa_s->driver->resume(wpa_s->drv_priv);
476 }
477 
478 static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
479 					 int threshold, int hysteresis)
480 {
481 	if (wpa_s->driver->signal_monitor)
482 		return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
483 						     threshold, hysteresis);
484 	return -1;
485 }
486 
487 static inline int wpa_drv_signal_poll(struct wpa_supplicant *wpa_s,
488 				      struct wpa_signal_info *si)
489 {
490 	if (wpa_s->driver->signal_poll)
491 		return wpa_s->driver->signal_poll(wpa_s->drv_priv, si);
492 	return -1;
493 }
494 
495 static inline int wpa_drv_pktcnt_poll(struct wpa_supplicant *wpa_s,
496 				      struct hostap_sta_driver_data *sta)
497 {
498 	if (wpa_s->driver->read_sta_data)
499 		return wpa_s->driver->read_sta_data(wpa_s->drv_priv, sta,
500 						    wpa_s->bssid);
501 	return -1;
502 }
503 
504 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 	if (!wpa_s->driver->set_ap_wps_ie)
510 		return -1;
511 	return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
512 					    proberesp, assocresp);
513 }
514 
515 static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
516 				  u8 *buf, size_t buf_len)
517 {
518 	if (!wpa_s->driver->get_noa)
519 		return -1;
520 	return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
521 }
522 
523 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 	if (!wpa_s->driver->set_p2p_powersave)
528 		return -1;
529 	return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
530 						opp_ps, ctwindow);
531 }
532 
533 static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
534 {
535 	if (!wpa_s->driver->ampdu)
536 		return -1;
537 	return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
538 }
539 
540 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 	if (wpa_s->driver->send_tdls_mgmt) {
547 		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 	return -1;
553 }
554 
555 static inline int wpa_drv_tdls_oper(struct wpa_supplicant *wpa_s,
556 				    enum tdls_oper oper, const u8 *peer)
557 {
558 	if (!wpa_s->driver->tdls_oper)
559 		return -1;
560 	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 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 	if (!wpa_s->driver->set_rekey_info)
579 		return;
580 	wpa_s->driver->set_rekey_info(wpa_s->drv_priv, kek, kek_len,
581 				      kck, kck_len, replay_ctr);
582 }
583 
584 static inline int wpa_drv_radio_disable(struct wpa_supplicant *wpa_s,
585 					int disabled)
586 {
587 	if (!wpa_s->driver->radio_disable)
588 		return -1;
589 	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 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 	if (!wpa_s->driver->add_tx_ts)
605 		return -1;
606 	return wpa_s->driver->add_tx_ts(wpa_s->drv_priv, tsid, address,
607 					user_priority, admitted_time);
608 }
609 
610 static inline int wpa_drv_del_ts(struct wpa_supplicant *wpa_s, u8 tid,
611 				 const u8 *address)
612 {
613 	if (!wpa_s->driver->del_tx_ts)
614 		return -1;
615 	return wpa_s->driver->del_tx_ts(wpa_s->drv_priv, tid, address);
616 }
617 
618 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 	if (!wpa_s->driver->tdls_enable_channel_switch)
623 		return -1;
624 	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 wpa_drv_tdls_disable_channel_switch(struct wpa_supplicant *wpa_s,
631 				    const u8 *addr)
632 {
633 	if (!wpa_s->driver->tdls_disable_channel_switch)
634 		return -1;
635 	return wpa_s->driver->tdls_disable_channel_switch(wpa_s->drv_priv,
636 							  addr);
637 }
638 
639 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 	if (!wpa_s->driver->wnm_oper)
644 		return -1;
645 	return wpa_s->driver->wnm_oper(wpa_s->drv_priv, oper, peer, buf,
646 				       buf_len);
647 }
648 
649 static inline int wpa_drv_status(struct wpa_supplicant *wpa_s,
650 				 char *buf, size_t buflen)
651 {
652 	if (!wpa_s->driver->status)
653 		return -1;
654 	return wpa_s->driver->status(wpa_s->drv_priv, buf, buflen);
655 }
656 
657 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 	if (!wpa_s->driver->set_qos_map)
661 		return -1;
662 	return wpa_s->driver->set_qos_map(wpa_s->drv_priv, qos_map_set,
663 					  qos_map_set_len);
664 }
665 
666 static inline int wpa_drv_wowlan(struct wpa_supplicant *wpa_s,
667 				 const struct wowlan_triggers *triggers)
668 {
669 	if (!wpa_s->driver->set_wowlan)
670 		return -1;
671 	return wpa_s->driver->set_wowlan(wpa_s->drv_priv, triggers);
672 }
673 
674 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 	if (!wpa_s->driver->vendor_cmd)
679 		return -1;
680 	return wpa_s->driver->vendor_cmd(wpa_s->drv_priv, vendor_id, subcmd,
681 					 data, data_len, buf);
682 }
683 
684 static inline int wpa_drv_roaming(struct wpa_supplicant *wpa_s, int allowed,
685 				  const u8 *bssid)
686 {
687 	if (!wpa_s->driver->roaming)
688 		return -1;
689 	return wpa_s->driver->roaming(wpa_s->drv_priv, allowed, bssid);
690 }
691 
692 static inline int wpa_drv_disable_fils(struct wpa_supplicant *wpa_s,
693 				       int disable)
694 {
695 	if (!wpa_s->driver->disable_fils)
696 		return -1;
697 	return wpa_s->driver->disable_fils(wpa_s->drv_priv, disable);
698 }
699 
700 static inline int wpa_drv_set_mac_addr(struct wpa_supplicant *wpa_s,
701 				       const u8 *addr)
702 {
703 	if (!wpa_s->driver->set_mac_addr)
704 		return -1;
705 	return wpa_s->driver->set_mac_addr(wpa_s->drv_priv, addr);
706 }
707 
708 
709 #ifdef CONFIG_MACSEC
710 
711 static inline int wpa_drv_macsec_init(struct wpa_supplicant *wpa_s,
712 				      struct macsec_init_params *params)
713 {
714 	if (!wpa_s->driver->macsec_init)
715 		return -1;
716 	return wpa_s->driver->macsec_init(wpa_s->drv_priv, params);
717 }
718 
719 static inline int wpa_drv_macsec_deinit(struct wpa_supplicant *wpa_s)
720 {
721 	if (!wpa_s->driver->macsec_deinit)
722 		return -1;
723 	return wpa_s->driver->macsec_deinit(wpa_s->drv_priv);
724 }
725 
726 static inline int wpa_drv_macsec_get_capability(struct wpa_supplicant *wpa_s,
727 						enum macsec_cap *cap)
728 {
729 	if (!wpa_s->driver->macsec_get_capability)
730 		return -1;
731 	return wpa_s->driver->macsec_get_capability(wpa_s->drv_priv, cap);
732 }
733 
734 static inline int wpa_drv_enable_protect_frames(struct wpa_supplicant *wpa_s,
735 						Boolean enabled)
736 {
737 	if (!wpa_s->driver->enable_protect_frames)
738 		return -1;
739 	return wpa_s->driver->enable_protect_frames(wpa_s->drv_priv, enabled);
740 }
741 
742 static inline int wpa_drv_enable_encrypt(struct wpa_supplicant *wpa_s,
743 						Boolean enabled)
744 {
745 	if (!wpa_s->driver->enable_encrypt)
746 		return -1;
747 	return wpa_s->driver->enable_encrypt(wpa_s->drv_priv, enabled);
748 }
749 
750 static inline int wpa_drv_set_replay_protect(struct wpa_supplicant *wpa_s,
751 					     Boolean enabled, u32 window)
752 {
753 	if (!wpa_s->driver->set_replay_protect)
754 		return -1;
755 	return wpa_s->driver->set_replay_protect(wpa_s->drv_priv, enabled,
756 						 window);
757 }
758 
759 static inline int wpa_drv_set_current_cipher_suite(struct wpa_supplicant *wpa_s,
760 						   u64 cs)
761 {
762 	if (!wpa_s->driver->set_current_cipher_suite)
763 		return -1;
764 	return wpa_s->driver->set_current_cipher_suite(wpa_s->drv_priv, cs);
765 }
766 
767 static inline int wpa_drv_enable_controlled_port(struct wpa_supplicant *wpa_s,
768 						 Boolean enabled)
769 {
770 	if (!wpa_s->driver->enable_controlled_port)
771 		return -1;
772 	return wpa_s->driver->enable_controlled_port(wpa_s->drv_priv, enabled);
773 }
774 
775 static inline int wpa_drv_get_receive_lowest_pn(struct wpa_supplicant *wpa_s,
776 						struct receive_sa *sa)
777 {
778 	if (!wpa_s->driver->get_receive_lowest_pn)
779 		return -1;
780 	return wpa_s->driver->get_receive_lowest_pn(wpa_s->drv_priv, sa);
781 }
782 
783 static inline int wpa_drv_get_transmit_next_pn(struct wpa_supplicant *wpa_s,
784 						struct transmit_sa *sa)
785 {
786 	if (!wpa_s->driver->get_transmit_next_pn)
787 		return -1;
788 	return wpa_s->driver->get_transmit_next_pn(wpa_s->drv_priv, sa);
789 }
790 
791 static inline int wpa_drv_set_transmit_next_pn(struct wpa_supplicant *wpa_s,
792 						struct transmit_sa *sa)
793 {
794 	if (!wpa_s->driver->set_transmit_next_pn)
795 		return -1;
796 	return wpa_s->driver->set_transmit_next_pn(wpa_s->drv_priv, sa);
797 }
798 
799 static inline int
800 wpa_drv_create_receive_sc(struct wpa_supplicant *wpa_s, struct receive_sc *sc,
801 			  unsigned int conf_offset, int validation)
802 {
803 	if (!wpa_s->driver->create_receive_sc)
804 		return -1;
805 	return wpa_s->driver->create_receive_sc(wpa_s->drv_priv, sc,
806 						conf_offset, validation);
807 }
808 
809 static inline int wpa_drv_delete_receive_sc(struct wpa_supplicant *wpa_s,
810 					    struct receive_sc *sc)
811 {
812 	if (!wpa_s->driver->delete_receive_sc)
813 		return -1;
814 	return wpa_s->driver->delete_receive_sc(wpa_s->drv_priv, sc);
815 }
816 
817 static inline int wpa_drv_create_receive_sa(struct wpa_supplicant *wpa_s,
818 					    struct receive_sa *sa)
819 {
820 	if (!wpa_s->driver->create_receive_sa)
821 		return -1;
822 	return wpa_s->driver->create_receive_sa(wpa_s->drv_priv, sa);
823 }
824 
825 static inline int wpa_drv_delete_receive_sa(struct wpa_supplicant *wpa_s,
826 					    struct receive_sa *sa)
827 {
828 	if (!wpa_s->driver->delete_receive_sa)
829 		return -1;
830 	return wpa_s->driver->delete_receive_sa(wpa_s->drv_priv, sa);
831 }
832 
833 static inline int wpa_drv_enable_receive_sa(struct wpa_supplicant *wpa_s,
834 					    struct receive_sa *sa)
835 {
836 	if (!wpa_s->driver->enable_receive_sa)
837 		return -1;
838 	return wpa_s->driver->enable_receive_sa(wpa_s->drv_priv, sa);
839 }
840 
841 static inline int wpa_drv_disable_receive_sa(struct wpa_supplicant *wpa_s,
842 					     struct receive_sa *sa)
843 {
844 	if (!wpa_s->driver->disable_receive_sa)
845 		return -1;
846 	return wpa_s->driver->disable_receive_sa(wpa_s->drv_priv, sa);
847 }
848 
849 static inline int
850 wpa_drv_create_transmit_sc(struct wpa_supplicant *wpa_s, struct transmit_sc *sc,
851 			   unsigned int conf_offset)
852 {
853 	if (!wpa_s->driver->create_transmit_sc)
854 		return -1;
855 	return wpa_s->driver->create_transmit_sc(wpa_s->drv_priv, sc,
856 						 conf_offset);
857 }
858 
859 static inline int wpa_drv_delete_transmit_sc(struct wpa_supplicant *wpa_s,
860 					     struct transmit_sc *sc)
861 {
862 	if (!wpa_s->driver->delete_transmit_sc)
863 		return -1;
864 	return wpa_s->driver->delete_transmit_sc(wpa_s->drv_priv, sc);
865 }
866 
867 static inline int wpa_drv_create_transmit_sa(struct wpa_supplicant *wpa_s,
868 					     struct transmit_sa *sa)
869 {
870 	if (!wpa_s->driver->create_transmit_sa)
871 		return -1;
872 	return wpa_s->driver->create_transmit_sa(wpa_s->drv_priv, sa);
873 }
874 
875 static inline int wpa_drv_delete_transmit_sa(struct wpa_supplicant *wpa_s,
876 					     struct transmit_sa *sa)
877 {
878 	if (!wpa_s->driver->delete_transmit_sa)
879 		return -1;
880 	return wpa_s->driver->delete_transmit_sa(wpa_s->drv_priv, sa);
881 }
882 
883 static inline int wpa_drv_enable_transmit_sa(struct wpa_supplicant *wpa_s,
884 					     struct transmit_sa *sa)
885 {
886 	if (!wpa_s->driver->enable_transmit_sa)
887 		return -1;
888 	return wpa_s->driver->enable_transmit_sa(wpa_s->drv_priv, sa);
889 }
890 
891 static inline int wpa_drv_disable_transmit_sa(struct wpa_supplicant *wpa_s,
892 					      struct transmit_sa *sa)
893 {
894 	if (!wpa_s->driver->disable_transmit_sa)
895 		return -1;
896 	return wpa_s->driver->disable_transmit_sa(wpa_s->drv_priv, sa);
897 }
898 #endif /* CONFIG_MACSEC */
899 
900 static inline int wpa_drv_setband(struct wpa_supplicant *wpa_s,
901 				  enum set_band band)
902 {
903 	if (!wpa_s->driver->set_band)
904 		return -1;
905 	return wpa_s->driver->set_band(wpa_s->drv_priv, band);
906 }
907 
908 static inline int wpa_drv_get_pref_freq_list(struct wpa_supplicant *wpa_s,
909 					     enum wpa_driver_if_type if_type,
910 					     unsigned int *num,
911 					     unsigned int *freq_list)
912 {
913 #ifdef CONFIG_TESTING_OPTIONS
914 	if (wpa_s->get_pref_freq_list_override)
915 		return wpas_ctrl_iface_get_pref_freq_list_override(
916 			wpa_s, if_type, num, freq_list);
917 #endif /* CONFIG_TESTING_OPTIONS */
918 	if (!wpa_s->driver->get_pref_freq_list)
919 		return -1;
920 	return wpa_s->driver->get_pref_freq_list(wpa_s->drv_priv, if_type,
921 						 num, freq_list);
922 }
923 
924 static inline int wpa_drv_set_prob_oper_freq(struct wpa_supplicant *wpa_s,
925 					     unsigned int freq)
926 {
927 	if (!wpa_s->driver->set_prob_oper_freq)
928 		return 0;
929 	return wpa_s->driver->set_prob_oper_freq(wpa_s->drv_priv, freq);
930 }
931 
932 static inline int wpa_drv_abort_scan(struct wpa_supplicant *wpa_s,
933 				     u64 scan_cookie)
934 {
935 	if (!wpa_s->driver->abort_scan)
936 		return -1;
937 	return wpa_s->driver->abort_scan(wpa_s->drv_priv, scan_cookie);
938 }
939 
940 static inline int wpa_drv_configure_frame_filters(struct wpa_supplicant *wpa_s,
941 						  u32 filters)
942 {
943 	if (!wpa_s->driver->configure_data_frame_filters)
944 		return -1;
945 	return wpa_s->driver->configure_data_frame_filters(wpa_s->drv_priv,
946 							   filters);
947 }
948 
949 static inline int wpa_drv_get_ext_capa(struct wpa_supplicant *wpa_s,
950 				       enum wpa_driver_if_type type)
951 {
952 	if (!wpa_s->driver->get_ext_capab)
953 		return -1;
954 	return wpa_s->driver->get_ext_capab(wpa_s->drv_priv, type,
955 					    &wpa_s->extended_capa,
956 					    &wpa_s->extended_capa_mask,
957 					    &wpa_s->extended_capa_len);
958 }
959 
960 static inline int wpa_drv_p2p_lo_start(struct wpa_supplicant *wpa_s,
961 				       unsigned int channel,
962 				       unsigned int period,
963 				       unsigned int interval,
964 				       unsigned int count,
965 				       const u8 *device_types,
966 				       size_t dev_types_len,
967 				       const u8 *ies, size_t ies_len)
968 {
969 	if (!wpa_s->driver->p2p_lo_start)
970 		return -1;
971 	return wpa_s->driver->p2p_lo_start(wpa_s->drv_priv, channel, period,
972 					   interval, count, device_types,
973 					   dev_types_len, ies, ies_len);
974 }
975 
976 static inline int wpa_drv_p2p_lo_stop(struct wpa_supplicant *wpa_s)
977 {
978 	if (!wpa_s->driver->p2p_lo_stop)
979 		return -1;
980 	return wpa_s->driver->p2p_lo_stop(wpa_s->drv_priv);
981 }
982 
983 static inline int wpa_drv_set_default_scan_ies(struct wpa_supplicant *wpa_s,
984 					       const u8 *ies, size_t len)
985 {
986 	if (!wpa_s->driver->set_default_scan_ies)
987 		return -1;
988 	return wpa_s->driver->set_default_scan_ies(wpa_s->drv_priv, ies, len);
989 }
990 
991 static inline int wpa_drv_set_tdls_mode(struct wpa_supplicant *wpa_s,
992 					int tdls_external_control)
993 {
994 	if (!wpa_s->driver->set_tdls_mode)
995 		return -1;
996 	return wpa_s->driver->set_tdls_mode(wpa_s->drv_priv,
997 					    tdls_external_control);
998 }
999 
1000 static inline struct wpa_bss_candidate_info *
1001 wpa_drv_get_bss_trans_status(struct wpa_supplicant *wpa_s,
1002 			     struct wpa_bss_trans_info *params)
1003 {
1004 	if (!wpa_s->driver->get_bss_transition_status)
1005 		return NULL;
1006 	return wpa_s->driver->get_bss_transition_status(wpa_s->drv_priv,
1007 							params);
1008 }
1009 
1010 static inline int wpa_drv_ignore_assoc_disallow(struct wpa_supplicant *wpa_s,
1011 						int val)
1012 {
1013 	if (!wpa_s->driver->ignore_assoc_disallow)
1014 		return -1;
1015 	return wpa_s->driver->ignore_assoc_disallow(wpa_s->drv_priv, val);
1016 }
1017 
1018 static inline int wpa_drv_set_bssid_blacklist(struct wpa_supplicant *wpa_s,
1019 					      unsigned int num_bssid,
1020 					      const u8 *bssids)
1021 {
1022 	if (!wpa_s->driver->set_bssid_blacklist)
1023 		return -1;
1024 	return wpa_s->driver->set_bssid_blacklist(wpa_s->drv_priv, num_bssid,
1025 						  bssids);
1026 }
1027 
1028 static inline int wpa_drv_update_connect_params(
1029 	struct wpa_supplicant *wpa_s,
1030 	struct wpa_driver_associate_params *params,
1031 	enum wpa_drv_update_connect_params_mask mask)
1032 {
1033 	if (!wpa_s->driver->update_connect_params)
1034 		return -1;
1035 	return wpa_s->driver->update_connect_params(wpa_s->drv_priv, params,
1036 						    mask);
1037 }
1038 
1039 static inline int
1040 wpa_drv_send_external_auth_status(struct wpa_supplicant *wpa_s,
1041 				  struct external_auth *params)
1042 {
1043 	if (!wpa_s->driver->send_external_auth_status)
1044 		return -1;
1045 	return wpa_s->driver->send_external_auth_status(wpa_s->drv_priv,
1046 							params);
1047 }
1048 
1049 #endif /* DRIVER_I_H */
1050