[thirdparty/hostap.git] / wpa_supplicant / driver_i.h

/*
 * wpa_supplicant - Internal driver interface wrappers
 * Copyright (c) 2003-2009, Jouni Malinen <j@w1.fi>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * Alternatively, this software may be distributed under the terms of BSD
 * license.
 *
 * See README and COPYING for more details.
 */

#ifndef DRIVER_I_H
#define DRIVER_I_H

#include "drivers/driver.h"

/* driver_ops */
static inline void * wpa_drv_init(struct wpa_supplicant *wpa_s,
				  const char *ifname)
{
	if (wpa_s->driver->init2)
		return wpa_s->driver->init2(wpa_s, ifname,
					    wpa_s->global_drv_priv);
	if (wpa_s->driver->init) {
		return wpa_s->driver->init(wpa_s, ifname);
	}
	return NULL;
}

static inline void wpa_drv_deinit(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->deinit)
		wpa_s->driver->deinit(wpa_s->drv_priv);
}

static inline int wpa_drv_set_param(struct wpa_supplicant *wpa_s,
				    const char *param)
{
	if (wpa_s->driver->set_param)
		return wpa_s->driver->set_param(wpa_s->drv_priv, param);
	return 0;
}

static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s,
					      int enabled)
{
	if (wpa_s->driver->set_countermeasures) {
		return wpa_s->driver->set_countermeasures(wpa_s->drv_priv,
							  enabled);
	}
	return -1;
}

static inline int wpa_drv_authenticate(struct wpa_supplicant *wpa_s,
				       struct wpa_driver_auth_params *params)
{
	if (wpa_s->driver->authenticate)
		return wpa_s->driver->authenticate(wpa_s->drv_priv, params);
	return -1;
}

static inline int wpa_drv_associate(struct wpa_supplicant *wpa_s,
				    struct wpa_driver_associate_params *params)
{
	if (wpa_s->driver->associate) {
		return wpa_s->driver->associate(wpa_s->drv_priv, params);
	}
	return -1;
}

static inline int wpa_drv_scan(struct wpa_supplicant *wpa_s,
			       struct wpa_driver_scan_params *params)
{
	if (wpa_s->driver->scan2)
		return wpa_s->driver->scan2(wpa_s->drv_priv, params);
	return -1;
}

static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
	struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->get_scan_results2)
		return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
	return NULL;
}

static inline int wpa_drv_get_bssid(struct wpa_supplicant *wpa_s, u8 *bssid)
{
	if (wpa_s->driver->get_bssid) {
		return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
	}
	return -1;
}

static inline int wpa_drv_get_ssid(struct wpa_supplicant *wpa_s, u8 *ssid)
{
	if (wpa_s->driver->get_ssid) {
		return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
	}
	return -1;
}

static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s,
				  enum wpa_alg alg, const u8 *addr,
				  int key_idx, int set_tx,
				   const u8 *seq, size_t seq_len,
				   const u8 *key, size_t key_len)
{
	if (wpa_s->driver->set_key) {
		wpa_s->keys_cleared = 0;
		return wpa_s->driver->set_key(wpa_s->ifname, wpa_s->drv_priv,
					      alg, addr, key_idx, set_tx,
					      seq, seq_len, key, key_len);
	}
	return -1;
}

static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
					 const u8 *addr, int reason_code)
{
	if (wpa_s->driver->deauthenticate) {
		return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
						     reason_code);
	}
	return -1;
}

static inline int wpa_drv_disassociate(struct wpa_supplicant *wpa_s,
				       const u8 *addr, int reason_code)
{
	if (wpa_s->driver->disassociate) {
		return wpa_s->driver->disassociate(wpa_s->drv_priv, addr,
						   reason_code);
	}
	return -1;
}

static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
				    const u8 *bssid, const u8 *pmkid)
{
	if (wpa_s->driver->add_pmkid) {
		return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
	}
	return -1;
}

static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
				       const u8 *bssid, const u8 *pmkid)
{
	if (wpa_s->driver->remove_pmkid) {
		return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
						   pmkid);
	}
	return -1;
}

static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->flush_pmkid) {
		return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
	}
	return -1;
}

static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
				   struct wpa_driver_capa *capa)
{
	if (wpa_s->driver->get_capa) {
		return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
	}
	return -1;
}

static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->poll) {
		wpa_s->driver->poll(wpa_s->drv_priv);
	}
}

