[net-next-2.6.git] / net / mac80211 / driver-ops.h

#ifndef __MAC80211_DRIVER_OPS
#define __MAC80211_DRIVER_OPS

#include <net/mac80211.h>
#include "ieee80211_i.h"
#include "driver-trace.h"

static inline int drv_tx(struct ieee80211_local *local, struct sk_buff *skb)
{
	return local->ops->tx(&local->hw, skb);
}

static inline int drv_start(struct ieee80211_local *local)
{
	int ret;

	might_sleep();

	local->started = true;
	smp_mb();
	ret = local->ops->start(&local->hw);
	trace_drv_start(local, ret);
	return ret;
}

static inline void drv_stop(struct ieee80211_local *local)
{
	might_sleep();

	local->ops->stop(&local->hw);
	trace_drv_stop(local);

	/* sync away all work on the tasklet before clearing started */
	tasklet_disable(&local->tasklet);
	tasklet_enable(&local->tasklet);

	barrier();

	local->started = false;
}

static inline int drv_add_interface(struct ieee80211_local *local,
				    struct ieee80211_vif *vif)
{
	int ret;

	might_sleep();

	ret = local->ops->add_interface(&local->hw, vif);
	trace_drv_add_interface(local, vif_to_sdata(vif), ret);
	return ret;
}

static inline void drv_remove_interface(struct ieee80211_local *local,
					struct ieee80211_vif *vif)
{
	might_sleep();

	local->ops->remove_interface(&local->hw, vif);
	trace_drv_remove_interface(local, vif_to_sdata(vif));
}

static inline int drv_config(struct ieee80211_local *local, u32 changed)
{
	int ret;

	might_sleep();

	ret = local->ops->config(&local->hw, changed);
	trace_drv_config(local, changed, ret);
	return ret;
}

static inline void drv_bss_info_changed(struct ieee80211_local *local,
					struct ieee80211_sub_if_data *sdata,
					struct ieee80211_bss_conf *info,
					u32 changed)
{
	might_sleep();

	if (local->ops->bss_info_changed)
		local->ops->bss_info_changed(&local->hw, &sdata->vif, info, changed);
	trace_drv_bss_info_changed(local, sdata, info, changed);
}

static inline u64 drv_prepare_multicast(struct ieee80211_local *local,
					struct netdev_hw_addr_list *mc_list)
{
	u64 ret = 0;

	if (local->ops->prepare_multicast)
		ret = local->ops->prepare_multicast(&local->hw, mc_list);

	trace_drv_prepare_multicast(local, mc_list->count, ret);

	return ret;
}

static inline void drv_configure_filter(struct ieee80211_local *local,
					unsigned int changed_flags,
					unsigned int *total_flags,
					u64 multicast)
{
	might_sleep();

	local->ops->configure_filter(&local->hw, changed_flags, total_flags,
				     multicast);
	trace_drv_configure_filter(local, changed_flags, total_flags,
				   multicast);
}

static inline int drv_set_tim(struct ieee80211_local *local,
			      struct ieee80211_sta *sta, bool set)
{
	int ret = 0;
	if (local->ops->set_tim)
		ret = local->ops->set_tim(&local->hw, sta, set);
	trace_drv_set_tim(local, sta, set, ret);
	return ret;
}

static inline int drv_set_key(struct ieee80211_local *local,
			      enum set_key_cmd cmd,
			      struct ieee80211_sub_if_data *sdata,
			      struct ieee80211_sta *sta,
			      struct ieee80211_key_conf *key)
{
	int ret;

	might_sleep();

	ret = local->ops->set_key(&local->hw, cmd, &sdata->vif, sta, key);
	trace_drv_set_key(local, cmd, sdata, sta, key, ret);
	return ret;
}

