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

/*
 * wpa_supplicant - Internal driver interface wrappers
 * Copyright (c) 2003-2009, Jouni Malinen <j@w1.fi>
 *
 * This software may be distributed under the terms of the BSD license.
 * See README 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 int wpa_drv_sched_scan(struct wpa_supplicant *wpa_s,
				     struct wpa_driver_scan_params *params,
				     u32 interval)
{
	if (wpa_s->driver->sched_scan)
		return wpa_s->driver->sched_scan(wpa_s->drv_priv,
						 params, interval);
	return -1;
}

static inline int wpa_drv_stop_sched_scan(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->stop_sched_scan)
		return wpa_s->driver->stop_sched_scan(wpa_s->drv_priv);
	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_sta_deauth(struct wpa_supplicant *wpa_s,
				     const u8 *addr, int reason_code)
{
	if (wpa_s->driver->sta_deauth) {
		return wpa_s->driver->sta_deauth(wpa_s->drv_priv,
						 wpa_s->own_addr, addr,
						 reason_code);
	}
	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_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_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, int noack)
{
	if (wpa_s->driver->send_mlme)
		return wpa_s->driver->send_mlme(wpa_s->drv_priv,
						data, data_len, noack);
	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_ap(struct wpa_supplicant *wpa_s,
				 struct wpa_driver_ap_params *params)
{
	if (wpa_s->driver->set_ap)
		return wpa_s->driver->set_ap(wpa_s->drv_priv, params);
	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, u32 flags)
{
	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, flags);
	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,
				      unsigned int wait,
				      const u8 *dst, const u8 *src,
				      const u8 *bssid,
				      const u8 *data, size_t data_len,
				      int no_cck)
{
	if (wpa_s->driver->send_action)
		return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
						  wait, dst, src, bssid,
						  data, data_len, no_cck);
	return -1;
}

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

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, const char *bridge)
{
	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, bridge, 0);
	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_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_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 int wpa_drv_deinit_p2p_cli(struct wpa_supplicant *wpa_s)
{
	if (wpa_s->driver->deinit_p2p_cli)
		return wpa_s->driver->deinit_p2p_cli(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_signal_poll(struct wpa_supplicant *wpa_s,
				      struct wpa_signal_info *si)
{
	if (wpa_s->driver->signal_poll)
		return wpa_s->driver->signal_poll(wpa_s->drv_priv, si);
	return -1;
}

static inline int wpa_drv_pktcnt_poll(struct wpa_supplicant *wpa_s,
				      struct hostap_sta_driver_data *sta)
{
	if (wpa_s->driver->read_sta_data)
		return wpa_s->driver->read_sta_data(wpa_s->drv_priv, sta,
						    wpa_s->bssid);
	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);
}

static inline int wpa_drv_send_tdls_mgmt(struct wpa_supplicant *wpa_s,
					 const u8 *dst, u8 action_code,
					 u8 dialog_token, u16 status_code,
					 const u8 *buf, size_t len)
{
	if (wpa_s->driver->send_tdls_mgmt) {
		return wpa_s->driver->send_tdls_mgmt(wpa_s->drv_priv, dst,
						     action_code, dialog_token,
						     status_code, buf, len);
	}
	return -1;
}

static inline int wpa_drv_tdls_oper(struct wpa_supplicant *wpa_s,
				    enum tdls_oper oper, const u8 *peer)
{
	if (!wpa_s->driver->tdls_oper)
		return -1;
	return wpa_s->driver->tdls_oper(wpa_s->drv_priv, oper, peer);
}

#ifdef ANDROID
static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
				     char *cmd, char *buf, size_t buf_len)
{
	if (!wpa_s->driver->driver_cmd)
		return -1;
	return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
}
#endif /* ANDROID */

static inline void wpa_drv_set_rekey_info(struct wpa_supplicant *wpa_s,
					  const u8 *kek, const u8 *kck,
					  const u8 *replay_ctr)
{
	if (!wpa_s->driver->set_rekey_info)
		return;
	wpa_s->driver->set_rekey_info(wpa_s->drv_priv, kek, kck, replay_ctr);
}

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

static inline int wpa_drv_switch_channel(struct wpa_supplicant *wpa_s,
					 struct csa_settings *settings)
{
	if (!wpa_s->driver->switch_channel)
		return -1;
	return wpa_s->driver->switch_channel(wpa_s->drv_priv, settings);
}

