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