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