static inline int wpa_drv_wnm_oper(struct wpa_supplicant *wpa_s,
				   enum wnm_oper oper, const u8 *peer,
				   u8 *buf, u16 *buf_len)
{
	if (!wpa_s->driver->wnm_oper)
		return -1;
	return wpa_s->driver->wnm_oper(wpa_s->drv_priv, oper, peer, buf,
				       buf_len);
}

static inline int wpa_drv_status(struct wpa_supplicant *wpa_s,
				 char *buf, size_t buflen)
{
	if (!wpa_s->driver->status)
		return -1;
	return wpa_s->driver->status(wpa_s->drv_priv, buf, buflen);
}

static inline int wpa_drv_set_qos_map(struct wpa_supplicant *wpa_s,
				      const u8 *qos_map_set, u8 qos_map_set_len)
{
	if (!wpa_s->driver->set_qos_map)
		return -1;
	return wpa_s->driver->set_qos_map(wpa_s->drv_priv, qos_map_set,
					  qos_map_set_len);
}

#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	*
0f3d578e JM	5	* This software may be distributed under the terms of the BSD license.
0f3d578e JM	6	* See README for more details.
2d5b792d JM	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)
8a5ab9f5 JM	19	return wpa_s->driver->init2(wpa_s, ifname,
8a5ab9f5 JM	20	wpa_s->global_drv_priv);
2d5b792d JM	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
2d5b792d JM	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
2d5b792d JM	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_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);
2d5b792d JM	73	return -1;
	74	}
	75
cbdf3507 LC	76	static 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
	86	static 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
2d5b792d JM	93	static 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
	101	static 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
	109	static 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
71934751 JM	117	static 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,
2d5b792d JM	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;
642187d6 JM	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);
2d5b792d JM	128	}
	129	return -1;
	130	}
	131
1aef400b BB	132	static inline int wpa_drv_sta_deauth(struct wpa_supplicant *wpa_s,
	133	const u8 *addr, int reason_code)
	134	{
	135	if (wpa_s->driver->sta_deauth) {
ec384c56 JM	136	return wpa_s->driver->sta_deauth(wpa_s->drv_priv,
ec384c56 JM	137	wpa_s->own_addr, addr,
1aef400b BB	138	reason_code);
	139	}
	140	return -1;
	141	}
	142
2d5b792d JM	143	static inline int wpa_drv_deauthenticate(struct wpa_supplicant *wpa_s,
	144	const u8 *addr, int reason_code)
	145	{
	146	if (wpa_s->driver->deauthenticate) {
	147	return wpa_s->driver->deauthenticate(wpa_s->drv_priv, addr,
	148	reason_code);
	149	}
	150	return -1;
	151	}
	152