static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->get_ifname) {
		return wpa_s->driver->get_ifname(wpa_s->drv_priv);
	}
	return NULL;
}

static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->get_mac_addr) {
		return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
	}
	return NULL;
}

static inline int wpa_drv_send_eapol(struct wpa_supplicant *wpa_s,
				     const u8 *dst, u16 proto,
				     const u8 *data, size_t data_len)
{
	if (wpa_s->driver->send_eapol)
		return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto,
						 data, data_len);
	return -1;
}

static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
					int state)
{
	if (wpa_s->driver->set_operstate)
		return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
	return 0;
}

static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
					     const u8 *addr, int protect_type,
					     int key_type)
{
	if (wpa_s->driver->mlme_setprotection)
		return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
							 protect_type,
							 key_type);
	return 0;
}

static inline struct hostapd_hw_modes *
wpa_drv_get_hw_feature_data(struct wpa_supplicant *wpa_s, u16 *num_modes,
			    u16 *flags)
{
	if (wpa_s->driver->get_hw_feature_data)
		return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
							  num_modes, flags);
	return NULL;
}

static inline int wpa_drv_set_channel(struct wpa_supplicant *wpa_s,
				      enum hostapd_hw_mode phymode, int chan,
				      int freq)
{
	if (wpa_s->driver->set_channel)
		return wpa_s->driver->set_channel(wpa_s->drv_priv, phymode,
						  chan, freq);
	return -1;
}

static inline int wpa_drv_set_ssid(struct wpa_supplicant *wpa_s,
				   const u8 *ssid, size_t ssid_len)
{
	if (wpa_s->driver->set_ssid) {
		return wpa_s->driver->set_ssid(wpa_s->drv_priv, ssid,
					       ssid_len);
	}
	return -1;
}

static inline int wpa_drv_set_bssid(struct wpa_supplicant *wpa_s,
				    const u8 *bssid)
{
	if (wpa_s->driver->set_bssid) {
		return wpa_s->driver->set_bssid(wpa_s->drv_priv, bssid);
	}
	return -1;
}

static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
				      const char *alpha2)
{
	if (wpa_s->driver->set_country)
		return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
	return 0;
}

static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
				    const u8 *data, size_t data_len)
{
	if (wpa_s->driver->send_mlme)
		return wpa_s->driver->send_mlme(wpa_s->drv_priv,
						data, data_len);
	return -1;
}

static inline int wpa_drv_mlme_add_sta(struct wpa_supplicant *wpa_s,
				       const u8 *addr, const u8 *supp_rates,
				       size_t supp_rates_len)
{
	if (wpa_s->driver->mlme_add_sta)
		return wpa_s->driver->mlme_add_sta(wpa_s->drv_priv, addr,
						   supp_rates, supp_rates_len);
	return -1;
}

static inline int wpa_drv_mlme_remove_sta(struct wpa_supplicant *wpa_s,
					  const u8 *addr)
{
	if (wpa_s->driver->mlme_remove_sta)
		return wpa_s->driver->mlme_remove_sta(wpa_s->drv_priv, addr);
	return -1;
}

static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
					const u8 *md,
					const u8 *ies, size_t ies_len)
{
	if (wpa_s->driver->update_ft_ies)
		return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
						    ies, ies_len);
	return -1;
}

static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
					 u8 action, const u8 *target_ap,
					 const u8 *ies, size_t ies_len)
{
	if (wpa_s->driver->send_ft_action)
		return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
						     target_ap, ies, ies_len);
	return -1;
}

static inline int wpa_drv_set_beacon(struct wpa_supplicant *wpa_s,
				     const u8 *head, size_t head_len,
				     const u8 *tail, size_t tail_len,
				     int dtim_period, int beacon_int)
{
	if (wpa_s->driver->set_beacon)
		return wpa_s->driver->set_beacon(wpa_s->drv_priv, head,
						 head_len, tail, tail_len,
						 dtim_period, beacon_int);
	return -1;
}

static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
				  struct hostapd_sta_add_params *params)
{
	if (wpa_s->driver->sta_add)
		return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
	return -1;
}

static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
				     const u8 *addr)
{
	if (wpa_s->driver->sta_remove)
		return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
	return -1;
}

static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
					  const u8 *addr, const u8 *data,
					  size_t data_len, int encrypt,
					  const u8 *own_addr)
{
	if (wpa_s->driver->hapd_send_eapol)
		return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
						      data, data_len, encrypt,
						      own_addr);
	return -1;
}

