driver_i.h revision 61d9df3e62aaa0e87ad05452fcb95142159a17b6 
1/*
2 * wpa_supplicant - Internal driver interface wrappers
3 * Copyright (c) 2003-2009, 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_scan(struct wpa_supplicant *wpa_s,
69			       struct wpa_driver_scan_params *params)
70{
71	if (wpa_s->driver->scan2)
72		return wpa_s->driver->scan2(wpa_s->drv_priv, params);
73	return -1;
74}
75
76static inline int wpa_drv_sched_scan(struct wpa_supplicant *wpa_s,
77				     struct wpa_driver_scan_params *params,
78				     u32 interval)
79{
80	if (wpa_s->driver->sched_scan)
81		return wpa_s->driver->sched_scan(wpa_s->drv_priv,
82						 params, interval);
83	return -1;
84}
85
86static inline int wpa_drv_stop_sched_scan(struct wpa_supplicant *wpa_s)
87{
88	if (wpa_s->driver->stop_sched_scan)
89		return wpa_s->driver->stop_sched_scan(wpa_s->drv_priv);
90	return -1;
91}
92
93static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
94	struct wpa_supplicant *wpa_s)
95{
96	if (wpa_s->driver->get_scan_results2)
97		return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
98	return NULL;
99}
100
101static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid)
102{
103	if (wpa_s->driver->get_bssid) {
104		return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
105	}
106	return -1;
107}
108
109static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid)
110{
111	if (wpa_s->driver->get_ssid) {
112		return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
113	}
114	return -1;
115}
116
117static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s,
118				  enum wpa_alg alg, const u8 *addr,
119				  int key_idx, int set_tx,
120				   const u8 *seq, size_t seq_len,
121				   const u8 *key, size_t key_len)
122{
123	if (wpa_s->driver->set_key) {
124		wpa_s->keys_cleared = 0;
125		return wpa_s->driver->set_key(wpa_s->ifname, wpa_s->drv_priv,
126					      alg, addr, key_idx, set_tx,
127					      seq, seq_len, key, key_len);
128	}
129	return -1;
130}
131
132static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
133					 const u8 *addr, int reason_code)
134{
135	if (wpa_s->driver->deauthenticate) {
136		return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
137						     reason_code);
138	}
139	return -1;
140}
141
142static inline int wpa_drv_disassociate(struct wpa_supplicant *wpa_s,
143				       const u8 *addr, int reason_code)
144{
145	if (wpa_s->driver->disassociate) {
146		return wpa_s->driver->disassociate(wpa_s->drv_priv, addr,
147						   reason_code);
148	}
149	return -1;
150}
151
152static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
153				    const u8 *bssid, const u8 *pmkid)
154{
155	if (wpa_s->driver->add_pmkid) {
156		return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
157	}
158	return -1;
159}
160
161static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
162				       const u8 *bssid, const u8 *pmkid)
163{
164	if (wpa_s->driver->remove_pmkid) {
165		return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
166						   pmkid);
167	}
168	return -1;
169}
170
171static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
172{
173	if (wpa_s->driver->flush_pmkid) {
174		return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
175	}
176	return -1;
177}
178
179static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
180				   struct wpa_driver_capa *capa)
181{
182	if (wpa_s->driver->get_capa) {
183		return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
184	}
185	return -1;
186}
187
188static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
189{
190	if (wpa_s->driver->poll) {
191		wpa_s->driver->poll(wpa_s->drv_priv);
192	}
193}
194
195static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
196{
197	if (wpa_s->driver->get_ifname) {
198		return wpa_s->driver->get_ifname(wpa_s->drv_priv);
199	}
200	return NULL;
201}
202
203static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
204{
205	if (wpa_s->driver->get_mac_addr) {
206		return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
207	}
208	return NULL;
209}
210
211static inline int wpa_drv_send_eapol(struct wpa_supplicant *wpa_s,
212				     const u8 *dst, u16 proto,
213				     const u8 *data, size_t data_len)
214{
215	if (wpa_s->driver->send_eapol)
216		return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto,
217						 data, data_len);
218	return -1;
219}
220
221static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
222					int state)
223{
224	if (wpa_s->driver->set_operstate)
225		return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
226	return 0;
227}
228
229static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
230					     const u8 *addr, int protect_type,
231					     int key_type)
232{
233	if (wpa_s->driver->mlme_setprotection)
234		return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
235							 protect_type,
236							 key_type);
237	return 0;
238}
239
240static inline struct hostapd_hw_modes *
241wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
242			    u16 *flags)
243{
244	if (wpa_s->driver->get_hw_feature_data)
245		return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
246							  num_modes, flags);
247	return NULL;
248}
249
250static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
251				      const char *alpha2)
252{
253	if (wpa_s->driver->set_country)
254		return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
255	return 0;
256}
257
258static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
259				    const u8 *data, size_t data_len, int noack)
260{
261	if (wpa_s->driver->send_mlme)
262		return wpa_s->driver->send_mlme(wpa_s->drv_priv,
263						data, data_len, noack);
264	return -1;
265}
266
267static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
268					const u8 *md,
269					const u8 *ies, size_t ies_len)
270{
271	if (wpa_s->driver->update_ft_ies)
272		return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
273						    ies, ies_len);
274	return -1;
275}
276
277static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
278					 u8 action, const u8 *target_ap,
279					 const u8 *ies, size_t ies_len)
280{
281	if (wpa_s->driver->send_ft_action)
282		return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
283						     target_ap, ies, ies_len);
284	return -1;
285}
286
287static inline int wpa_drv_set_ap(struct wpa_supplicant *wpa_s,
288				 struct wpa_driver_ap_params *params)
289{
290	if (wpa_s->driver->set_ap)
291		return wpa_s->driver->set_ap(wpa_s->drv_priv, params);
292	return -1;
293}
294
295static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
296				  struct hostapd_sta_add_params *params)
297{
298	if (wpa_s->driver->sta_add)
299		return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
300	return -1;
301}
302
303static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
304				     const u8 *addr)
305{
306	if (wpa_s->driver->sta_remove)
307		return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
308	return -1;
309}
310
311static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
312					  const u8 *addr, const u8 *data,
313					  size_t data_len, int encrypt,
314					  const u8 *own_addr, u32 flags)
315{
316	if (wpa_s->driver->hapd_send_eapol)
317		return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
318						      data, data_len, encrypt,
319						      own_addr, flags);
320	return -1;
321}
322
323static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
324					const u8 *addr, int total_flags,
325					int flags_or, int flags_and)
326{
327	if (wpa_s->driver->sta_set_flags)
328		return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
329						    total_flags, flags_or,
330						    flags_and);
331	return -1;
332}
333
334static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
335					int authorized)
336{
337	if (wpa_s->driver->set_supp_port) {
338		return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
339						    authorized);
340	}
341	return 0;
342}
343
344static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
345				      unsigned int freq,
346				      unsigned int wait,
347				      const u8 *dst, const u8 *src,
348				      const u8 *bssid,
349				      const u8 *data, size_t data_len,
350				      int no_cck)
351{
352	if (wpa_s->driver->send_action)
353		return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
354						  wait, dst, src, bssid,
355						  data, data_len, no_cck);
356	return -1;
357}
358
359static inline void wpa_drv_send_action_cancel_wait(struct wpa_supplicant *wpa_s)
360{
361	if (wpa_s->driver->send_action_cancel_wait)
362		wpa_s->driver->send_action_cancel_wait(wpa_s->drv_priv);
363}
364
365static inline int wpa_drv_set_freq(struct wpa_supplicant *wpa_s,
366				   struct hostapd_freq_params *freq)
367{
368	if (wpa_s->driver->set_freq)
369		return wpa_s->driver->set_freq(wpa_s->drv_priv, freq);
370	return -1;
371}
372
373static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
374				 enum wpa_driver_if_type type,
375				 const char *ifname, const u8 *addr,
376				 void *bss_ctx, char *force_ifname,
377				 u8 *if_addr, const char *bridge)
378{
379	if (wpa_s->driver->if_add)
380		return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
381					     addr, bss_ctx, NULL, force_ifname,
382					     if_addr, bridge);
383	return -1;
384}
385
386static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
387				    enum wpa_driver_if_type type,
388				    const char *ifname)
389{
390	if (wpa_s->driver->if_remove)
391		return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
392	return -1;
393}
394
395static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
396					    unsigned int freq,
397					    unsigned int duration)
398{
399	if (wpa_s->driver->remain_on_channel)
400		return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
401							duration);
402	return -1;
403}
404
405static inline int wpa_drv_cancel_remain_on_channel(
406	struct wpa_supplicant *wpa_s)
407{
408	if (wpa_s->driver->cancel_remain_on_channel)
409		return wpa_s->driver->cancel_remain_on_channel(
410			wpa_s->drv_priv);
411	return -1;
412}
413
414static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
415					   int report)
416{
417	if (wpa_s->driver->probe_req_report)
418		return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
419						       report);
420	return -1;
421}
422
423static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
424{
425	if (wpa_s->driver->deinit_ap)
426		return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
427	return 0;
428}
429
430static inline int wpa_drv_deinit_p2p_cli(struct wpa_supplicant *wpa_s)
431{
432	if (wpa_s->driver->deinit_p2p_cli)
433		return wpa_s->driver->deinit_p2p_cli(wpa_s->drv_priv);
434	return 0;
435}
436
437static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
438{
439	if (wpa_s->driver->suspend)
440		wpa_s->driver->suspend(wpa_s->drv_priv);
441}
442
443static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
444{
445	if (wpa_s->driver->resume)
446		wpa_s->driver->resume(wpa_s->drv_priv);
447}
448
449static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
450					 int threshold, int hysteresis)
451{
452	if (wpa_s->driver->signal_monitor)
453		return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
454						     threshold, hysteresis);
455	return -1;
456}
457
458static inline int wpa_drv_signal_poll(struct wpa_supplicant *wpa_s,
459				      struct wpa_signal_info *si)
460{
461	if (wpa_s->driver->signal_poll)
462		return wpa_s->driver->signal_poll(wpa_s->drv_priv, si);
463	return -1;
464}
465
466static inline int wpa_drv_pktcnt_poll(struct wpa_supplicant *wpa_s,
467				      struct hostap_sta_driver_data *sta)
468{
469	if (wpa_s->driver->read_sta_data)
470		return wpa_s->driver->read_sta_data(wpa_s->drv_priv, sta, wpa_s->bssid);
471	return -1;
472}
473
474static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
475					const struct wpabuf *beacon,
476					const struct wpabuf *proberesp,
477					const struct wpabuf *assocresp)
478{
479	if (!wpa_s->driver->set_ap_wps_ie)
480		return -1;
481	return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
482					    proberesp, assocresp);
483}
484
485static inline int wpa_drv_shared_freq(struct wpa_supplicant *wpa_s)
486{
487	if (!wpa_s->driver->shared_freq)
488		return -1;
489	return wpa_s->driver->shared_freq(wpa_s->drv_priv);
490}
491
492static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
493				  u8 *buf, size_t buf_len)
494{
495	if (!wpa_s->driver->get_noa)
496		return -1;
497	return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
498}
499
500static inline int wpa_drv_set_p2p_powersave(struct wpa_supplicant *wpa_s,
501					    int legacy_ps, int opp_ps,
502					    int ctwindow)
503{
504	if (!wpa_s->driver->set_p2p_powersave)
505		return -1;
506	return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
507						opp_ps, ctwindow);
508}
509
510static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
511{
512	if (!wpa_s->driver->ampdu)
513		return -1;
514	return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
515}
516
517static inline int wpa_drv_p2p_find(struct wpa_supplicant *wpa_s,
518				   unsigned int timeout, int type)
519{
520	if (!wpa_s->driver->p2p_find)
521		return -1;
522	return wpa_s->driver->p2p_find(wpa_s->drv_priv, timeout, type);
523}
524
525static inline int wpa_drv_p2p_stop_find(struct wpa_supplicant *wpa_s)
526{
527	if (!wpa_s->driver->p2p_stop_find)
528		return -1;
529	return wpa_s->driver->p2p_stop_find(wpa_s->drv_priv);
530}
531
532static inline int wpa_drv_p2p_listen(struct wpa_supplicant *wpa_s,
533				     unsigned int timeout)
534{
535	if (!wpa_s->driver->p2p_listen)
536		return -1;
537	return wpa_s->driver->p2p_listen(wpa_s->drv_priv, timeout);
538}
539
540static inline int wpa_drv_p2p_connect(struct wpa_supplicant *wpa_s,
541				      const u8 *peer_addr, int wps_method,
542				      int go_intent,
543				      const u8 *own_interface_addr,
544				      unsigned int force_freq,
545				      int persistent_group)
546{
547	if (!wpa_s->driver->p2p_connect)
548		return -1;
549	return wpa_s->driver->p2p_connect(wpa_s->drv_priv, peer_addr,
550					  wps_method, go_intent,
551					  own_interface_addr, force_freq,
552					  persistent_group);
553}
554
555static inline int wpa_drv_wps_success_cb(struct wpa_supplicant *wpa_s,
556					 const u8 *peer_addr)
557{
558	if (!wpa_s->driver->wps_success_cb)
559		return -1;
560	return wpa_s->driver->wps_success_cb(wpa_s->drv_priv, peer_addr);
561}
562
563static inline int
564wpa_drv_p2p_group_formation_failed(struct wpa_supplicant *wpa_s)
565{
566	if (!wpa_s->driver->p2p_group_formation_failed)
567		return -1;
568	return wpa_s->driver->p2p_group_formation_failed(wpa_s->drv_priv);
569}
570
571static inline int wpa_drv_p2p_set_params(struct wpa_supplicant *wpa_s,
572					 const struct p2p_params *params)
573{
574	if (!wpa_s->driver->p2p_set_params)
575		return -1;
576	return wpa_s->driver->p2p_set_params(wpa_s->drv_priv, params);
577}
578
579static inline int wpa_drv_p2p_prov_disc_req(struct wpa_supplicant *wpa_s,
580					    const u8 *peer_addr,
581					    u16 config_methods, int join)
582{
583	if (!wpa_s->driver->p2p_prov_disc_req)
584		return -1;
585	return wpa_s->driver->p2p_prov_disc_req(wpa_s->drv_priv, peer_addr,
586						config_methods, join);
587}
588
589static inline u64 wpa_drv_p2p_sd_request(struct wpa_supplicant *wpa_s,
590					 const u8 *dst,
591					 const struct wpabuf *tlvs)
592{
593	if (!wpa_s->driver->p2p_sd_request)
594		return 0;
595	return wpa_s->driver->p2p_sd_request(wpa_s->drv_priv, dst, tlvs);
596}
597
598static inline int wpa_drv_p2p_sd_cancel_request(struct wpa_supplicant *wpa_s,
599						u64 req)
600{
601	if (!wpa_s->driver->p2p_sd_cancel_request)
602		return -1;
603	return wpa_s->driver->p2p_sd_cancel_request(wpa_s->drv_priv, req);
604}
605
606static inline int wpa_drv_p2p_sd_response(struct wpa_supplicant *wpa_s,
607					  int freq, const u8 *dst,
608					  u8 dialog_token,
609					  const struct wpabuf *resp_tlvs)
610{
611	if (!wpa_s->driver->p2p_sd_response)
612		return -1;
613	return wpa_s->driver->p2p_sd_response(wpa_s->drv_priv, freq, dst,
614					      dialog_token, resp_tlvs);
615}
616
617static inline int wpa_drv_p2p_service_update(struct wpa_supplicant *wpa_s)
618{
619	if (!wpa_s->driver->p2p_service_update)
620		return -1;
621	return wpa_s->driver->p2p_service_update(wpa_s->drv_priv);
622}
623
624static inline int wpa_drv_p2p_reject(struct wpa_supplicant *wpa_s,
625				     const u8 *addr)
626{
627	if (!wpa_s->driver->p2p_reject)
628		return -1;
629	return wpa_s->driver->p2p_reject(wpa_s->drv_priv, addr);
630}
631
632static inline int wpa_drv_p2p_invite(struct wpa_supplicant *wpa_s,
633				     const u8 *peer, int role, const u8 *bssid,
634				     const u8 *ssid, size_t ssid_len,
635				     const u8 *go_dev_addr,
636				     int persistent_group)
637{
638	if (!wpa_s->driver->p2p_invite)
639		return -1;
640	return wpa_s->driver->p2p_invite(wpa_s->drv_priv, peer, role, bssid,
641					 ssid, ssid_len, go_dev_addr,
642					 persistent_group);
643}
644
645static inline int wpa_drv_send_tdls_mgmt(struct wpa_supplicant *wpa_s,
646					 const u8 *dst, u8 action_code,
647					 u8 dialog_token, u16 status_code,
648					 const u8 *buf, size_t len)
649{
650	if (wpa_s->driver->send_tdls_mgmt) {
651		return wpa_s->driver->send_tdls_mgmt(wpa_s->drv_priv, dst,
652						     action_code, dialog_token,
653						     status_code, buf, len);
654	}
655	return -1;
656}
657
658static inline int wpa_drv_tdls_oper(struct wpa_supplicant *wpa_s,
659				    enum tdls_oper oper, const u8 *peer)
660{
661	if (!wpa_s->driver->tdls_oper)
662		return -1;
663	return wpa_s->driver->tdls_oper(wpa_s->drv_priv, oper, peer);
664}
665
666#ifdef ANDROID
667static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
668				     char *cmd, char *buf, size_t buf_len)
669{
670	if (!wpa_s->driver->driver_cmd)
671		return -1;
672	return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
673}
674#endif
675
676static inline void wpa_drv_set_rekey_info(struct wpa_supplicant *wpa_s,
677					  const u8 *kek, const u8 *kck,
678					  const u8 *replay_ctr)
679{
680	if (!wpa_s->driver->set_rekey_info)
681		return;
682	wpa_s->driver->set_rekey_info(wpa_s->drv_priv, kek, kck, replay_ctr);
683}
684
685static inline int wpa_drv_radio_disable(struct wpa_supplicant *wpa_s,
686					int disabled)
687{
688	if (!wpa_s->driver->radio_disable)
689		return -1;
690	return wpa_s->driver->radio_disable(wpa_s->drv_priv, disabled);
691}
692
693static inline int wpa_drv_switch_channel(struct wpa_supplicant *wpa_s,
694					 unsigned int freq)
695{
696	if (!wpa_s->driver->switch_channel)
697		return -1;
698	return wpa_s->driver->switch_channel(wpa_s->drv_priv, freq);
699}
700
701static inline int wpa_drv_wnm_oper(struct wpa_supplicant *wpa_s,
702				   enum wnm_oper oper, const u8 *peer,
703				   u8 *buf, u16 *buf_len)
704{
705	if (!wpa_s->driver->wnm_oper)
706		return -1;
707	return wpa_s->driver->wnm_oper(wpa_s->drv_priv, oper, peer, buf,
708				       buf_len);
709}
710
711#endif /* DRIVER_I_H */
712