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 				    const u8 *bssid, const u8 *pmkid)
193 {
194 	if (wpa_s->driver->add_pmkid) {
195 		return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
196 	}
197 	return -1;
198 }
199 
200 static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
201 				       const u8 *bssid, const u8 *pmkid)
202 {
203 	if (wpa_s->driver->remove_pmkid) {
204 		return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
205 						   pmkid);
206 	}
207 	return -1;
208 }
209 
210 static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
211 {
212 	if (wpa_s->driver->flush_pmkid) {
213 		return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
214 	}
215 	return -1;
216 }
217 
218 static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
219 				   struct wpa_driver_capa *capa)
220 {
221 	if (wpa_s->driver->get_capa) {
222 		return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
223 	}
224 	return -1;
225 }
226 
227 static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
228 {
229 	if (wpa_s->driver->poll) {
230 		wpa_s->driver->poll(wpa_s->drv_priv);
231 	}
232 }
233 
234 static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
235 {
236 	if (wpa_s->driver->get_ifname) {
237 		return wpa_s->driver->get_ifname(wpa_s->drv_priv);
238 	}
239 	return NULL;
240 }
241 
242 static inline const char *
243 wpa_driver_get_radio_name(struct wpa_supplicant *wpa_s)
244 {
245 	if (wpa_s->driver->get_radio_name)
246 		return wpa_s->driver->get_radio_name(wpa_s->drv_priv);
247 	return NULL;
248 }
249 
250 static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
251 {
252 	if (wpa_s->driver->get_mac_addr) {
253 		return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
254 	}
255 	return NULL;
256 }
257 
258 static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
259 					int state)
260 {
261 	if (wpa_s->driver->set_operstate)
262 		return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
263 	return 0;
264 }
265 
266 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 	if (wpa_s->driver->mlme_setprotection)
271 		return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
272 							 protect_type,
273 							 key_type);
274 	return 0;
275 }
276 
277 static inline struct hostapd_hw_modes *
278 wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
279 			    u16 *flags)
280 {
281 	if (wpa_s->driver->get_hw_feature_data)
282 		return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
283 							  num_modes, flags);
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_set_mac_addr(struct wpa_supplicant *wpa_s,
693 				       const u8 *addr)
694 {
695 	if (!wpa_s->driver->set_mac_addr)
696 		return -1;
697 	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 static inline int wpa_drv_setband(struct wpa_supplicant *wpa_s,
895 				  enum set_band band)
896 {
897 	if (!wpa_s->driver->set_band)
898 		return -1;
899 	return wpa_s->driver->set_band(wpa_s->drv_priv, band);
900 }
901 
902 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 	if (!wpa_s->driver->get_pref_freq_list)
908 		return -1;
909 	return wpa_s->driver->get_pref_freq_list(wpa_s->drv_priv, if_type,
910 						 num, freq_list);
911 }
912 
913 static inline int wpa_drv_set_prob_oper_freq(struct wpa_supplicant *wpa_s,
914 					     unsigned int freq)
915 {
916 	if (!wpa_s->driver->set_prob_oper_freq)
917 		return 0;
918 	return wpa_s->driver->set_prob_oper_freq(wpa_s->drv_priv, freq);
919 }
920 
921 static inline int wpa_drv_abort_scan(struct wpa_supplicant *wpa_s)
922 {
923 	if (!wpa_s->driver->abort_scan)
924 		return -1;
925 	return wpa_s->driver->abort_scan(wpa_s->drv_priv);
926 }
927 
928 static inline int wpa_drv_configure_frame_filters(struct wpa_supplicant *wpa_s,
929 						  u32 filters)
930 {
931 	if (!wpa_s->driver->configure_data_frame_filters)
932 		return -1;
933 	return wpa_s->driver->configure_data_frame_filters(wpa_s->drv_priv,
934 							   filters);
935 }
936 
937 static inline int wpa_drv_get_ext_capa(struct wpa_supplicant *wpa_s,
938 				       enum wpa_driver_if_type type)
939 {
940 	if (!wpa_s->driver->get_ext_capab)
941 		return -1;
942 	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 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 	if (!wpa_s->driver->p2p_lo_start)
958 		return -1;
959 	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 static inline int wpa_drv_p2p_lo_stop(struct wpa_supplicant *wpa_s)
965 {
966 	if (!wpa_s->driver->p2p_lo_stop)
967 		return -1;
968 	return wpa_s->driver->p2p_lo_stop(wpa_s->drv_priv);
969 }
970 
971 static inline int wpa_drv_set_default_scan_ies(struct wpa_supplicant *wpa_s,
972 					       const u8 *ies, size_t len)
973 {
974 	if (!wpa_s->driver->set_default_scan_ies)
975 		return -1;
976 	return wpa_s->driver->set_default_scan_ies(wpa_s->drv_priv, ies, len);
977 }
978 
979 #endif /* DRIVER_I_H */
980