static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
					const u8 *addr, int total_flags,
					int flags_or, int flags_and)
{
	if (wpa_s->driver->sta_set_flags)
		return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
						    total_flags, flags_or,
						    flags_and);
	return -1;
}

static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
					int authorized)
{
	if (wpa_s->driver->set_supp_port) {
		return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
						    authorized);
	}
	return 0;
}

static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
				      unsigned int freq,
				      const u8 *dst, const u8 *src,
				      const u8 *bssid,
				      const u8 *data, size_t data_len)
{
	if (wpa_s->driver->send_action)
		return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
						  dst, src, bssid, data,
						  data_len);
	return -1;
}

static inline int wpa_drv_set_freq(struct wpa_supplicant *wpa_s,
				   struct hostapd_freq_params *freq)
{
	if (wpa_s->driver->set_freq)
		return wpa_s->driver->set_freq(wpa_s->drv_priv, freq);
	return -1;
}

static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
				 enum wpa_driver_if_type type,
				 const char *ifname, const u8 *addr,
				 void *bss_ctx, char *force_ifname,
				 u8 *if_addr)
{
	if (wpa_s->driver->if_add)
		return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
					     addr, bss_ctx, NULL, force_ifname,
					     if_addr);
	return -1;
}

static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
				    enum wpa_driver_if_type type,
				    const char *ifname)
{
	if (wpa_s->driver->if_remove)
		return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
	return -1;
}

static inline int wpa_drv_set_intra_bss(struct wpa_supplicant *wpa_s,
					int enabled)
{
	if (wpa_s->driver->set_intra_bss)
		return wpa_s->driver->set_intra_bss(wpa_s->drv_priv, enabled);
	return -1;
}

static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
					    unsigned int freq,
					    unsigned int duration)
{
	if (wpa_s->driver->remain_on_channel)
		return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
							duration);
	return -1;
}

static inline int wpa_drv_cancel_remain_on_channel(
	struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->cancel_remain_on_channel)
		return wpa_s->driver->cancel_remain_on_channel(
			wpa_s->drv_priv);
	return -1;
}

static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
					   int report)
{
	if (wpa_s->driver->probe_req_report)
		return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
						       report);
	return -1;
}

static inline int wpa_drv_disable_11b_rates(struct wpa_supplicant *wpa_s,
					    int disabled)
{
	if (wpa_s->driver->disable_11b_rates)
		return wpa_s->driver->disable_11b_rates(wpa_s->drv_priv,
							disabled);
	return -1;
}

static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->deinit_ap)
		return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
	return 0;
}

static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->suspend)
		wpa_s->driver->suspend(wpa_s->drv_priv);
}

static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->resume)
		wpa_s->driver->resume(wpa_s->drv_priv);
}

static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
					 int threshold, int hysteresis)
{
	if (wpa_s->driver->signal_monitor)
		return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
						     threshold, hysteresis);
	return -1;
}

static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
					const struct wpabuf *beacon,
					const struct wpabuf *proberesp,
					const struct wpabuf *assocresp)
{
	if (!wpa_s->driver->set_ap_wps_ie)
		return -1;
	return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
					    proberesp, assocresp);
}

static inline int wpa_drv_shared_freq(struct wpa_supplicant *wpa_s)
{
	if (!wpa_s->driver->shared_freq)
		return -1;
	return wpa_s->driver->shared_freq(wpa_s->drv_priv);
}

static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
				  u8 *buf, size_t buf_len)
{
	if (!wpa_s->driver->get_noa)
		return -1;
	return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
}

static inline int wpa_drv_set_p2p_powersave(struct wpa_supplicant *wpa_s,
					    int legacy_ps, int opp_ps,
					    int ctwindow)
{
	if (!wpa_s->driver->set_p2p_powersave)
		return -1;
	return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
						opp_ps, ctwindow);
}

static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
{
	if (!wpa_s->driver->ampdu)
		return -1;
	return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
}