2d5b792d JM	153	static inline int wpa_drv_add_pmkid(struct wpa_supplicant *wpa_s,
	154	const u8 bssid, const u8 pmkid)
	155	{
	156	if (wpa_s->driver->add_pmkid) {
	157	return wpa_s->driver->add_pmkid(wpa_s->drv_priv, bssid, pmkid);
	158	}
	159	return -1;
	160	}
	161
	162	static inline int wpa_drv_remove_pmkid(struct wpa_supplicant *wpa_s,
	163	const u8 bssid, const u8 pmkid)
	164	{
	165	if (wpa_s->driver->remove_pmkid) {
	166	return wpa_s->driver->remove_pmkid(wpa_s->drv_priv, bssid,
	167	pmkid);
	168	}
	169	return -1;
	170	}
	171
	172	static inline int wpa_drv_flush_pmkid(struct wpa_supplicant *wpa_s)
	173	{
	174	if (wpa_s->driver->flush_pmkid) {
	175	return wpa_s->driver->flush_pmkid(wpa_s->drv_priv);
	176	}
	177	return -1;
	178	}
	179
	180	static inline int wpa_drv_get_capa(struct wpa_supplicant *wpa_s,
	181	struct wpa_driver_capa *capa)
	182	{
	183	if (wpa_s->driver->get_capa) {
	184	return wpa_s->driver->get_capa(wpa_s->drv_priv, capa);
	185	}
	186	return -1;
	187	}
	188
	189	static inline void wpa_drv_poll(struct wpa_supplicant *wpa_s)
	190	{
	191	if (wpa_s->driver->poll) {
	192	wpa_s->driver->poll(wpa_s->drv_priv);
	193	}
	194	}
	195
	196	static inline const char * wpa_drv_get_ifname(struct wpa_supplicant *wpa_s)
	197	{
	198	if (wpa_s->driver->get_ifname) {
	199	return wpa_s->driver->get_ifname(wpa_s->drv_priv);
	200	}
	201	return NULL;
	202	}
	203
	204	static inline const u8 * wpa_drv_get_mac_addr(struct wpa_supplicant *wpa_s)
	205	{
	206	if (wpa_s->driver->get_mac_addr) {
	207	return wpa_s->driver->get_mac_addr(wpa_s->drv_priv);
	208	}
	209	return NULL;
	210	}
	211
	212	static inline int wpa_drv_send_eapol(struct wpa_supplicant *wpa_s,
	213	const u8 *dst, u16 proto,
	214	const u8 *data, size_t data_len)
	215	{
	216	if (wpa_s->driver->send_eapol)
217	return wpa_s->driver->send_eapol(wpa_s->drv_priv, dst, proto,
218	data, data_len);
219	return -1;
220	}
221
222	static inline int wpa_drv_set_operstate(struct wpa_supplicant *wpa_s,
223	int state)
224	{
225	if (wpa_s->driver->set_operstate)
226	return wpa_s->driver->set_operstate(wpa_s->drv_priv, state);
227	return 0;
228	}
229
230	static inline int wpa_drv_mlme_setprotection(struct wpa_supplicant *wpa_s,
231	const u8 *addr, int protect_type,
232	int key_type)
233	{
234	if (wpa_s->driver->mlme_setprotection)
235	return wpa_s->driver->mlme_setprotection(wpa_s->drv_priv, addr,
236	protect_type,
237	key_type);
238	return 0;
239	}
240
6caf9ca6	241	static inline struct hostapd_hw_modes *
2d5b792d JM	242	wpa_drv_get_hw_feature_data(struct wpa_supplicant wpa_s, u16 num_modes,
	243	u16 *flags)
	244	{
	245	if (wpa_s->driver->get_hw_feature_data)
	246	return wpa_s->driver->get_hw_feature_data(wpa_s->drv_priv,
	247	num_modes, flags);
	248	return NULL;
	249	}
	250
2d5b792d JM	251	static inline int wpa_drv_set_country(struct wpa_supplicant *wpa_s,
	252	const char *alpha2)
	253	{
	254	if (wpa_s->driver->set_country)
	255	return wpa_s->driver->set_country(wpa_s->drv_priv, alpha2);
	256	return 0;
	257	}
	258
	259	static inline int wpa_drv_send_mlme(struct wpa_supplicant *wpa_s,
9dbf53fe	260	const u8 *data, size_t data_len, int noack)
2d5b792d JM	261	{
	262	if (wpa_s->driver->send_mlme)
	263	return wpa_s->driver->send_mlme(wpa_s->drv_priv,
9dbf53fe	264	data, data_len, noack);
2d5b792d JM	265	return -1;
	266	}
	267
2d5b792d JM	268	static inline int wpa_drv_update_ft_ies(struct wpa_supplicant *wpa_s,
	269	const u8 *md,
	270	const u8 *ies, size_t ies_len)
	271	{
	272	if (wpa_s->driver->update_ft_ies)
	273	return wpa_s->driver->update_ft_ies(wpa_s->drv_priv, md,
	274	ies, ies_len);
	275	return -1;
	276	}
	277
	278	static inline int wpa_drv_send_ft_action(struct wpa_supplicant *wpa_s,
	279	u8 action, const u8 *target_ap,
	280	const u8 *ies, size_t ies_len)
	281	{
	282	if (wpa_s->driver->send_ft_action)
	283	return wpa_s->driver->send_ft_action(wpa_s->drv_priv, action,
	284	target_ap, ies, ies_len);
	285	return -1;
	286	}
	287
19c3b566 JM	288	static inline int wpa_drv_set_ap(struct wpa_supplicant *wpa_s,
	289	struct wpa_driver_ap_params *params)
	290	{
	291	if (wpa_s->driver->set_ap)
	292	return wpa_s->driver->set_ap(wpa_s->drv_priv, params);
d2440ba0 JM	293	return -1;
	294	}
	295
0f4e8b4f JM	296	static inline int wpa_drv_sta_add(struct wpa_supplicant *wpa_s,
	297	struct hostapd_sta_add_params *params)
	298	{
	299	if (wpa_s->driver->sta_add)
62847751	300	return wpa_s->driver->sta_add(wpa_s->drv_priv, params);
0f4e8b4f JM	301	return -1;
	302	}
	303
	304	static inline int wpa_drv_sta_remove(struct wpa_supplicant *wpa_s,
	305	const u8 *addr)
	306	{
	307	if (wpa_s->driver->sta_remove)
	308	return wpa_s->driver->sta_remove(wpa_s->drv_priv, addr);
	309	return -1;
	310	}
	311
