driver_i.h revision 78a5dac804c22aa6e4ec8226a864d3b0d6ccddbb 
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_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
102static 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
110static 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
117static 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
125static 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
133static 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
141static 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
161static 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
170static 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
181static 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
191static 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
200static 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
210static 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
218static 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
227static 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
234static 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
242static inline const char *
243wpa_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
250static 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
258static 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
266static 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
277static inline struct hostapd_hw_modes *
278wpa_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
287static 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
295static 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
306static 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
316static 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
324static 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
332static 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
340static 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
352static 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
363static 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
373static 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
388static 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
394static 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
402static 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
415static 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
424static 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
434static 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
443static 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
452static 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
459static 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
466static 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
472static 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
478static 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
487static 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
495static 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
504static 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
515static 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
523static 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
533static 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
540static 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
555static 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
564static 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
573static 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
584static 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
592static 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
600static 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
610static 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
618static 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
629static inline int
630wpa_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
639static 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
649static 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
657static 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
666static 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
674static 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
684static 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
692static 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
703static 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
711static 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
718static inline int wpa_drv_macsec_get_capability(struct wpa_supplicant *wpa_s,
719						enum macsec_cap *cap)
720{
721	if (!wpa_s->driver->macsec_get_capability)
722		return -1;
723	return wpa_s->driver->macsec_get_capability(wpa_s->drv_priv, cap);
724}
725
726static inline int wpa_drv_enable_protect_frames(struct wpa_supplicant *wpa_s,
727						Boolean enabled)
728{
729	if (!wpa_s->driver->enable_protect_frames)
730		return -1;
731	return wpa_s->driver->enable_protect_frames(wpa_s->drv_priv, enabled);
732}
733
734static inline int wpa_drv_set_replay_protect(struct wpa_supplicant *wpa_s,
735					     Boolean enabled, u32 window)
736{
737	if (!wpa_s->driver->set_replay_protect)
738		return -1;
739	return wpa_s->driver->set_replay_protect(wpa_s->drv_priv, enabled,
740						 window);
741}
742
743static inline int wpa_drv_set_current_cipher_suite(struct wpa_supplicant *wpa_s,
744						   u64 cs)
745{
746	if (!wpa_s->driver->set_current_cipher_suite)
747		return -1;
748	return wpa_s->driver->set_current_cipher_suite(wpa_s->drv_priv, cs);
749}
750
751static inline int wpa_drv_enable_controlled_port(struct wpa_supplicant *wpa_s,
752						 Boolean enabled)
753{
754	if (!wpa_s->driver->enable_controlled_port)
755		return -1;
756	return wpa_s->driver->enable_controlled_port(wpa_s->drv_priv, enabled);
757}
758
759static inline int wpa_drv_get_receive_lowest_pn(struct wpa_supplicant *wpa_s,
760						struct receive_sa *sa)
761{
762	if (!wpa_s->driver->get_receive_lowest_pn)
763		return -1;
764	return wpa_s->driver->get_receive_lowest_pn(wpa_s->drv_priv, sa);
765}
766
767static inline int wpa_drv_get_transmit_next_pn(struct wpa_supplicant *wpa_s,
768						struct transmit_sa *sa)
769{
770	if (!wpa_s->driver->get_transmit_next_pn)
771		return -1;
772	return wpa_s->driver->get_transmit_next_pn(wpa_s->drv_priv, sa);
773}
774
775static inline int wpa_drv_set_transmit_next_pn(struct wpa_supplicant *wpa_s,
776						struct transmit_sa *sa)
777{
778	if (!wpa_s->driver->set_transmit_next_pn)
779		return -1;
780	return wpa_s->driver->set_transmit_next_pn(wpa_s->drv_priv, sa);
781}
782
783static inline int
784wpa_drv_create_receive_sc(struct wpa_supplicant *wpa_s, struct receive_sc *sc,
785			  unsigned int conf_offset, int validation)
786{
787	if (!wpa_s->driver->create_receive_sc)
788		return -1;
789	return wpa_s->driver->create_receive_sc(wpa_s->drv_priv, sc,
790						conf_offset, validation);
791}
792
793static inline int wpa_drv_delete_receive_sc(struct wpa_supplicant *wpa_s,
794					    struct receive_sc *sc)
795{
796	if (!wpa_s->driver->delete_receive_sc)
797		return -1;
798	return wpa_s->driver->delete_receive_sc(wpa_s->drv_priv, sc);
799}
800
801static inline int wpa_drv_create_receive_sa(struct wpa_supplicant *wpa_s,
802					    struct receive_sa *sa)
803{
804	if (!wpa_s->driver->create_receive_sa)
805		return -1;
806	return wpa_s->driver->create_receive_sa(wpa_s->drv_priv, sa);
807}
808
809static inline int wpa_drv_delete_receive_sa(struct wpa_supplicant *wpa_s,
810					    struct receive_sa *sa)
811{
812	if (!wpa_s->driver->delete_receive_sa)
813		return -1;
814	return wpa_s->driver->delete_receive_sa(wpa_s->drv_priv, sa);
815}
816
817static inline int wpa_drv_enable_receive_sa(struct wpa_supplicant *wpa_s,
818					    struct receive_sa *sa)
819{
820	if (!wpa_s->driver->enable_receive_sa)
821		return -1;
822	return wpa_s->driver->enable_receive_sa(wpa_s->drv_priv, sa);
823}
824
825static inline int wpa_drv_disable_receive_sa(struct wpa_supplicant *wpa_s,
826					     struct receive_sa *sa)
827{
828	if (!wpa_s->driver->disable_receive_sa)
829		return -1;
830	return wpa_s->driver->disable_receive_sa(wpa_s->drv_priv, sa);
831}
832
833static inline int
834wpa_drv_create_transmit_sc(struct wpa_supplicant *wpa_s, struct transmit_sc *sc,
835			   unsigned int conf_offset)
836{
837	if (!wpa_s->driver->create_transmit_sc)
838		return -1;
839	return wpa_s->driver->create_transmit_sc(wpa_s->drv_priv, sc,
840						 conf_offset);
841}
842
843static inline int wpa_drv_delete_transmit_sc(struct wpa_supplicant *wpa_s,
844					     struct transmit_sc *sc)
845{
846	if (!wpa_s->driver->delete_transmit_sc)
847		return -1;
848	return wpa_s->driver->delete_transmit_sc(wpa_s->drv_priv, sc);
849}
850
851static inline int wpa_drv_create_transmit_sa(struct wpa_supplicant *wpa_s,
852					     struct transmit_sa *sa)
853{
854	if (!wpa_s->driver->create_transmit_sa)
855		return -1;
856	return wpa_s->driver->create_transmit_sa(wpa_s->drv_priv, sa);
857}
858
859static inline int wpa_drv_delete_transmit_sa(struct wpa_supplicant *wpa_s,
860					     struct transmit_sa *sa)
861{
862	if (!wpa_s->driver->delete_transmit_sa)
863		return -1;
864	return wpa_s->driver->delete_transmit_sa(wpa_s->drv_priv, sa);
865}
866
867static inline int wpa_drv_enable_transmit_sa(struct wpa_supplicant *wpa_s,
868					     struct transmit_sa *sa)
869{
870	if (!wpa_s->driver->enable_transmit_sa)
871		return -1;
872	return wpa_s->driver->enable_transmit_sa(wpa_s->drv_priv, sa);
873}
874
875static inline int wpa_drv_disable_transmit_sa(struct wpa_supplicant *wpa_s,
876					      struct transmit_sa *sa)
877{
878	if (!wpa_s->driver->disable_transmit_sa)
879		return -1;
880	return wpa_s->driver->disable_transmit_sa(wpa_s->drv_priv, sa);
881}
882#endif /* CONFIG_MACSEC */
883
884static inline int wpa_drv_setband(struct wpa_supplicant *wpa_s,
885				  enum set_band band)
886{
887	if (!wpa_s->driver->set_band)
888		return -1;
889	return wpa_s->driver->set_band(wpa_s->drv_priv, band);
890}
891
892static inline int wpa_drv_get_pref_freq_list(struct wpa_supplicant *wpa_s,
893					     enum wpa_driver_if_type if_type,
894					     unsigned int *num,
895					     unsigned int *freq_list)
896{
897	if (!wpa_s->driver->get_pref_freq_list)
898		return -1;
899	return wpa_s->driver->get_pref_freq_list(wpa_s->drv_priv, if_type,
900						 num, freq_list);
901}
902
903static inline int wpa_drv_set_prob_oper_freq(struct wpa_supplicant *wpa_s,
904					     unsigned int freq)
905{
906	if (!wpa_s->driver->set_prob_oper_freq)
907		return 0;
908	return wpa_s->driver->set_prob_oper_freq(wpa_s->drv_priv, freq);
909}
910
911static inline int wpa_drv_abort_scan(struct wpa_supplicant *wpa_s)
912{
913	if (!wpa_s->driver->abort_scan)
914		return -1;
915	return wpa_s->driver->abort_scan(wpa_s->drv_priv);
916}
917
918static inline int wpa_drv_configure_frame_filters(struct wpa_supplicant *wpa_s,
919						  u32 filters)
920{
921	if (!wpa_s->driver->configure_data_frame_filters)
922		return -1;
923	return wpa_s->driver->configure_data_frame_filters(wpa_s->drv_priv,
924							   filters);
925}
926
927static inline int wpa_drv_get_ext_capa(struct wpa_supplicant *wpa_s,
928				       enum wpa_driver_if_type type)
929{
930	if (!wpa_s->driver->get_ext_capab)
931		return -1;
932	return wpa_s->driver->get_ext_capab(wpa_s->drv_priv, type,
933					    &wpa_s->extended_capa,
934					    &wpa_s->extended_capa_mask,
935					    &wpa_s->extended_capa_len);
936}
937
938static inline int wpa_drv_p2p_lo_start(struct wpa_supplicant *wpa_s,
939				       unsigned int channel,
940				       unsigned int period,
941				       unsigned int interval,
942				       unsigned int count,
943				       const u8 *device_types,
944				       size_t dev_types_len,
945				       const u8 *ies, size_t ies_len)
946{
947	if (!wpa_s->driver->p2p_lo_start)
948		return -1;
949	return wpa_s->driver->p2p_lo_start(wpa_s->drv_priv, channel, period,
950					   interval, count, device_types,
951					   dev_types_len, ies, ies_len);
952}
953
954static inline int wpa_drv_p2p_lo_stop(struct wpa_supplicant *wpa_s)
955{
956	if (!wpa_s->driver->p2p_lo_stop)
957		return -1;
958	return wpa_s->driver->p2p_lo_stop(wpa_s->drv_priv);
959}
960
961static inline int wpa_drv_set_default_scan_ies(struct wpa_supplicant *wpa_s,
962					       const u8 *ies, size_t len)
963{
964	if (!wpa_s->driver->set_default_scan_ies)
965		return -1;
966	return wpa_s->driver->set_default_scan_ies(wpa_s->drv_priv, ies, len);
967}
968
969static inline int wpa_drv_set_tdls_mode(struct wpa_supplicant *wpa_s,
970					int tdls_external_control)
971{
972	if (!wpa_s->driver->set_tdls_mode)
973		return -1;
974	return wpa_s->driver->set_tdls_mode(wpa_s->drv_priv,
975					    tdls_external_control);
976}
977
978#endif /* DRIVER_I_H */
979