#endif /* DRIVER_I_H */
Commit	Line	Data
2d5b792d JM	1	/*
	2	* wpa_supplicant - Internal driver interface wrappers
	3	* Copyright (c) 2003-2009, Jouni Malinen <j@w1.fi>
	4	*
	5	* This program is free software; you can redistribute it and/or modify
	6	* it under the terms of the GNU General Public License version 2 as
	7	* published by the Free Software Foundation.
	8	*
	9	* Alternatively, this software may be distributed under the terms of BSD
	10	* license.
	11	*
	12	* See README and COPYING for more details.
	13	*/
	14
	15	#ifndef DRIVER_I_H
	16	#define DRIVER_I_H
	17
	18	#include "drivers/driver.h"
	19
	20	/* driver_ops */
	21	static inline void * wpa_drv_init(struct wpa_supplicant *wpa_s,
	22	const char *ifname)
	23	{
	24	if (wpa_s->driver->init2)
8a5ab9f5 JM	25	return wpa_s->driver->init2(wpa_s, ifname,
8a5ab9f5 JM	26	wpa_s->global_drv_priv);
2d5b792d JM	27	if (wpa_s->driver->init) {
	28	return wpa_s->driver->init(wpa_s, ifname);
	29	}
	30	return NULL;
	31	}
	32
	33	static inline void wpa_drv_deinit(struct wpa_supplicant *wpa_s)
	34	{
	35	if (wpa_s->driver->deinit)
	36	wpa_s->driver->deinit(wpa_s->drv_priv);
	37	}
	38
	39	static inline int wpa_drv_set_param(struct wpa_supplicant *wpa_s,
	40	const char *param)
	41	{
	42	if (wpa_s->driver->set_param)
	43	return wpa_s->driver->set_param(wpa_s->drv_priv, param);
	44	return 0;
	45	}
	46
2d5b792d JM	47	static inline int wpa_drv_set_countermeasures(struct wpa_supplicant *wpa_s,
	48	int enabled)
	49	{
	50	if (wpa_s->driver->set_countermeasures) {
	51	return wpa_s->driver->set_countermeasures(wpa_s->drv_priv,
	52	enabled);
	53	}
	54	return -1;
	55	}
	56
2d5b792d JM	57	static inline int wpa_drv_authenticate(struct wpa_supplicant *wpa_s,
	58	struct wpa_driver_auth_params *params)
	59	{
	60	if (wpa_s->driver->authenticate)
	61	return wpa_s->driver->authenticate(wpa_s->drv_priv, params);
	62	return -1;
	63	}
	64
	65	static inline int wpa_drv_associate(struct wpa_supplicant *wpa_s,
	66	struct wpa_driver_associate_params *params)
	67	{
	68	if (wpa_s->driver->associate) {
	69	return wpa_s->driver->associate(wpa_s->drv_priv, params);
	70	}
	71	return -1;
	72	}
	73
	74	static inline int wpa_drv_scan(struct wpa_supplicant *wpa_s,
	75	struct wpa_driver_scan_params *params)
	76	{
	77	if (wpa_s->driver->scan2)
	78	return wpa_s->driver->scan2(wpa_s->drv_priv, params);
2d5b792d JM	79	return -1;
	80	}
	81
2d5b792d JM	82	static inline struct wpa_scan_results * wpa_drv_get_scan_results2(
	83	struct wpa_supplicant *wpa_s)
	84	{
	85	if (wpa_s->driver->get_scan_results2)
	86	return wpa_s->driver->get_scan_results2(wpa_s->drv_priv);
	87	return NULL;
	88	}
	89
	90	static inline int wpa_drv_get_bssid(struct wpa_supplicant wpa_s, u8 bssid)
	91	{
	92	if (wpa_s->driver->get_bssid) {
	93	return wpa_s->driver->get_bssid(wpa_s->drv_priv, bssid);
	94	}
	95	return -1;
	96	}
	97
	98	static inline int wpa_drv_get_ssid(struct wpa_supplicant wpa_s, u8 ssid)
	99	{
	100	if (wpa_s->driver->get_ssid) {
	101	return wpa_s->driver->get_ssid(wpa_s->drv_priv, ssid);
	102	}
	103	return -1;
	104	}
	105