db149ac9 JM	312	static inline int wpa_drv_hapd_send_eapol(struct wpa_supplicant *wpa_s,
	313	const u8 addr, const u8 data,
	314	size_t data_len, int encrypt,
4378fc14	315	const u8 *own_addr, u32 flags)
db149ac9 JM	316	{
	317	if (wpa_s->driver->hapd_send_eapol)
	318	return wpa_s->driver->hapd_send_eapol(wpa_s->drv_priv, addr,
	319	data, data_len, encrypt,
4378fc14	320	own_addr, flags);
db149ac9 JM	321	return -1;
	322	}
	323
a8d6ffa4 JM	324	static inline int wpa_drv_sta_set_flags(struct wpa_supplicant *wpa_s,
	325	const u8 *addr, int total_flags,
	326	int flags_or, int flags_and)
	327	{
	328	if (wpa_s->driver->sta_set_flags)
3234cba4	329	return wpa_s->driver->sta_set_flags(wpa_s->drv_priv, addr,
a8d6ffa4 JM	330	total_flags, flags_or,
	331	flags_and);
	332	return -1;
	333	}
	334
4bc181ec JM	335	static inline int wpa_drv_set_supp_port(struct wpa_supplicant *wpa_s,
	336	int authorized)
	337	{
	338	if (wpa_s->driver->set_supp_port) {
	339	return wpa_s->driver->set_supp_port(wpa_s->drv_priv,
	340	authorized);
	341	}
	342	return 0;
	343	}
	344
55777702 JM	345	static inline int wpa_drv_send_action(struct wpa_supplicant *wpa_s,
55777702 JM	346	unsigned int freq,
190b9062	347	unsigned int wait,
55777702	348	const u8 dst, const u8 src,
e8828999	349	const u8 *bssid,
b106173a JM	350	const u8 *data, size_t data_len,
b106173a JM	351	int no_cck)
55777702 JM	352	{
	353	if (wpa_s->driver->send_action)
	354	return wpa_s->driver->send_action(wpa_s->drv_priv, freq,
190b9062	355	wait, dst, src, bssid,
b106173a	356	data, data_len, no_cck);
55777702 JM	357	return -1;
	358	}
	359
190b9062 JB	360	static inline void wpa_drv_send_action_cancel_wait(struct wpa_supplicant *wpa_s)
	361	{
	362	if (wpa_s->driver->send_action_cancel_wait)
	363	wpa_s->driver->send_action_cancel_wait(wpa_s->drv_priv);
	364	}
	365
75bde05d JM	366	static inline int wpa_drv_set_freq(struct wpa_supplicant *wpa_s,
	367	struct hostapd_freq_params *freq)
	368	{
	369	if (wpa_s->driver->set_freq)
	370	return wpa_s->driver->set_freq(wpa_s->drv_priv, freq);
	371	return -1;
	372	}
	373
f3585c8a JM	374	static inline int wpa_drv_if_add(struct wpa_supplicant *wpa_s,
	375	enum wpa_driver_if_type type,
	376	const char ifname, const u8 addr,
	377	void bss_ctx, char force_ifname,
e17a2477	378	u8 if_addr, const char bridge)
f3585c8a JM	379	{
	380	if (wpa_s->driver->if_add)
	381	return wpa_s->driver->if_add(wpa_s->drv_priv, type, ifname,
	382	addr, bss_ctx, NULL, force_ifname,
2aec4f3c	383	if_addr, bridge, 0);
7bfc47c3 JM	384	return -1;
	385	}
	386
f3585c8a JM	387	static inline int wpa_drv_if_remove(struct wpa_supplicant *wpa_s,
	388	enum wpa_driver_if_type type,
	389	const char *ifname)
7bfc47c3	390	{
f3585c8a JM	391	if (wpa_s->driver->if_remove)
	392	return wpa_s->driver->if_remove(wpa_s->drv_priv, type, ifname);
	393	return -1;
7bfc47c3 JM	394	}
7bfc47c3 JM	395
55777702 JM	396	static inline int wpa_drv_remain_on_channel(struct wpa_supplicant *wpa_s,
	397	unsigned int freq,
	398	unsigned int duration)
	399	{
	400	if (wpa_s->driver->remain_on_channel)
	401	return wpa_s->driver->remain_on_channel(wpa_s->drv_priv, freq,
	402	duration);
	403	return -1;
	404	}
	405
	406	static inline int wpa_drv_cancel_remain_on_channel(
	407	struct wpa_supplicant *wpa_s)
	408	{
	409	if (wpa_s->driver->cancel_remain_on_channel)
	410	return wpa_s->driver->cancel_remain_on_channel(
	411	wpa_s->drv_priv);
	412	return -1;
	413	}
	414
