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 */
15static 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
27static 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
33static 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
41static 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
51static 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
59static 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
68static 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
75static 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
83static 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
90static inline int wpa_drv_mesh_link_probe(struct wpa_supplicant *wpa_s,
91					  const u8 *addr,
92					  const u8 *eth, size_t len)
93{
94	if (wpa_s->driver->probe_mesh_link)
95		return wpa_s->driver->probe_mesh_link(wpa_s->drv_priv, addr,
96						      eth, len);
97	return -1;
98}
99
100static inline int wpa_drv_scan(struct wpa_supplicant *wpa_s,
101			       struct wpa_driver_scan_params *params)
102{
103#ifdef CONFIG_TESTING_OPTIONS
104	if (wpa_s->test_failure == WPAS_TEST_FAILURE_SCAN_TRIGGER)
105		return -EBUSY;
106#endif /* CONFIG_TESTING_OPTIONS */
107	if (wpa_s->driver->scan2)
108		return wpa_s->driver->scan2(wpa_s->drv_priv, params);
109	return -1;
110}
111
112static inline int wpa_drv_sched_scan(struct wpa_supplicant *wpa_s,
113				     struct wpa_driver_scan_params *params)
114{
115	if (wpa_s->driver->sched_scan)
116		return wpa_s->driver->sched_scan(wpa_s->drv_priv, params);
117	return -1;
118}
119
120static inline int wpa_drv_stop_sched_scan(struct wpa_supplicant *wpa_s)
121{
122	if (wpa_s->driver->stop_sched_scan)
123		return wpa_s->driver->stop_sched_scan(wpa_s->drv_priv);
124	return -1;
125}
126
127static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
128	struct wpa_supplicant *wpa_s)
129{
130	if (wpa_s->driver->get_scan_results2)
131		return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
132	return NULL;
133}
134
135static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid)
136{
137	if (wpa_s->driver->get_bssid) {
138		return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
139	}
140	return -1;
141}
142
143static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid)
144{
145	if (wpa_s->driver->get_ssid) {
146		return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
147	}
148	return -1;
149}
150
151static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s,
152				  enum wpa_alg alg, const u8 *addr,
153				  int key_idx, int set_tx,
154				  const u8 *seq, size_t seq_len,
155				  const u8 *key, size_t key_len)
156{
157	if (alg != WPA_ALG_NONE) {
158		if (key_idx >= 0 && key_idx <= 6)
159			wpa_s->keys_cleared &= ~BIT(key_idx);
160		else
161			wpa_s->keys_cleared = 0;
162	}
163	if (wpa_s->driver->set_key) {
164		return wpa_s->driver->set_key(wpa_s->ifname, wpa_s->drv_priv,
165					      alg, addr, key_idx, set_tx,
166					      seq, seq_len, key, key_len);
167	}
168	return -1;
169}
170
171static inline int wpa_drv_get_seqnum(struct wpa_supplicant *wpa_s,
172				     const u8 *addr, int idx, u8 *seq)
173{
174	if (wpa_s->driver->get_seqnum)
175		return wpa_s->driver->get_seqnum(wpa_s->ifname, wpa_s->drv_priv,
176						 addr, idx, seq);
177	return -1;
178}
179
180static inline int wpa_drv_sta_deauth(struct wpa_supplicant *wpa_s,
181				     const u8 *addr, u16 reason_code)
182{
183	if (wpa_s->driver->sta_deauth) {
184		return wpa_s->driver->sta_deauth(wpa_s->drv_priv,
185						 wpa_s->own_addr, addr,
186						 reason_code);
187	}
188	return -1;
189}
190
191static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
192					 const u8 *addr, u16 reason_code)
193{
194	if (wpa_s->driver->deauthenticate) {
195		return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
196						     reason_code);
197	}
198	return -1;
199}
200
201static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
202				    struct wpa_pmkid_params *params)
203{
204	if (wpa_s->driver->add_pmkid) {
205		return wpa_s->driver->add_pmkid(wpa_s->drv_priv, params);
206	}
207	return -1;
208}
209
210static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
211				       struct wpa_pmkid_params *params)
212{
213	if (wpa_s->driver->remove_pmkid) {
214		return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, params);
215	}
216	return -1;
217}
218
219static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
220{
221	if (wpa_s->driver->flush_pmkid) {
222		return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
223	}
224	return -1;
225}
226
227static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
228				   struct wpa_driver_capa *capa)
229{
230	if (wpa_s->driver->get_capa) {
231		return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
232	}
233	return -1;
234}
235
236static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
237{
238	if (wpa_s->driver->poll) {
239		wpa_s->driver->poll(wpa_s->drv_priv);
240	}
241}
242
243static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
244{
245	if (wpa_s->driver->get_ifname) {
246		return wpa_s->driver->get_ifname(wpa_s->drv_priv);
247	}
248	return NULL;
249}
250
251static inline const char *
252wpa_driver_get_radio_name(struct wpa_supplicant *wpa_s)
253{
254	if (wpa_s->driver->get_radio_name)
255		return wpa_s->driver->get_radio_name(wpa_s->drv_priv);
256	return NULL;
257}
258
259static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
260{
261	if (wpa_s->driver->get_mac_addr) {
262		return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
263	}
264	return NULL;
265}
266
267static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
268					int state)
269{
270	if (wpa_s->driver->set_operstate)
271		return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
272	return 0;
273}
274
275static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
276					     const u8 *addr, int protect_type,
277					     int key_type)
278{
279	if (wpa_s->driver->mlme_setprotection)
280		return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
281							 protect_type,
282							 key_type);
283	return 0;
284}
285
286static inline struct hostapd_hw_modes *
287wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
288			    u16 *flags, u8 *dfs_domain)
289{
290	if (wpa_s->driver->get_hw_feature_data)
291		return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
292							  num_modes, flags,
293							  dfs_domain);
294	return NULL;
295}
296
297static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
298				      const char *alpha2)
299{
300	if (wpa_s->driver->set_country)
301		return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
302	return 0;
303}
304
305static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
306				    const u8 *data, size_t data_len, int noack,
307				    unsigned int freq)
308{
309	if (wpa_s->driver->send_mlme)
310		return wpa_s->driver->send_mlme(wpa_s->drv_priv,
311						data, data_len, noack,
312						freq, NULL, 0);
313	return -1;
314}
315
316static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
317					const u8 *md,
318					const u8 *ies, size_t ies_len)
319{
320	if (wpa_s->driver->update_ft_ies)
321		return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
322						    ies, ies_len);
323	return -1;
324}
325
326static inline int wpa_drv_set_ap(struct wpa_supplicant *wpa_s,
327				 struct wpa_driver_ap_params *params)
328{
329	if (wpa_s->driver->set_ap)
330		return wpa_s->driver->set_ap(wpa_s->drv_priv, params);
331	return -1;
332}
333
334static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
335				  struct hostapd_sta_add_params *params)
336{
337	if (wpa_s->driver->sta_add)
338		return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
339	return -1;
340}
341
342static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
343				     const u8 *addr)
344{
345	if (wpa_s->driver->sta_remove)
346		return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
347	return -1;
348}
349
350static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
351					  const u8 *addr, const u8 *data,
352					  size_t data_len, int encrypt,
353					  const u8 *own_addr, u32 flags)
354{
355	if (wpa_s->driver->hapd_send_eapol)
356		return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
357						      data, data_len, encrypt,
358						      own_addr, flags);
359	return -1;
360}
361
362static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
363					const u8 *addr, int total_flags,
364					int flags_or, int flags_and)
365{
366	if (wpa_s->driver->sta_set_flags)
367		return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
368						    total_flags, flags_or,
369						    flags_and);
370	return -1;
371}
372
373static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
374					int authorized)
375{
376	if (wpa_s->driver->set_supp_port) {
377		return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
378						    authorized);
379	}
380	return 0;
381}
382
383static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
384				      unsigned int freq,
385				      unsigned int wait,
386				      const u8 *dst, const u8 *src,
387				      const u8 *bssid,
388				      const u8 *data, size_t data_len,
389				      int no_cck)
390{
391	if (wpa_s->driver->send_action)
392		return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
393						  wait, dst, src, bssid,
394						  data, data_len, no_cck);
395	return -1;
396}
397
398static inline void wpa_drv_send_action_cancel_wait(struct wpa_supplicant *wpa_s)
399{
400	if (wpa_s->driver->send_action_cancel_wait)
401		wpa_s->driver->send_action_cancel_wait(wpa_s->drv_priv);
402}
403
404static inline int wpa_drv_set_freq(struct wpa_supplicant *wpa_s,
405				   struct hostapd_freq_params *freq)
406{
407	if (wpa_s->driver->set_freq)
408		return wpa_s->driver->set_freq(wpa_s->drv_priv, freq);
409	return -1;
410}
411
412static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
413				 enum wpa_driver_if_type type,
414				 const char *ifname, const u8 *addr,
415				 void *bss_ctx, char *force_ifname,
416				 u8 *if_addr, const char *bridge)
417{
418	if (wpa_s->driver->if_add)
419		return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
420					     addr, bss_ctx, NULL, force_ifname,
421					     if_addr, bridge, 0, 0);
422	return -1;
423}
424
425static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
426				    enum wpa_driver_if_type type,
427				    const char *ifname)
428{
429	if (wpa_s->driver->if_remove)
430		return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
431	return -1;
432}
433
434static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
435					    unsigned int freq,
436					    unsigned int duration)
437{
438	if (wpa_s->driver->remain_on_channel)
439		return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
440							duration);
441	return -1;
442}
443
444static inline int wpa_drv_cancel_remain_on_channel(
445	struct wpa_supplicant *wpa_s)
446{
447	if (wpa_s->driver->cancel_remain_on_channel)
448		return wpa_s->driver->cancel_remain_on_channel(
449			wpa_s->drv_priv);
450	return -1;
451}
452
453static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
454					   int report)
455{
456	if (wpa_s->driver->probe_req_report)
457		return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
458						       report);
459	return -1;
460}
461
462static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
463{
464	if (wpa_s->driver->deinit_ap)
465		return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
466	return 0;
467}
468
469static inline int wpa_drv_deinit_p2p_cli(struct wpa_supplicant *wpa_s)
470{
471	if (wpa_s->driver->deinit_p2p_cli)
472		return wpa_s->driver->deinit_p2p_cli(wpa_s->drv_priv);
473	return 0;
474}
475
476static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
477{
478	if (wpa_s->driver->suspend)
479		wpa_s->driver->suspend(wpa_s->drv_priv);
480}
481
482static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
483{
484	if (wpa_s->driver->resume)
485		wpa_s->driver->resume(wpa_s->drv_priv);
486}
487
488static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
489					 int threshold, int hysteresis)
490{
491	if (wpa_s->driver->signal_monitor)
492		return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
493						     threshold, hysteresis);
494	return -1;
495}
496
497static inline int wpa_drv_signal_poll(struct wpa_supplicant *wpa_s,
498				      struct wpa_signal_info *si)
499{
500	if (wpa_s->driver->signal_poll)
501		return wpa_s->driver->signal_poll(wpa_s->drv_priv, si);
502	return -1;
503}
504
505static inline int wpa_drv_channel_info(struct wpa_supplicant *wpa_s,
506				       struct wpa_channel_info *ci)
507{
508	if (wpa_s->driver->channel_info)
509		return wpa_s->driver->channel_info(wpa_s->drv_priv, ci);
510	return -1;
511}
512
513static inline int wpa_drv_pktcnt_poll(struct wpa_supplicant *wpa_s,
514				      struct hostap_sta_driver_data *sta)
515{
516	if (wpa_s->driver->read_sta_data)
517		return wpa_s->driver->read_sta_data(wpa_s->drv_priv, sta,
518						    wpa_s->bssid);
519	return -1;
520}
521
522static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
523					const struct wpabuf *beacon,
524					const struct wpabuf *proberesp,
525					const struct wpabuf *assocresp)
526{
527	if (!wpa_s->driver->set_ap_wps_ie)
528		return -1;
529	return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
530					    proberesp, assocresp);
531}
532
533static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
534				  u8 *buf, size_t buf_len)
535{
536	if (!wpa_s->driver->get_noa)
537		return -1;
538	return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
539}
540
541static inline int wpa_drv_set_p2p_powersave(struct wpa_supplicant *wpa_s,
542					    int legacy_ps, int opp_ps,
543					    int ctwindow)
544{
545	if (!wpa_s->driver->set_p2p_powersave)
546		return -1;
547	return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
548						opp_ps, ctwindow);
549}
550
551static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
552{
553	if (!wpa_s->driver->ampdu)
554		return -1;
555	return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
556}
557
558static inline int wpa_drv_send_tdls_mgmt(struct wpa_supplicant *wpa_s,
559					 const u8 *dst, u8 action_code,
560					 u8 dialog_token, u16 status_code,
561					 u32 peer_capab, int initiator,
562					 const u8 *buf, size_t len)
563{
564	if (wpa_s->driver->send_tdls_mgmt) {
565		return wpa_s->driver->send_tdls_mgmt(wpa_s->drv_priv, dst,
566						     action_code, dialog_token,
567						     status_code, peer_capab,
568						     initiator, buf, len);
569	}
570	return -1;
571}
572
573static inline int wpa_drv_tdls_oper(struct wpa_supplicant *wpa_s,
574				    enum tdls_oper oper, const u8 *peer)
575{
576	if (!wpa_s->driver->tdls_oper)
577		return -1;
578	return wpa_s->driver->tdls_oper(wpa_s->drv_priv, oper, peer);
579}
580
581#ifdef ANDROID
582static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
583				     char *cmd, char *buf, size_t buf_len)
584{
585	if (!wpa_s->driver->driver_cmd)
586		return -1;
587	return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
588}
589#endif /* ANDROID */
590
591static inline void wpa_drv_set_rekey_info(struct wpa_supplicant *wpa_s,
592					  const u8 *kek, size_t kek_len,
593					  const u8 *kck, size_t kck_len,
594					  const u8 *replay_ctr)
595{
596	if (!wpa_s->driver->set_rekey_info)
597		return;
598	wpa_s->driver->set_rekey_info(wpa_s->drv_priv, kek, kek_len,
599				      kck, kck_len, replay_ctr);
600}
601
602static inline int wpa_drv_radio_disable(struct wpa_supplicant *wpa_s,
603					int disabled)
604{
605	if (!wpa_s->driver->radio_disable)
606		return -1;
607	return wpa_s->driver->radio_disable(wpa_s->drv_priv, disabled);
608}
609
610static inline int wpa_drv_switch_channel(struct wpa_supplicant *wpa_s,
611					 struct csa_settings *settings)
612{
613	if (!wpa_s->driver->switch_channel)
614		return -1;
615	return wpa_s->driver->switch_channel(wpa_s->drv_priv, settings);
616}
617
618static inline int wpa_drv_add_ts(struct wpa_supplicant *wpa_s, u8 tsid,
619				 const u8 *address, u8 user_priority,
620				 u16 admitted_time)
621{
622	if (!wpa_s->driver->add_tx_ts)
623		return -1;
624	return wpa_s->driver->add_tx_ts(wpa_s->drv_priv, tsid, address,
625					user_priority, admitted_time);
626}
627
628static inline int wpa_drv_del_ts(struct wpa_supplicant *wpa_s, u8 tid,
629				 const u8 *address)
630{
631	if (!wpa_s->driver->del_tx_ts)
632		return -1;
633	return wpa_s->driver->del_tx_ts(wpa_s->drv_priv, tid, address);
634}
635
636static inline int wpa_drv_tdls_enable_channel_switch(
637	struct wpa_supplicant *wpa_s, const u8 *addr, u8 oper_class,
638	const struct hostapd_freq_params *freq_params)
639{
640	if (!wpa_s->driver->tdls_enable_channel_switch)
641		return -1;
642	return wpa_s->driver->tdls_enable_channel_switch(wpa_s->drv_priv, addr,
643							 oper_class,
644							 freq_params);
645}
646
647static inline int
648wpa_drv_tdls_disable_channel_switch(struct wpa_supplicant *wpa_s,
649				    const u8 *addr)
650{
651	if (!wpa_s->driver->tdls_disable_channel_switch)
652		return -1;
653	return wpa_s->driver->tdls_disable_channel_switch(wpa_s->drv_priv,
654							  addr);
655}
656
657static inline int wpa_drv_wnm_oper(struct wpa_supplicant *wpa_s,
658				   enum wnm_oper oper, const u8 *peer,
659				   u8 *buf, u16 *buf_len)
660{
661	if (!wpa_s->driver->wnm_oper)
662		return -1;
663	return wpa_s->driver->wnm_oper(wpa_s->drv_priv, oper, peer, buf,
664				       buf_len);
665}
666
667static inline int wpa_drv_status(struct wpa_supplicant *wpa_s,
668				 char *buf, size_t buflen)
669{
670	if (!wpa_s->driver->status)
671		return -1;
672	return wpa_s->driver->status(wpa_s->drv_priv, buf, buflen);
673}
674
675static inline int wpa_drv_set_qos_map(struct wpa_supplicant *wpa_s,
676				      const u8 *qos_map_set, u8 qos_map_set_len)
677{
678	if (!wpa_s->driver->set_qos_map)
679		return -1;
680	return wpa_s->driver->set_qos_map(wpa_s->drv_priv, qos_map_set,
681					  qos_map_set_len);
682}
683
684static inline int wpa_drv_wowlan(struct wpa_supplicant *wpa_s,
685				 const struct wowlan_triggers *triggers)
686{
687	if (!wpa_s->driver->set_wowlan)
688		return -1;
689	return wpa_s->driver->set_wowlan(wpa_s->drv_priv, triggers);
690}
691
692static inline int wpa_drv_vendor_cmd(struct wpa_supplicant *wpa_s,
693				     int vendor_id, int subcmd, const u8 *data,
694				     size_t data_len, struct wpabuf *buf)
695{
696	if (!wpa_s->driver->vendor_cmd)
697		return -1;
698	return wpa_s->driver->vendor_cmd(wpa_s->drv_priv, vendor_id, subcmd,
699					 data, data_len, buf);
700}
701
702static inline int wpa_drv_roaming(struct wpa_supplicant *wpa_s, int allowed,
703				  const u8 *bssid)
704{
705	if (!wpa_s->driver->roaming)
706		return -1;
707	return wpa_s->driver->roaming(wpa_s->drv_priv, allowed, bssid);
708}
709
710static inline int wpa_drv_disable_fils(struct wpa_supplicant *wpa_s,
711				       int disable)
712{
713	if (!wpa_s->driver->disable_fils)
714		return -1;
715	return wpa_s->driver->disable_fils(wpa_s->drv_priv, disable);
716}
717
718static inline int wpa_drv_set_mac_addr(struct wpa_supplicant *wpa_s,
719				       const u8 *addr)
720{
721	if (!wpa_s->driver->set_mac_addr)
722		return -1;
723	return wpa_s->driver->set_mac_addr(wpa_s->drv_priv, addr);
724}
725
726
727#ifdef CONFIG_MACSEC
728
729static inline int wpa_drv_macsec_init(struct wpa_supplicant *wpa_s,
730				      struct macsec_init_params *params)
731{
732	if (!wpa_s->driver->macsec_init)
733		return -1;
734	return wpa_s->driver->macsec_init(wpa_s->drv_priv, params);
735}
736
737static inline int wpa_drv_macsec_deinit(struct wpa_supplicant *wpa_s)
738{
739	if (!wpa_s->driver->macsec_deinit)
740		return -1;
741	return wpa_s->driver->macsec_deinit(wpa_s->drv_priv);
742}
743
744static inline int wpa_drv_macsec_get_capability(struct wpa_supplicant *wpa_s,
745						enum macsec_cap *cap)
746{
747	if (!wpa_s->driver->macsec_get_capability)
748		return -1;
749	return wpa_s->driver->macsec_get_capability(wpa_s->drv_priv, cap);
750}
751
752static inline int wpa_drv_enable_protect_frames(struct wpa_supplicant *wpa_s,
753						Boolean enabled)
754{
755	if (!wpa_s->driver->enable_protect_frames)
756		return -1;
757	return wpa_s->driver->enable_protect_frames(wpa_s->drv_priv, enabled);
758}
759
760static inline int wpa_drv_enable_encrypt(struct wpa_supplicant *wpa_s,
761						Boolean enabled)
762{
763	if (!wpa_s->driver->enable_encrypt)
764		return -1;
765	return wpa_s->driver->enable_encrypt(wpa_s->drv_priv, enabled);
766}
767
768static inline int wpa_drv_set_replay_protect(struct wpa_supplicant *wpa_s,
769					     Boolean enabled, u32 window)
770{
771	if (!wpa_s->driver->set_replay_protect)
772		return -1;
773	return wpa_s->driver->set_replay_protect(wpa_s->drv_priv, enabled,
774						 window);
775}
776
777static inline int wpa_drv_set_current_cipher_suite(struct wpa_supplicant *wpa_s,
778						   u64 cs)
779{
780	if (!wpa_s->driver->set_current_cipher_suite)
781		return -1;
782	return wpa_s->driver->set_current_cipher_suite(wpa_s->drv_priv, cs);
783}
784
785static inline int wpa_drv_enable_controlled_port(struct wpa_supplicant *wpa_s,
786						 Boolean enabled)
787{
788	if (!wpa_s->driver->enable_controlled_port)
789		return -1;
790	return wpa_s->driver->enable_controlled_port(wpa_s->drv_priv, enabled);
791}
792
793static inline int wpa_drv_get_receive_lowest_pn(struct wpa_supplicant *wpa_s,
794						struct receive_sa *sa)
795{
796	if (!wpa_s->driver->get_receive_lowest_pn)
797		return -1;
798	return wpa_s->driver->get_receive_lowest_pn(wpa_s->drv_priv, sa);
799}
800
801static inline int wpa_drv_get_transmit_next_pn(struct wpa_supplicant *wpa_s,
802						struct transmit_sa *sa)
803{
804	if (!wpa_s->driver->get_transmit_next_pn)
805		return -1;
806	return wpa_s->driver->get_transmit_next_pn(wpa_s->drv_priv, sa);
807}
808
809static inline int wpa_drv_set_transmit_next_pn(struct wpa_supplicant *wpa_s,
810						struct transmit_sa *sa)
811{
812	if (!wpa_s->driver->set_transmit_next_pn)
813		return -1;
814	return wpa_s->driver->set_transmit_next_pn(wpa_s->drv_priv, sa);
815}
816
817static inline int wpa_drv_set_receive_lowest_pn(struct wpa_supplicant *wpa_s,
818						struct receive_sa *sa)
819{
820	if (!wpa_s->driver->set_receive_lowest_pn)
821		return -1;
822	return wpa_s->driver->set_receive_lowest_pn(wpa_s->drv_priv, sa);
823}
824
825static inline int
826wpa_drv_create_receive_sc(struct wpa_supplicant *wpa_s, struct receive_sc *sc,
827			  unsigned int conf_offset, int validation)
828{
829	if (!wpa_s->driver->create_receive_sc)
830		return -1;
831	return wpa_s->driver->create_receive_sc(wpa_s->drv_priv, sc,
832						conf_offset, validation);
833}
834
835static inline int wpa_drv_delete_receive_sc(struct wpa_supplicant *wpa_s,
836					    struct receive_sc *sc)
837{
838	if (!wpa_s->driver->delete_receive_sc)
839		return -1;
840	return wpa_s->driver->delete_receive_sc(wpa_s->drv_priv, sc);
841}
842
843static inline int wpa_drv_create_receive_sa(struct wpa_supplicant *wpa_s,
844					    struct receive_sa *sa)
845{
846	if (!wpa_s->driver->create_receive_sa)
847		return -1;
848	return wpa_s->driver->create_receive_sa(wpa_s->drv_priv, sa);
849}
850
851static inline int wpa_drv_delete_receive_sa(struct wpa_supplicant *wpa_s,
852					    struct receive_sa *sa)
853{
854	if (!wpa_s->driver->delete_receive_sa)
855		return -1;
856	return wpa_s->driver->delete_receive_sa(wpa_s->drv_priv, sa);
857}
858
859static inline int wpa_drv_enable_receive_sa(struct wpa_supplicant *wpa_s,
860					    struct receive_sa *sa)
861{
862	if (!wpa_s->driver->enable_receive_sa)
863		return -1;
864	return wpa_s->driver->enable_receive_sa(wpa_s->drv_priv, sa);
865}
866
867static inline int wpa_drv_disable_receive_sa(struct wpa_supplicant *wpa_s,
868					     struct receive_sa *sa)
869{
870	if (!wpa_s->driver->disable_receive_sa)
871		return -1;
872	return wpa_s->driver->disable_receive_sa(wpa_s->drv_priv, sa);
873}
874
875static inline int
876wpa_drv_create_transmit_sc(struct wpa_supplicant *wpa_s, struct transmit_sc *sc,
877			   unsigned int conf_offset)
878{
879	if (!wpa_s->driver->create_transmit_sc)
880		return -1;
881	return wpa_s->driver->create_transmit_sc(wpa_s->drv_priv, sc,
882						 conf_offset);
883}
884
885static inline int wpa_drv_delete_transmit_sc(struct wpa_supplicant *wpa_s,
886					     struct transmit_sc *sc)
887{
888	if (!wpa_s->driver->delete_transmit_sc)
889		return -1;
890	return wpa_s->driver->delete_transmit_sc(wpa_s->drv_priv, sc);
891}
892
893static inline int wpa_drv_create_transmit_sa(struct wpa_supplicant *wpa_s,
894					     struct transmit_sa *sa)
895{
896	if (!wpa_s->driver->create_transmit_sa)
897		return -1;
898	return wpa_s->driver->create_transmit_sa(wpa_s->drv_priv, sa);
899}
900
901static inline int wpa_drv_delete_transmit_sa(struct wpa_supplicant *wpa_s,
902					     struct transmit_sa *sa)
903{
904	if (!wpa_s->driver->delete_transmit_sa)
905		return -1;
906	return wpa_s->driver->delete_transmit_sa(wpa_s->drv_priv, sa);
907}
908
909static inline int wpa_drv_enable_transmit_sa(struct wpa_supplicant *wpa_s,
910					     struct transmit_sa *sa)
911{
912	if (!wpa_s->driver->enable_transmit_sa)
913		return -1;
914	return wpa_s->driver->enable_transmit_sa(wpa_s->drv_priv, sa);
915}
916
917static inline int wpa_drv_disable_transmit_sa(struct wpa_supplicant *wpa_s,
918					      struct transmit_sa *sa)
919{
920	if (!wpa_s->driver->disable_transmit_sa)
921		return -1;
922	return wpa_s->driver->disable_transmit_sa(wpa_s->drv_priv, sa);
923}
924#endif /* CONFIG_MACSEC */
925
926static inline int wpa_drv_setband(struct wpa_supplicant *wpa_s,
927				  enum set_band band)
928{
929	if (!wpa_s->driver->set_band)
930		return -1;
931	return wpa_s->driver->set_band(wpa_s->drv_priv, band);
932}
933
934static inline int wpa_drv_get_pref_freq_list(struct wpa_supplicant *wpa_s,
935					     enum wpa_driver_if_type type,
936					     unsigned int *num,
937					     unsigned int *freq_list)
938{
939#ifdef CONFIG_TESTING_OPTIONS
940	if (wpa_s->get_pref_freq_list_override)
941		return wpas_ctrl_iface_get_pref_freq_list_override(
942			wpa_s, if_type, num, freq_list);
943#endif /* CONFIG_TESTING_OPTIONS */
944	if (!wpa_s->driver->get_pref_freq_list)
945		return -1;
946	return wpa_s->driver->get_pref_freq_list(wpa_s->drv_priv, type,
947						 num, freq_list);
948}
949
950static inline int wpa_drv_set_prob_oper_freq(struct wpa_supplicant *wpa_s,
951					     unsigned int freq)
952{
953	if (!wpa_s->driver->set_prob_oper_freq)
954		return 0;
955	return wpa_s->driver->set_prob_oper_freq(wpa_s->drv_priv, freq);
956}
957
958static inline int wpa_drv_abort_scan(struct wpa_supplicant *wpa_s,
959				     u64 scan_cookie)
960{
961	if (!wpa_s->driver->abort_scan)
962		return -1;
963	return wpa_s->driver->abort_scan(wpa_s->drv_priv, scan_cookie);
964}
965
966static inline int wpa_drv_configure_frame_filters(struct wpa_supplicant *wpa_s,
967						  u32 filters)
968{
969	if (!wpa_s->driver->configure_data_frame_filters)
970		return -1;
971	return wpa_s->driver->configure_data_frame_filters(wpa_s->drv_priv,
972							   filters);
973}
974
975static inline int wpa_drv_get_ext_capa(struct wpa_supplicant *wpa_s,
976				       enum wpa_driver_if_type type)
977{
978	if (!wpa_s->driver->get_ext_capab)
979		return -1;
980	return wpa_s->driver->get_ext_capab(wpa_s->drv_priv, type,
981					    &wpa_s->extended_capa,
982					    &wpa_s->extended_capa_mask,
983					    &wpa_s->extended_capa_len);
984}
985
986static inline int wpa_drv_p2p_lo_start(struct wpa_supplicant *wpa_s,
987				       unsigned int channel,
988				       unsigned int period,
989				       unsigned int interval,
990				       unsigned int count,
991				       const u8 *device_types,
992				       size_t dev_types_len,
993				       const u8 *ies, size_t ies_len)
994{
995	if (!wpa_s->driver->p2p_lo_start)
996		return -1;
997	return wpa_s->driver->p2p_lo_start(wpa_s->drv_priv, channel, period,
998					   interval, count, device_types,
999					   dev_types_len, ies, ies_len);
1000}
1001
1002static inline int wpa_drv_p2p_lo_stop(struct wpa_supplicant *wpa_s)
1003{
1004	if (!wpa_s->driver->p2p_lo_stop)
1005		return -1;
1006	return wpa_s->driver->p2p_lo_stop(wpa_s->drv_priv);
1007}
1008
1009static inline int wpa_drv_set_default_scan_ies(struct wpa_supplicant *wpa_s,
1010					       const u8 *ies, size_t len)
1011{
1012	if (!wpa_s->driver->set_default_scan_ies)
1013		return -1;
1014	return wpa_s->driver->set_default_scan_ies(wpa_s->drv_priv, ies, len);
1015}
1016
1017static inline int wpa_drv_set_tdls_mode(struct wpa_supplicant *wpa_s,
1018					int tdls_external_control)
1019{
1020	if (!wpa_s->driver->set_tdls_mode)
1021		return -1;
1022	return wpa_s->driver->set_tdls_mode(wpa_s->drv_priv,
1023					    tdls_external_control);
1024}
1025
1026static inline struct wpa_bss_candidate_info *
1027wpa_drv_get_bss_trans_status(struct wpa_supplicant *wpa_s,
1028			     struct wpa_bss_trans_info *params)
1029{
1030	if (!wpa_s->driver->get_bss_transition_status)
1031		return NULL;
1032	return wpa_s->driver->get_bss_transition_status(wpa_s->drv_priv,
1033							params);
1034}
1035
1036static inline int wpa_drv_ignore_assoc_disallow(struct wpa_supplicant *wpa_s,
1037						int val)
1038{
1039	if (!wpa_s->driver->ignore_assoc_disallow)
1040		return -1;
1041	return wpa_s->driver->ignore_assoc_disallow(wpa_s->drv_priv, val);
1042}
1043
1044static inline int wpa_drv_set_bssid_blacklist(struct wpa_supplicant *wpa_s,
1045					      unsigned int num_bssid,
1046					      const u8 *bssids)
1047{
1048	if (!wpa_s->driver->set_bssid_blacklist)
1049		return -1;
1050	return wpa_s->driver->set_bssid_blacklist(wpa_s->drv_priv, num_bssid,
1051						  bssids);
1052}
1053
1054static inline int wpa_drv_update_connect_params(
1055	struct wpa_supplicant *wpa_s,
1056	struct wpa_driver_associate_params *params,
1057	enum wpa_drv_update_connect_params_mask mask)
1058{
1059	if (!wpa_s->driver->update_connect_params)
1060		return -1;
1061	return wpa_s->driver->update_connect_params(wpa_s->drv_priv, params,
1062						    mask);
1063}
1064
1065static inline int
1066wpa_drv_send_external_auth_status(struct wpa_supplicant *wpa_s,
1067				  struct external_auth *params)
1068{
1069	if (!wpa_s->driver->send_external_auth_status)
1070		return -1;
1071	return wpa_s->driver->send_external_auth_status(wpa_s->drv_priv,
1072							params);
1073}
1074
1075static inline int wpa_drv_set_4addr_mode(struct wpa_supplicant *wpa_s, int val)
1076{
1077	if (!wpa_s->driver->set_4addr_mode)
1078		return -1;
1079	return wpa_s->driver->set_4addr_mode(wpa_s->drv_priv,
1080					     wpa_s->bridge_ifname, val);
1081}
1082
1083#endif /* DRIVER_I_H */
1084