71934751 JM	106	static inline int wpa_drv_set_key(struct wpa_supplicant *wpa_s,
	107	enum wpa_alg alg, const u8 *addr,
	108	int key_idx, int set_tx,
2d5b792d JM	109	const u8 *seq, size_t seq_len,
	110	const u8 *key, size_t key_len)
	111	{
	112	if (wpa_s->driver->set_key) {
	113	wpa_s->keys_cleared = 0;
642187d6 JM	114	return wpa_s->driver->set_key(wpa_s->ifname, wpa_s->drv_priv,
	115	alg, addr, key_idx, set_tx,
	116	seq, seq_len, key, key_len);
2d5b792d JM	117	}
	118	return -1;
	119	}
	120
	121	static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
	122	const u8 *addr, int reason_code)
	123	{
	124	if (wpa_s->driver->deauthenticate) {
	125	return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
	126	reason_code);
	127	}
	128	return -1;
	129	}
	130
	131	static inline int wpa_drv_disassociate(struct wpa_supplicant *wpa_s,
	132	const u8 *addr, int reason_code)
	133	{
	134	if (wpa_s->driver->disassociate) {
	135	return wpa_s->driver->disassociate(wpa_s->drv_priv, addr,
	136	reason_code);
	137	}
	138	return -1;
	139	}
	140
	141	static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
	142	const u8 bssid, const u8 pmkid)
	143	{
	144	if (wpa_s->driver->add_pmkid) {
	145	return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
	146	}
	147	return -1;
	148	}
	149
	150	static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
	151	const u8 bssid, const u8 pmkid)
	152	{
	153	if (wpa_s->driver->remove_pmkid) {
	154	return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
	155	pmkid);
	156	}
	157	return -1;
	158	}
	159
	160	static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
	161	{
	162	if (wpa_s->driver->flush_pmkid) {
	163	return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
	164	}
	165	return -1;
	166	}
	167
	168	static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
	169	struct wpa_driver_capa *capa)
	170	{
	171	if (wpa_s->driver->get_capa) {
	172	return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
	173	}
	174	return -1;
	175	}
	176
	177	static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
	178	{
	179	if (wpa_s->driver->poll) {
	180	wpa_s->driver->poll(wpa_s->drv_priv);
181	}
182	}
183
184	static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
185	{
186	if (wpa_s->driver->get_ifname) {
187	return wpa_s->driver->get_ifname(wpa_s->drv_priv);
188	}
189	return NULL;
190	}
191
192	static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
193	{
194	if (wpa_s->driver->get_mac_addr) {
195	return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
196	}
197	return NULL;
198	}
199
200	static inline int wpa_drv_send_eapol(struct wpa_supplicant *wpa_s,
201	const u8 *dst, u16 proto,
202	const u8 *data, size_t data_len)
203	{
204	if (wpa_s->driver->send_eapol)
205	return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto,
206	data, data_len);
207	return -1;
208	}
209
210	static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
211	int state)
212	{
213	if (wpa_s->driver->set_operstate)
214	return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
215	return 0;
216	}
217
218	static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
219	const u8 *addr, int protect_type,
220	int key_type)
221	{
222	if (wpa_s->driver->mlme_setprotection)
223	return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
224	protect_type,
225	key_type);
226	return 0;
227	}
228
6caf9ca6	229	static inline struct hostapd_hw_modes *
2d5b792d JM	230	wpa_drv_get_hw_feature_data(struct wpa_supplicant wpa_s, u16 num_modes,
	231	u16 *flags)
	232	{
	233	if (wpa_s->driver->get_hw_feature_data)
	234	return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
	235	num_modes, flags);
	236	return NULL;
	237	}
	238
	239	static inline int wpa_drv_set_channel(struct wpa_supplicant *wpa_s,
71934751	240	enum hostapd_hw_mode phymode, int chan,
2d5b792d JM	241	int freq)
	242	{
	243	if (wpa_s->driver->set_channel)
	244	return wpa_s->driver->set_channel(wpa_s->drv_priv, phymode,
	245	chan, freq);
	246	return -1;
	247	}
	248
	249	static inline int wpa_drv_set_ssid(struct wpa_supplicant *wpa_s,
	250	const u8 *ssid, size_t ssid_len)
	251	{
	252	if (wpa_s->driver->set_ssid) {
	253	return wpa_s->driver->set_ssid(wpa_s->drv_priv, ssid,
	254	ssid_len);
	255	}
	256	return -1;
	257	}
	258
	259	static inline int wpa_drv_set_bssid(struct wpa_supplicant *wpa_s,
	260	const u8 *bssid)
	261	{
	262	if (wpa_s->driver->set_bssid) {
	263	return wpa_s->driver->set_bssid(wpa_s->drv_priv, bssid);
	264	}
	265	return -1;
	266	}
	267
	268	static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
	269	const char *alpha2)
	270	{
	271	if (wpa_s->driver->set_country)
	272	return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
	273	return 0;
	274	}
	275
	276	static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
	277	const u8 *data, size_t data_len)
	278	{
	279	if (wpa_s->driver->send_mlme)
	280	return wpa_s->driver->send_mlme(wpa_s->drv_priv,
	281	data, data_len);
	282	return -1;
	283	}
	284
	285	static inline int wpa_drv_mlme_add_sta(struct wpa_supplicant *wpa_s,
	286	const u8 addr, const u8 supp_rates,
	287	size_t supp_rates_len)
	288	{
	289	if (wpa_s->driver->mlme_add_sta)
	290	return wpa_s->driver->mlme_add_sta(wpa_s->drv_priv, addr,
	291	supp_rates, supp_rates_len);
	292	return -1;
	293	}
	294
	295	static inline int wpa_drv_mlme_remove_sta(struct wpa_supplicant *wpa_s,
	296	const u8 *addr)
	297	{
	298	if (wpa_s->driver->mlme_remove_sta)
	299	return wpa_s->driver->mlme_remove_sta(wpa_s->drv_priv, addr);
	300	return -1;
	301	}
	302
	303	static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
	304	const u8 *md,