static inline void drv_update_tkip_key(struct ieee80211_local *local,
				       struct ieee80211_sub_if_data *sdata,
				       struct ieee80211_key_conf *conf,
				       struct sta_info *sta, u32 iv32,
				       u16 *phase1key)
{
	struct ieee80211_sta *ista = NULL;

	if (sta)
		ista = &sta->sta;

	if (local->ops->update_tkip_key)
		local->ops->update_tkip_key(&local->hw, &sdata->vif, conf,
					    ista, iv32, phase1key);
	trace_drv_update_tkip_key(local, sdata, conf, ista, iv32);
}

static inline int drv_hw_scan(struct ieee80211_local *local,
			      struct ieee80211_sub_if_data *sdata,
			      struct cfg80211_scan_request *req)
{
	int ret;

	might_sleep();

	ret = local->ops->hw_scan(&local->hw, &sdata->vif, req);
	trace_drv_hw_scan(local, sdata, req, ret);
	return ret;
}

static inline void drv_sw_scan_start(struct ieee80211_local *local)
{
	might_sleep();

	if (local->ops->sw_scan_start)
		local->ops->sw_scan_start(&local->hw);
	trace_drv_sw_scan_start(local);
}

static inline void drv_sw_scan_complete(struct ieee80211_local *local)
{
	might_sleep();

	if (local->ops->sw_scan_complete)
		local->ops->sw_scan_complete(&local->hw);
	trace_drv_sw_scan_complete(local);
}

static inline int drv_get_stats(struct ieee80211_local *local,
				struct ieee80211_low_level_stats *stats)
{
	int ret = -EOPNOTSUPP;

	might_sleep();

	if (local->ops->get_stats)
		ret = local->ops->get_stats(&local->hw, stats);
	trace_drv_get_stats(local, stats, ret);

	return ret;
}

static inline void drv_get_tkip_seq(struct ieee80211_local *local,
				    u8 hw_key_idx, u32 *iv32, u16 *iv16)
{
	if (local->ops->get_tkip_seq)
		local->ops->get_tkip_seq(&local->hw, hw_key_idx, iv32, iv16);
	trace_drv_get_tkip_seq(local, hw_key_idx, iv32, iv16);
}

static inline int drv_set_rts_threshold(struct ieee80211_local *local,
					u32 value)
{
	int ret = 0;

	might_sleep();

	if (local->ops->set_rts_threshold)
		ret = local->ops->set_rts_threshold(&local->hw, value);
	trace_drv_set_rts_threshold(local, value, ret);
	return ret;
}

static inline int drv_set_coverage_class(struct ieee80211_local *local,
					 u8 value)
{
	int ret = 0;
	might_sleep();

	if (local->ops->set_coverage_class)
		local->ops->set_coverage_class(&local->hw, value);
	else
		ret = -EOPNOTSUPP;

	trace_drv_set_coverage_class(local, value, ret);
	return ret;
}

static inline void drv_sta_notify(struct ieee80211_local *local,
				  struct ieee80211_sub_if_data *sdata,
				  enum sta_notify_cmd cmd,
				  struct ieee80211_sta *sta)
{
	if (local->ops->sta_notify)
		local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta);
	trace_drv_sta_notify(local, sdata, cmd, sta);
}

static inline int drv_sta_add(struct ieee80211_local *local,
			      struct ieee80211_sub_if_data *sdata,
			      struct ieee80211_sta *sta)
{
	int ret = 0;

	might_sleep();

	if (local->ops->sta_add)
		ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
	else if (local->ops->sta_notify)
		local->ops->sta_notify(&local->hw, &sdata->vif,
					STA_NOTIFY_ADD, sta);

	trace_drv_sta_add(local, sdata, sta, ret);

	return ret;
}

static inline void drv_sta_remove(struct ieee80211_local *local,
				  struct ieee80211_sub_if_data *sdata,
				  struct ieee80211_sta *sta)
{
	might_sleep();

	if (local->ops->sta_remove)
		local->ops->sta_remove(&local->hw, &sdata->vif, sta);
	else if (local->ops->sta_notify)
		local->ops->sta_notify(&local->hw, &sdata->vif,
					STA_NOTIFY_REMOVE, sta);