504e905c JM	415	static inline int wpa_drv_probe_req_report(struct wpa_supplicant *wpa_s,
	416	int report)
	417	{
	418	if (wpa_s->driver->probe_req_report)
	419	return wpa_s->driver->probe_req_report(wpa_s->drv_priv,
	420	report);
	421	return -1;
	422	}
	423
af473088 JM	424	static inline int wpa_drv_deinit_ap(struct wpa_supplicant *wpa_s)
	425	{
	426	if (wpa_s->driver->deinit_ap)
	427	return wpa_s->driver->deinit_ap(wpa_s->drv_priv);
	428	return 0;
	429	}
	430
3c29244e EP	431	static inline int wpa_drv_deinit_p2p_cli(struct wpa_supplicant *wpa_s)
	432	{
	433	if (wpa_s->driver->deinit_p2p_cli)
	434	return wpa_s->driver->deinit_p2p_cli(wpa_s->drv_priv);
	435	return 0;
	436	}
	437
207ef3fb JM	438	static inline void wpa_drv_suspend(struct wpa_supplicant *wpa_s)
	439	{
	440	if (wpa_s->driver->suspend)
	441	wpa_s->driver->suspend(wpa_s->drv_priv);
	442	}
	443
	444	static inline void wpa_drv_resume(struct wpa_supplicant *wpa_s)
	445	{
	446	if (wpa_s->driver->resume)
	447	wpa_s->driver->resume(wpa_s->drv_priv);
	448	}
	449
b625473c JM	450	static inline int wpa_drv_signal_monitor(struct wpa_supplicant *wpa_s,
	451	int threshold, int hysteresis)
	452	{
	453	if (wpa_s->driver->signal_monitor)
	454	return wpa_s->driver->signal_monitor(wpa_s->drv_priv,
	455	threshold, hysteresis);
	456	return -1;
	457	}
	458
1c5c7273 PS	459	static inline int wpa_drv_signal_poll(struct wpa_supplicant *wpa_s,
	460	struct wpa_signal_info *si)
	461	{
	462	if (wpa_s->driver->signal_poll)
	463	return wpa_s->driver->signal_poll(wpa_s->drv_priv, si);
	464	return -1;
	465	}
	466
dc7785f8 YZ	467	static inline int wpa_drv_pktcnt_poll(struct wpa_supplicant *wpa_s,
	468	struct hostap_sta_driver_data *sta)
	469	{
	470	if (wpa_s->driver->read_sta_data)
	471	return wpa_s->driver->read_sta_data(wpa_s->drv_priv, sta,
	472	wpa_s->bssid);
	473	return -1;
	474	}
	475
b3db190f JM	476	static inline int wpa_drv_set_ap_wps_ie(struct wpa_supplicant *wpa_s,
b3db190f JM	477	const struct wpabuf *beacon,
0e2e565a JM	478	const struct wpabuf *proberesp,
0e2e565a JM	479	const struct wpabuf *assocresp)
b3db190f JM	480	{
	481	if (!wpa_s->driver->set_ap_wps_ie)
	482	return -1;
	483	return wpa_s->driver->set_ap_wps_ie(wpa_s->drv_priv, beacon,
0e2e565a	484	proberesp, assocresp);
b3db190f JM	485	}
b3db190f JM	486
75bde05d JM	487	static inline int wpa_drv_shared_freq(struct wpa_supplicant *wpa_s)
	488	{
	489	if (!wpa_s->driver->shared_freq)
	490	return -1;
	491	return wpa_s->driver->shared_freq(wpa_s->drv_priv);
	492	}
	493
	494	static inline int wpa_drv_get_noa(struct wpa_supplicant *wpa_s,
	495	u8 *buf, size_t buf_len)
	496	{
	497	if (!wpa_s->driver->get_noa)
	498	return -1;
	499	return wpa_s->driver->get_noa(wpa_s->drv_priv, buf, buf_len);
	500	}
	501