305	const u8 *ies, size_t ies_len)
306	{
307	if (wpa_s->driver->update_ft_ies)
308	return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
309	ies, ies_len);
310	return -1;
311	}
312
313	static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
314	u8 action, const u8 *target_ap,
315	const u8 *ies, size_t ies_len)
316	{
317	if (wpa_s->driver->send_ft_action)
318	return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
319	target_ap, ies, ies_len);
320	return -1;
321	}
322
d2440ba0 JM	323	static inline int wpa_drv_set_beacon(struct wpa_supplicant *wpa_s,
	324	const u8 *head, size_t head_len,
	325	const u8 *tail, size_t tail_len,
5d674872	326	int dtim_period, int beacon_int)
d2440ba0 JM	327	{
d2440ba0 JM	328	if (wpa_s->driver->set_beacon)
17557ebe	329	return wpa_s->driver->set_beacon(wpa_s->drv_priv, head,
d2440ba0	330	head_len, tail, tail_len,
5d674872	331	dtim_period, beacon_int);
d2440ba0 JM	332	return -1;
	333	}
	334
0f4e8b4f JM	335	static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
	336	struct hostapd_sta_add_params *params)
	337	{
	338	if (wpa_s->driver->sta_add)
62847751	339	return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
0f4e8b4f JM	340	return -1;
	341	}
	342
	343	static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
	344	const u8 *addr)
	345	{
	346	if (wpa_s->driver->sta_remove)
	347	return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
	348	return -1;
	349	}
	350
db149ac9 JM	351	static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
	352	const u8 addr, const u8 data,
	353	size_t data_len, int encrypt,
	354	const u8 *own_addr)
	355	{
	356	if (wpa_s->driver->hapd_send_eapol)
	357	return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
	358	data, data_len, encrypt,
	359	own_addr);
	360	return -1;
	361	}
	362
a8d6ffa4 JM	363	static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
	364	const u8 *addr, int total_flags,
	365	int flags_or, int flags_and)
	366	{
	367	if (wpa_s->driver->sta_set_flags)
3234cba4	368	return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
a8d6ffa4 JM	369	total_flags, flags_or,
	370	flags_and);
	371	return -1;
	372	}
	373
4bc181ec JM	374	static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
	375	int authorized)
	376	{
	377	if (wpa_s->driver->set_supp_port) {
	378	return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
	379	authorized);
	380	}
	381	return 0;
	382	}
	383
55777702 JM	384	static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
	385	unsigned int freq,
	386	const u8 dst, const u8 src,
e8828999	387	const u8 *bssid,
55777702 JM	388	const u8 *data, size_t data_len)
	389	{
	390	if (wpa_s->driver->send_action)
	391	return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
e8828999 JM	392	dst, src, bssid, data,
e8828999 JM	393	data_len);
55777702 JM	394	return -1;
	395	}
	396
75bde05d JM	397	static inline int wpa_drv_set_freq(struct wpa_supplicant *wpa_s,
	398	struct hostapd_freq_params *freq)
	399	{
	400	if (wpa_s->driver->set_freq)
	401	return wpa_s->driver->set_freq(wpa_s->drv_priv, freq);
	402	return -1;
	403	}
	404