	trace_drv_sta_remove(local, sdata, sta);
}

static inline int drv_conf_tx(struct ieee80211_local *local, u16 queue,
			      const struct ieee80211_tx_queue_params *params)
{
	int ret = -EOPNOTSUPP;

	might_sleep();

	if (local->ops->conf_tx)
		ret = local->ops->conf_tx(&local->hw, queue, params);
	trace_drv_conf_tx(local, queue, params, ret);
	return ret;
}

static inline u64 drv_get_tsf(struct ieee80211_local *local)
{
	u64 ret = -1ULL;

	might_sleep();

	if (local->ops->get_tsf)
		ret = local->ops->get_tsf(&local->hw);
	trace_drv_get_tsf(local, ret);
	return ret;
}

static inline void drv_set_tsf(struct ieee80211_local *local, u64 tsf)
{
	might_sleep();

	if (local->ops->set_tsf)
		local->ops->set_tsf(&local->hw, tsf);
	trace_drv_set_tsf(local, tsf);
}

static inline void drv_reset_tsf(struct ieee80211_local *local)
{
	might_sleep();

	if (local->ops->reset_tsf)
		local->ops->reset_tsf(&local->hw);
	trace_drv_reset_tsf(local);
}

static inline int drv_tx_last_beacon(struct ieee80211_local *local)
{
	int ret = 1;

	might_sleep();

	if (local->ops->tx_last_beacon)
		ret = local->ops->tx_last_beacon(&local->hw);
	trace_drv_tx_last_beacon(local, ret);
	return ret;
}

static inline int drv_ampdu_action(struct ieee80211_local *local,
				   struct ieee80211_sub_if_data *sdata,
				   enum ieee80211_ampdu_mlme_action action,
				   struct ieee80211_sta *sta, u16 tid,
				   u16 *ssn)
{
	int ret = -EOPNOTSUPP;
	if (local->ops->ampdu_action)
		ret = local->ops->ampdu_action(&local->hw, &sdata->vif, action,
					       sta, tid, ssn);
	trace_drv_ampdu_action(local, sdata, action, sta, tid, ssn, ret);
	return ret;
}

static inline int drv_get_survey(struct ieee80211_local *local, int idx,
				struct survey_info *survey)
{
	int ret = -EOPNOTSUPP;
	if (local->ops->get_survey)
		ret = local->ops->get_survey(&local->hw, idx, survey);
	/* trace_drv_get_survey(local, idx, survey, ret); */
	return ret;
}

static inline void drv_rfkill_poll(struct ieee80211_local *local)
{
	might_sleep();

	if (local->ops->rfkill_poll)
		local->ops->rfkill_poll(&local->hw);
}

static inline void drv_flush(struct ieee80211_local *local, bool drop)
{
	might_sleep();

	trace_drv_flush(local, drop);
	if (local->ops->flush)
		local->ops->flush(&local->hw, drop);
}

static inline void drv_channel_switch(struct ieee80211_local *local,
				     struct ieee80211_channel_switch *ch_switch)
{
	might_sleep();

	local->ops->channel_switch(&local->hw, ch_switch);

	trace_drv_channel_switch(local, ch_switch);
}

#endif /* __MAC80211_DRIVER_OPS */
Commit	Line	Data
24487981 JB	1	#ifndef __MAC80211_DRIVER_OPS
	2	#define __MAC80211_DRIVER_OPS
	3
	4	#include <net/mac80211.h>
	5	#include "ieee80211_i.h"