c381508d JM	502	static inline int wpa_drv_set_p2p_powersave(struct wpa_supplicant *wpa_s,
	503	int legacy_ps, int opp_ps,
	504	int ctwindow)
	505	{
	506	if (!wpa_s->driver->set_p2p_powersave)
	507	return -1;
	508	return wpa_s->driver->set_p2p_powersave(wpa_s->drv_priv, legacy_ps,
	509	opp_ps, ctwindow);
	510	}
	511
b6c79a99 JM	512	static inline int wpa_drv_ampdu(struct wpa_supplicant *wpa_s, int ampdu)
	513	{
	514	if (!wpa_s->driver->ampdu)
	515	return -1;
	516	return wpa_s->driver->ampdu(wpa_s->drv_priv, ampdu);
	517	}
	518
281ff0aa GP	519	static inline int wpa_drv_send_tdls_mgmt(struct wpa_supplicant *wpa_s,
	520	const u8 *dst, u8 action_code,
	521	u8 dialog_token, u16 status_code,
	522	const u8 *buf, size_t len)
	523	{
	524	if (wpa_s->driver->send_tdls_mgmt) {
	525	return wpa_s->driver->send_tdls_mgmt(wpa_s->drv_priv, dst,
	526	action_code, dialog_token,
	527	status_code, buf, len);
	528	}
	529	return -1;
	530	}
	531
	532	static inline int wpa_drv_tdls_oper(struct wpa_supplicant *wpa_s,
	533	enum tdls_oper oper, const u8 *peer)
	534	{
	535	if (!wpa_s->driver->tdls_oper)
	536	return -1;
	537	return wpa_s->driver->tdls_oper(wpa_s->drv_priv, oper, peer);
	538	}
3ac17eba	539
5e2c3490 JM	540	#ifdef ANDROID
	541	static inline int wpa_drv_driver_cmd(struct wpa_supplicant *wpa_s,
	542	char cmd, char buf, size_t buf_len)
	543	{
	544	if (!wpa_s->driver->driver_cmd)
	545	return -1;
	546	return wpa_s->driver->driver_cmd(wpa_s->drv_priv, cmd, buf, buf_len);
	547	}
	548	#endif /* ANDROID */
	549
b14a210c JB	550	static inline void wpa_drv_set_rekey_info(struct wpa_supplicant *wpa_s,
	551	const u8 kek, const u8 kck,
	552	const u8 *replay_ctr)
	553	{
	554	if (!wpa_s->driver->set_rekey_info)
	555	return;
	556	wpa_s->driver->set_rekey_info(wpa_s->drv_priv, kek, kck, replay_ctr);
	557	}
	558
8b9d0bfa JM	559	static inline int wpa_drv_radio_disable(struct wpa_supplicant *wpa_s,
	560	int disabled)
	561	{
	562	if (!wpa_s->driver->radio_disable)
	563	return -1;
	564	return wpa_s->driver->radio_disable(wpa_s->drv_priv, disabled);
	565	}
	566
ef35f5a0	567	static inline int wpa_drv_switch_channel(struct wpa_supplicant *wpa_s,
dcca2219	568	struct csa_settings *settings)
ef35f5a0 JJ	569	{
	570	if (!wpa_s->driver->switch_channel)
	571	return -1;
dcca2219	572	return wpa_s->driver->switch_channel(wpa_s->drv_priv, settings);
ef35f5a0 JJ	573	}
ef35f5a0 JJ	574
a884be9d XC	575	static inline int wpa_drv_wnm_oper(struct wpa_supplicant *wpa_s,
	576	enum wnm_oper oper, const u8 *peer,
	577	u8 buf, u16 buf_len)
	578	{
	579	if (!wpa_s->driver->wnm_oper)
	580	return -1;
	581	return wpa_s->driver->wnm_oper(wpa_s->drv_priv, oper, peer, buf,
	582	buf_len);
	583	}
	584
a771c07d JM	585	static inline int wpa_drv_status(struct wpa_supplicant *wpa_s,
	586	char *buf, size_t buflen)
	587	{
	588	if (!wpa_s->driver->status)
	589	return -1;
	590	return wpa_s->driver->status(wpa_s->drv_priv, buf, buflen);
	591	}
	592
56f5af48 JM	593	static inline int wpa_drv_set_qos_map(struct wpa_supplicant *wpa_s,
	594	const u8 *qos_map_set, u8 qos_map_set_len)
	595	{
	596	if (!wpa_s->driver->set_qos_map)
	597	return -1;
	598	return wpa_s->driver->set_qos_map(wpa_s->drv_priv, qos_map_set,
	599	qos_map_set_len);
	600	}
	601
2d5b792d	602	#endif /* DRIVER_I_H */