f3585c8a JM	405	static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
	406	enum wpa_driver_if_type type,
	407	const char ifname, const u8 addr,
	408	void bss_ctx, char force_ifname,
	409	u8 *if_addr)
	410	{
	411	if (wpa_s->driver->if_add)
	412	return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
	413	addr, bss_ctx, NULL, force_ifname,
	414	if_addr);
7bfc47c3 JM	415	return -1;
	416	}
	417
f3585c8a JM	418	static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
	419	enum wpa_driver_if_type type,
	420	const char *ifname)
7bfc47c3	421	{
f3585c8a JM	422	if (wpa_s->driver->if_remove)
	423	return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
	424	return -1;
7bfc47c3 JM	425	}
7bfc47c3 JM	426
0f66abd2 SS	427	static inline int wpa_drv_set_intra_bss(struct wpa_supplicant *wpa_s,
	428	int enabled)
	429	{
	430	if (wpa_s->driver->set_intra_bss)
	431	return wpa_s->driver->set_intra_bss(wpa_s->drv_priv, enabled);
	432	return -1;
	433	}
	434
55777702 JM	435	static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
	436	unsigned int freq,
	437	unsigned int duration)
	438	{
	439	if (wpa_s->driver->remain_on_channel)
	440	return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
	441	duration);
	442	return -1;
	443	}
	444
	445	static inline int wpa_drv_cancel_remain_on_channel(
	446	struct wpa_supplicant *wpa_s)
	447	{
	448	if (wpa_s->driver->cancel_remain_on_channel)
	449	return wpa_s->driver->cancel_remain_on_channel(
	450	wpa_s->drv_priv);
	451	return -1;
	452	}
	453
504e905c JM	454	static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
	455	int report)
	456	{
	457	if (wpa_s->driver->probe_req_report)
	458	return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
	459	report);
	460	return -1;
	461	}
	462
e8828999 JM	463	static inline int wpa_drv_disable_11b_rates(struct wpa_supplicant *wpa_s,
	464	int disabled)
	465	{
	466	if (wpa_s->driver->disable_11b_rates)
	467	return wpa_s->driver->disable_11b_rates(wpa_s->drv_priv,
	468	disabled);
	469	return -1;
	470	}
	471
af473088 JM	472	static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
	473	{
	474	if (wpa_s->driver->deinit_ap)
	475	return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
	476	return 0;
	477	}
	478
207ef3fb JM	479	static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
	480	{
	481	if (wpa_s->driver->suspend)
	482	wpa_s->driver->suspend(wpa_s->drv_priv);
	483	}
	484
	485	static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
	486	{
	487	if (wpa_s->driver->resume)
	488	wpa_s->driver->resume(wpa_s->drv_priv);
	489	}
	490
b625473c JM	491	static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
	492	int threshold, int hysteresis)
	493	{
	494	if (wpa_s->driver->signal_monitor)
	495	return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
	496	threshold, hysteresis);
	497	return -1;
	498	}
	499
b3db190f JM	500	static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
b3db190f JM	501	const struct wpabuf *beacon,
0e2e565a JM	502	const struct wpabuf *proberesp,
0e2e565a JM	503	const struct wpabuf *assocresp)
b3db190f JM	504	{
	505	if (!wpa_s->driver->set_ap_wps_ie)
	506	return -1;
	507	return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
0e2e565a	508	proberesp, assocresp);
b3db190f JM	509	}
b3db190f JM	510
75bde05d JM	511	static inline int wpa_drv_shared_freq(struct wpa_supplicant *wpa_s)
	512	{
	513	if (!wpa_s->driver->shared_freq)
	514	return -1;
	515	return wpa_s->driver->shared_freq(wpa_s->drv_priv);
	516	}
	517
	518	static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
	519	u8 *buf, size_t buf_len)
	520	{
	521	if (!wpa_s->driver->get_noa)
	522	return -1;
	523	return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
	524	}
	525
c381508d JM	526	static inline int wpa_drv_set_p2p_powersave(struct wpa_supplicant *wpa_s,
	527	int legacy_ps, int opp_ps,
	528	int ctwindow)
	529	{
	530	if (!wpa_s->driver->set_p2p_powersave)
	531	return -1;
	532	return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
	533	opp_ps, ctwindow);
	534	}
	535
b6c79a99 JM	536	static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
	537	{
	538	if (!wpa_s->driver->ampdu)
	539	return -1;
	540	return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
	541	}
	542
2d5b792d	543	#endif /* DRIVER_I_H */