0a2b8bb2	6	#include "driver-trace.h"
24487981 JB	7
	8	static inline int drv_tx(struct ieee80211_local local, struct sk_buff skb)
	9	{
	10	return local->ops->tx(&local->hw, skb);
	11	}
	12
	13	static inline int drv_start(struct ieee80211_local *local)
	14	{
ea77f12f JB	15	int ret;
ea77f12f JB	16
e1781ed3 KV	17	might_sleep();
e1781ed3 KV	18
ea77f12f JB	19	local->started = true;
	20	smp_mb();
	21	ret = local->ops->start(&local->hw);
0a2b8bb2 JB	22	trace_drv_start(local, ret);
0a2b8bb2 JB	23	return ret;
24487981 JB	24	}
	25
	26	static inline void drv_stop(struct ieee80211_local *local)
	27	{
e1781ed3 KV	28	might_sleep();
e1781ed3 KV	29
24487981	30	local->ops->stop(&local->hw);
0a2b8bb2	31	trace_drv_stop(local);
ea77f12f JB	32
	33	/* sync away all work on the tasklet before clearing started */
	34	tasklet_disable(&local->tasklet);
	35	tasklet_enable(&local->tasklet);
	36
	37	barrier();
	38
	39	local->started = false;
24487981 JB	40	}
	41
	42	static inline int drv_add_interface(struct ieee80211_local *local,
1ed32e4f	43	struct ieee80211_vif *vif)
24487981	44	{
e1781ed3 KV	45	int ret;
	46
	47	might_sleep();
	48
	49	ret = local->ops->add_interface(&local->hw, vif);
1ed32e4f	50	trace_drv_add_interface(local, vif_to_sdata(vif), ret);
0a2b8bb2	51	return ret;
24487981 JB	52	}
	53
	54	static inline void drv_remove_interface(struct ieee80211_local *local,
1ed32e4f	55	struct ieee80211_vif *vif)
24487981	56	{
e1781ed3 KV	57	might_sleep();
e1781ed3 KV	58
1ed32e4f JB	59	local->ops->remove_interface(&local->hw, vif);
1ed32e4f JB	60	trace_drv_remove_interface(local, vif_to_sdata(vif));
24487981 JB	61	}
	62
	63	static inline int drv_config(struct ieee80211_local *local, u32 changed)
	64	{
e1781ed3 KV	65	int ret;
	66
	67	might_sleep();
	68
	69	ret = local->ops->config(&local->hw, changed);
0a2b8bb2 JB	70	trace_drv_config(local, changed, ret);
0a2b8bb2 JB	71	return ret;
24487981 JB	72	}
	73
	74	static inline void drv_bss_info_changed(struct ieee80211_local *local,
12375ef9	75	struct ieee80211_sub_if_data *sdata,
24487981 JB	76	struct ieee80211_bss_conf *info,
	77	u32 changed)
	78	{
e1781ed3 KV	79	might_sleep();
e1781ed3 KV	80
24487981	81	if (local->ops->bss_info_changed)
12375ef9 JB	82	local->ops->bss_info_changed(&local->hw, &sdata->vif, info, changed);
12375ef9 JB	83	trace_drv_bss_info_changed(local, sdata, info, changed);
24487981 JB	84	}
24487981 JB	85
3ac64bee	86	static inline u64 drv_prepare_multicast(struct ieee80211_local *local,
22bedad3	87	struct netdev_hw_addr_list *mc_list)
3ac64bee JB	88	{
	89	u64 ret = 0;
	90
	91	if (local->ops->prepare_multicast)
22bedad3	92	ret = local->ops->prepare_multicast(&local->hw, mc_list);
3ac64bee	93
22bedad3	94	trace_drv_prepare_multicast(local, mc_list->count, ret);
3ac64bee JB	95
	96	return ret;
	97	}
	98
