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