24487981 JB	99	static inline void drv_configure_filter(struct ieee80211_local *local,
	100	unsigned int changed_flags,
	101	unsigned int *total_flags,
3ac64bee	102	u64 multicast)
24487981	103	{
3ac64bee JB	104	might_sleep();
3ac64bee JB	105
24487981	106	local->ops->configure_filter(&local->hw, changed_flags, total_flags,
3ac64bee	107	multicast);
0a2b8bb2	108	trace_drv_configure_filter(local, changed_flags, total_flags,
3ac64bee	109	multicast);
24487981 JB	110	}
	111
	112	static inline int drv_set_tim(struct ieee80211_local *local,
	113	struct ieee80211_sta *sta, bool set)
	114	{
0a2b8bb2	115	int ret = 0;
24487981	116	if (local->ops->set_tim)
0a2b8bb2 JB	117	ret = local->ops->set_tim(&local->hw, sta, set);
	118	trace_drv_set_tim(local, sta, set, ret);
	119	return ret;
24487981 JB	120	}
	121
	122	static inline int drv_set_key(struct ieee80211_local *local,
12375ef9 JB	123	enum set_key_cmd cmd,
12375ef9 JB	124	struct ieee80211_sub_if_data *sdata,
24487981 JB	125	struct ieee80211_sta *sta,
	126	struct ieee80211_key_conf *key)
	127	{
e1781ed3 KV	128	int ret;
	129
	130	might_sleep();
	131
	132	ret = local->ops->set_key(&local->hw, cmd, &sdata->vif, sta, key);
12375ef9	133	trace_drv_set_key(local, cmd, sdata, sta, key, ret);
0a2b8bb2	134	return ret;
24487981 JB	135	}
	136
	137	static inline void drv_update_tkip_key(struct ieee80211_local *local,
b3fbdcf4	138	struct ieee80211_sub_if_data *sdata,
24487981	139	struct ieee80211_key_conf *conf,
b3fbdcf4	140	struct sta_info *sta, u32 iv32,
24487981 JB	141	u16 *phase1key)
24487981 JB	142	{
b3fbdcf4 JB	143	struct ieee80211_sta *ista = NULL;
b3fbdcf4 JB	144
b3fbdcf4 JB	145	if (sta)
	146	ista = &sta->sta;
	147
24487981	148	if (local->ops->update_tkip_key)
b3fbdcf4 JB	149	local->ops->update_tkip_key(&local->hw, &sdata->vif, conf,
	150	ista, iv32, phase1key);
	151	trace_drv_update_tkip_key(local, sdata, conf, ista, iv32);
24487981 JB	152	}
	153
	154	static inline int drv_hw_scan(struct ieee80211_local *local,
a060bbfe	155	struct ieee80211_sub_if_data *sdata,
24487981 JB	156	struct cfg80211_scan_request *req)
24487981 JB	157	{
e1781ed3 KV	158	int ret;
	159
	160	might_sleep();
	161
a060bbfe JB	162	ret = local->ops->hw_scan(&local->hw, &sdata->vif, req);
a060bbfe JB	163	trace_drv_hw_scan(local, sdata, req, ret);
0a2b8bb2	164	return ret;
24487981 JB	165	}
	166
	167	static inline void drv_sw_scan_start(struct ieee80211_local *local)
	168	{
e1781ed3 KV	169	might_sleep();
e1781ed3 KV	170
24487981 JB	171	if (local->ops->sw_scan_start)
24487981 JB	172	local->ops->sw_scan_start(&local->hw);
0a2b8bb2	173	trace_drv_sw_scan_start(local);
24487981 JB	174	}
	175
	176	static inline void drv_sw_scan_complete(struct ieee80211_local *local)
	177	{
e1781ed3 KV	178	might_sleep();
e1781ed3 KV	179
24487981 JB	180	if (local->ops->sw_scan_complete)
24487981 JB	181	local->ops->sw_scan_complete(&local->hw);
0a2b8bb2	182	trace_drv_sw_scan_complete(local);
24487981 JB	183	}
	184
	185	static inline int drv_get_stats(struct ieee80211_local *local,
	186	struct ieee80211_low_level_stats *stats)
	187	{
0a2b8bb2 JB	188	int ret = -EOPNOTSUPP;
0a2b8bb2 JB	189
e1781ed3 KV	190	might_sleep();
e1781ed3 KV	191
0a2b8bb2 JB	192	if (local->ops->get_stats)
	193	ret = local->ops->get_stats(&local->hw, stats);
	194	trace_drv_get_stats(local, stats, ret);
	195
	196	return ret;
24487981 JB	197	}
	198
	199	static inline void drv_get_tkip_seq(struct ieee80211_local *local,
	200	u8 hw_key_idx, u32 iv32, u16 iv16)
	201	{
	202	if (local->ops->get_tkip_seq)
	203	local->ops->get_tkip_seq(&local->hw, hw_key_idx, iv32, iv16);
0a2b8bb2	204	trace_drv_get_tkip_seq(local, hw_key_idx, iv32, iv16);
24487981 JB	205	}
	206
	207	static inline int drv_set_rts_threshold(struct ieee80211_local *local,
	208	u32 value)
	209	{
0a2b8bb2	210	int ret = 0;
e1781ed3 KV	211
	212	might_sleep();
	213
24487981	214	if (local->ops->set_rts_threshold)
0a2b8bb2 JB	215	ret = local->ops->set_rts_threshold(&local->hw, value);
	216	trace_drv_set_rts_threshold(local, value, ret);
	217	return ret;
24487981 JB	218	}
24487981 JB	219
310bc676 LT	220	static inline int drv_set_coverage_class(struct ieee80211_local *local,
	221	u8 value)
	222	{
	223	int ret = 0;
	224	might_sleep();
	225
	226	if (local->ops->set_coverage_class)
	227	local->ops->set_coverage_class(&local->hw, value);
	228	else
	229	ret = -EOPNOTSUPP;
	230
	231	trace_drv_set_coverage_class(local, value, ret);
	232	return ret;
	233	}
	234
24487981	235	static inline void drv_sta_notify(struct ieee80211_local *local,
12375ef9	236	struct ieee80211_sub_if_data *sdata,
24487981 JB	237	enum sta_notify_cmd cmd,
	238	struct ieee80211_sta *sta)
	239	{
	240	if (local->ops->sta_notify)
12375ef9 JB	241	local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta);
12375ef9 JB	242	trace_drv_sta_notify(local, sdata, cmd, sta);
24487981 JB	243	}
24487981 JB	244
34e89507 JB	245	static inline int drv_sta_add(struct ieee80211_local *local,
	246	struct ieee80211_sub_if_data *sdata,
	247	struct ieee80211_sta *sta)
	248	{
	249	int ret = 0;
	250
	251	might_sleep();
	252
	253	if (local->ops->sta_add)
	254	ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
	255	else if (local->ops->sta_notify)
	256	local->ops->sta_notify(&local->hw, &sdata->vif,
	257	STA_NOTIFY_ADD, sta);
	258
	259	trace_drv_sta_add(local, sdata, sta, ret);
	260
	261	return ret;
	262	}
	263
	264	static inline void drv_sta_remove(struct ieee80211_local *local,
	265	struct ieee80211_sub_if_data *sdata,
	266	struct ieee80211_sta *sta)
	267	{
	268	might_sleep();
	269
	270	if (local->ops->sta_remove)
	271	local->ops->sta_remove(&local->hw, &sdata->vif, sta);
	272	else if (local->ops->sta_notify)
	273	local->ops->sta_notify(&local->hw, &sdata->vif,
	274	STA_NOTIFY_REMOVE, sta);
	275
	276	trace_drv_sta_remove(local, sdata, sta);
	277	}
	278
24487981 JB	279	static inline int drv_conf_tx(struct ieee80211_local *local, u16 queue,
	280	const struct ieee80211_tx_queue_params *params)
	281	{
0a2b8bb2	282	int ret = -EOPNOTSUPP;
e1781ed3 KV	283
	284	might_sleep();
	285
24487981	286	if (local->ops->conf_tx)
0a2b8bb2 JB	287	ret = local->ops->conf_tx(&local->hw, queue, params);
	288	trace_drv_conf_tx(local, queue, params, ret);
	289	return ret;
24487981 JB	290	}
24487981 JB	291
24487981 JB	292	static inline u64 drv_get_tsf(struct ieee80211_local *local)
24487981 JB	293	{
0a2b8bb2	294	u64 ret = -1ULL;
e1781ed3 KV	295
	296	might_sleep();
	297
24487981	298	if (local->ops->get_tsf)
0a2b8bb2 JB	299	ret = local->ops->get_tsf(&local->hw);
	300	trace_drv_get_tsf(local, ret);
	301	return ret;
24487981 JB	302	}
	303
	304	static inline void drv_set_tsf(struct ieee80211_local *local, u64 tsf)
	305	{
e1781ed3 KV	306	might_sleep();
e1781ed3 KV	307
24487981 JB	308	if (local->ops->set_tsf)
24487981 JB	309	local->ops->set_tsf(&local->hw, tsf);
0a2b8bb2	310	trace_drv_set_tsf(local, tsf);
24487981 JB	311	}
	312
	313	static inline void drv_reset_tsf(struct ieee80211_local *local)
	314	{
e1781ed3 KV	315	might_sleep();
e1781ed3 KV	316
24487981 JB	317	if (local->ops->reset_tsf)
24487981 JB	318	local->ops->reset_tsf(&local->hw);
0a2b8bb2	319	trace_drv_reset_tsf(local);
24487981 JB	320	}
	321
	322	static inline int drv_tx_last_beacon(struct ieee80211_local *local)
	323	{
0a2b8bb2	324	int ret = 1;
e1781ed3 KV	325
	326	might_sleep();
	327
24487981	328	if (local->ops->tx_last_beacon)
0a2b8bb2 JB	329	ret = local->ops->tx_last_beacon(&local->hw);
	330	trace_drv_tx_last_beacon(local, ret);
	331	return ret;
24487981 JB	332	}
	333
	334	static inline int drv_ampdu_action(struct ieee80211_local *local,
12375ef9	335	struct ieee80211_sub_if_data *sdata,
24487981 JB	336	enum ieee80211_ampdu_mlme_action action,
	337	struct ieee80211_sta *sta, u16 tid,
	338	u16 *ssn)
	339	{
0a2b8bb2	340	int ret = -EOPNOTSUPP;
24487981	341	if (local->ops->ampdu_action)
12375ef9	342	ret = local->ops->ampdu_action(&local->hw, &sdata->vif, action,
0a2b8bb2	343	sta, tid, ssn);
12375ef9	344	trace_drv_ampdu_action(local, sdata, action, sta, tid, ssn, ret);
0a2b8bb2	345	return ret;
24487981	346	}
1f87f7d3	347
1289723e HS	348	static inline int drv_get_survey(struct ieee80211_local *local, int idx,
	349	struct survey_info *survey)
	350	{
	351	int ret = -EOPNOTSUPP;
35dd0509	352	if (local->ops->get_survey)
1289723e HS	353	ret = local->ops->get_survey(&local->hw, idx, survey);
	354	/* trace_drv_get_survey(local, idx, survey, ret); */
	355	return ret;
	356	}
1f87f7d3 JB	357
	358	static inline void drv_rfkill_poll(struct ieee80211_local *local)
	359	{
e1781ed3 KV	360	might_sleep();
e1781ed3 KV	361
1f87f7d3 JB	362	if (local->ops->rfkill_poll)
	363	local->ops->rfkill_poll(&local->hw);
	364	}
a80f7c0b JB	365
	366	static inline void drv_flush(struct ieee80211_local *local, bool drop)
	367	{
e1781ed3 KV	368	might_sleep();
e1781ed3 KV	369
a80f7c0b JB	370	trace_drv_flush(local, drop);
	371	if (local->ops->flush)
	372	local->ops->flush(&local->hw, drop);
	373	}
5ce6e438 JB	374
	375	static inline void drv_channel_switch(struct ieee80211_local *local,
	376	struct ieee80211_channel_switch *ch_switch)
	377	{
	378	might_sleep();
	379
	380	local->ops->channel_switch(&local->hw, ch_switch);
	381
	382	trace_drv_channel_switch(local, ch_switch);
	383	}
	384
24487981	385	#endif /* __MAC80211_DRIVER_OPS */