blob: bd782dcffcc7b81478277bcb2b5545dfef545da8 [file] [log] [blame]
Johannes Berg24487982009-04-23 18:52:52 +02001#ifndef __MAC80211_DRIVER_OPS
2#define __MAC80211_DRIVER_OPS
3
4#include <net/mac80211.h>
5#include "ieee80211_i.h"
Johannes Berg011ad0e2012-06-22 12:55:52 +02006#include "trace.h"
Johannes Berg24487982009-04-23 18:52:52 +02007
Johannes Bergf6837ba2014-04-30 14:19:04 +02008static inline bool check_sdata_in_driver(struct ieee80211_sub_if_data *sdata)
Johannes Berg7b7eab62011-11-03 14:41:13 +01009{
Johannes Bergf6837ba2014-04-30 14:19:04 +020010 return !WARN(!(sdata->flags & IEEE80211_SDATA_IN_DRIVER),
11 "%s: Failed check-sdata-in-driver check, flags: 0x%x\n",
12 sdata->dev ? sdata->dev->name : sdata->name, sdata->flags);
Johannes Berg7b7eab62011-11-03 14:41:13 +010013}
14
Felix Fietkaubc192f82011-11-23 21:09:49 +070015static inline struct ieee80211_sub_if_data *
16get_bss_sdata(struct ieee80211_sub_if_data *sdata)
17{
18 if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN)
19 sdata = container_of(sdata->bss, struct ieee80211_sub_if_data,
20 u.ap);
21
22 return sdata;
23}
24
Thomas Huehn36323f82012-07-23 21:33:42 +020025static inline void drv_tx(struct ieee80211_local *local,
26 struct ieee80211_tx_control *control,
27 struct sk_buff *skb)
Johannes Berg24487982009-04-23 18:52:52 +020028{
Thomas Huehn36323f82012-07-23 21:33:42 +020029 local->ops->tx(&local->hw, control, skb);
Johannes Berg24487982009-04-23 18:52:52 +020030}
31
Ben Greeare3521142012-04-23 12:50:31 -070032static inline void drv_get_et_strings(struct ieee80211_sub_if_data *sdata,
33 u32 sset, u8 *data)
34{
35 struct ieee80211_local *local = sdata->local;
36 if (local->ops->get_et_strings) {
37 trace_drv_get_et_strings(local, sset);
38 local->ops->get_et_strings(&local->hw, &sdata->vif, sset, data);
39 trace_drv_return_void(local);
40 }
41}
42
43static inline void drv_get_et_stats(struct ieee80211_sub_if_data *sdata,
44 struct ethtool_stats *stats,
45 u64 *data)
46{
47 struct ieee80211_local *local = sdata->local;
48 if (local->ops->get_et_stats) {
49 trace_drv_get_et_stats(local);
50 local->ops->get_et_stats(&local->hw, &sdata->vif, stats, data);
51 trace_drv_return_void(local);
52 }
53}
54
55static inline int drv_get_et_sset_count(struct ieee80211_sub_if_data *sdata,
56 int sset)
57{
58 struct ieee80211_local *local = sdata->local;
59 int rv = 0;
60 if (local->ops->get_et_sset_count) {
61 trace_drv_get_et_sset_count(local, sset);
62 rv = local->ops->get_et_sset_count(&local->hw, &sdata->vif,
63 sset);
64 trace_drv_return_int(local, rv);
65 }
66 return rv;
67}
68
Johannes Berg24487982009-04-23 18:52:52 +020069static inline int drv_start(struct ieee80211_local *local)
70{
Johannes Bergea77f122009-08-21 14:44:45 +020071 int ret;
72
Kalle Valoe1781ed2009-12-23 13:15:47 +010073 might_sleep();
74
Johannes Berg4efc76b2010-06-10 10:56:20 +020075 trace_drv_start(local);
Johannes Bergea77f122009-08-21 14:44:45 +020076 local->started = true;
77 smp_mb();
78 ret = local->ops->start(&local->hw);
Johannes Berg4efc76b2010-06-10 10:56:20 +020079 trace_drv_return_int(local, ret);
Johannes Berg0a2b8bb2009-07-07 13:46:22 +020080 return ret;
Johannes Berg24487982009-04-23 18:52:52 +020081}
82
83static inline void drv_stop(struct ieee80211_local *local)
84{
Kalle Valoe1781ed2009-12-23 13:15:47 +010085 might_sleep();
86
Johannes Berg0a2b8bb2009-07-07 13:46:22 +020087 trace_drv_stop(local);
Johannes Berg4efc76b2010-06-10 10:56:20 +020088 local->ops->stop(&local->hw);
89 trace_drv_return_void(local);
Johannes Bergea77f122009-08-21 14:44:45 +020090
91 /* sync away all work on the tasklet before clearing started */
92 tasklet_disable(&local->tasklet);
93 tasklet_enable(&local->tasklet);
94
95 barrier();
96
97 local->started = false;
Johannes Berg24487982009-04-23 18:52:52 +020098}
99
Johannes Bergeecc4802011-05-04 15:37:29 +0200100#ifdef CONFIG_PM
101static inline int drv_suspend(struct ieee80211_local *local,
102 struct cfg80211_wowlan *wowlan)
103{
104 int ret;
105
106 might_sleep();
107
108 trace_drv_suspend(local);
109 ret = local->ops->suspend(&local->hw, wowlan);
110 trace_drv_return_int(local, ret);
111 return ret;
112}
113
114static inline int drv_resume(struct ieee80211_local *local)
115{
116 int ret;
117
118 might_sleep();
119
120 trace_drv_resume(local);
121 ret = local->ops->resume(&local->hw);
122 trace_drv_return_int(local, ret);
123 return ret;
124}
Johannes Berg6d525632012-04-04 15:05:25 +0200125
126static inline void drv_set_wakeup(struct ieee80211_local *local,
127 bool enabled)
128{
129 might_sleep();
130
131 if (!local->ops->set_wakeup)
132 return;
133
134 trace_drv_set_wakeup(local, enabled);
135 local->ops->set_wakeup(&local->hw, enabled);
136 trace_drv_return_void(local);
137}
Johannes Bergeecc4802011-05-04 15:37:29 +0200138#endif
139
Johannes Berg24487982009-04-23 18:52:52 +0200140static inline int drv_add_interface(struct ieee80211_local *local,
Johannes Berg7b7eab62011-11-03 14:41:13 +0100141 struct ieee80211_sub_if_data *sdata)
Johannes Berg24487982009-04-23 18:52:52 +0200142{
Kalle Valoe1781ed2009-12-23 13:15:47 +0100143 int ret;
144
145 might_sleep();
146
Johannes Berg7b7eab62011-11-03 14:41:13 +0100147 if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN ||
Johannes Berg4b6f1dd2012-04-03 14:35:57 +0200148 (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
Felix Fietkau31eba5b2013-05-28 13:01:53 +0200149 !(local->hw.flags & IEEE80211_HW_WANT_MONITOR_VIF) &&
150 !(sdata->u.mntr_flags & MONITOR_FLAG_ACTIVE))))
Johannes Berg7b7eab62011-11-03 14:41:13 +0100151 return -EINVAL;
152
153 trace_drv_add_interface(local, sdata);
154 ret = local->ops->add_interface(&local->hw, &sdata->vif);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200155 trace_drv_return_int(local, ret);
Johannes Berg7b7eab62011-11-03 14:41:13 +0100156
157 if (ret == 0)
158 sdata->flags |= IEEE80211_SDATA_IN_DRIVER;
159
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200160 return ret;
Johannes Berg24487982009-04-23 18:52:52 +0200161}
162
Johannes Berg34d4bc42010-08-27 12:35:58 +0200163static inline int drv_change_interface(struct ieee80211_local *local,
164 struct ieee80211_sub_if_data *sdata,
Johannes Berg2ca27bc2010-09-16 14:58:23 +0200165 enum nl80211_iftype type, bool p2p)
Johannes Berg34d4bc42010-08-27 12:35:58 +0200166{
167 int ret;
168
169 might_sleep();
170
Johannes Bergf6837ba2014-04-30 14:19:04 +0200171 if (!check_sdata_in_driver(sdata))
172 return -EIO;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100173
Johannes Berg2ca27bc2010-09-16 14:58:23 +0200174 trace_drv_change_interface(local, sdata, type, p2p);
175 ret = local->ops->change_interface(&local->hw, &sdata->vif, type, p2p);
Johannes Berg34d4bc42010-08-27 12:35:58 +0200176 trace_drv_return_int(local, ret);
177 return ret;
178}
179
Johannes Berg24487982009-04-23 18:52:52 +0200180static inline void drv_remove_interface(struct ieee80211_local *local,
Johannes Berg7b7eab62011-11-03 14:41:13 +0100181 struct ieee80211_sub_if_data *sdata)
Johannes Berg24487982009-04-23 18:52:52 +0200182{
Kalle Valoe1781ed2009-12-23 13:15:47 +0100183 might_sleep();
184
Johannes Bergf6837ba2014-04-30 14:19:04 +0200185 if (!check_sdata_in_driver(sdata))
186 return;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100187
188 trace_drv_remove_interface(local, sdata);
189 local->ops->remove_interface(&local->hw, &sdata->vif);
190 sdata->flags &= ~IEEE80211_SDATA_IN_DRIVER;
Johannes Berg4efc76b2010-06-10 10:56:20 +0200191 trace_drv_return_void(local);
Johannes Berg24487982009-04-23 18:52:52 +0200192}
193
194static inline int drv_config(struct ieee80211_local *local, u32 changed)
195{
Kalle Valoe1781ed2009-12-23 13:15:47 +0100196 int ret;
197
198 might_sleep();
199
Johannes Berg4efc76b2010-06-10 10:56:20 +0200200 trace_drv_config(local, changed);
Kalle Valoe1781ed2009-12-23 13:15:47 +0100201 ret = local->ops->config(&local->hw, changed);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200202 trace_drv_return_int(local, ret);
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200203 return ret;
Johannes Berg24487982009-04-23 18:52:52 +0200204}
205
206static inline void drv_bss_info_changed(struct ieee80211_local *local,
Johannes Berg12375ef2009-11-25 20:30:31 +0100207 struct ieee80211_sub_if_data *sdata,
Johannes Berg24487982009-04-23 18:52:52 +0200208 struct ieee80211_bss_conf *info,
209 u32 changed)
210{
Kalle Valoe1781ed2009-12-23 13:15:47 +0100211 might_sleep();
212
Johannes Berg5bbe754d2013-02-13 13:50:51 +0100213 if (WARN_ON_ONCE(changed & (BSS_CHANGED_BEACON |
214 BSS_CHANGED_BEACON_ENABLED) &&
215 sdata->vif.type != NL80211_IFTYPE_AP &&
216 sdata->vif.type != NL80211_IFTYPE_ADHOC &&
217 sdata->vif.type != NL80211_IFTYPE_MESH_POINT))
218 return;
219
220 if (WARN_ON_ONCE(sdata->vif.type == NL80211_IFTYPE_P2P_DEVICE ||
221 sdata->vif.type == NL80211_IFTYPE_MONITOR))
222 return;
Johannes Bergb8dc1a32012-12-14 14:22:10 +0100223
Johannes Bergf6837ba2014-04-30 14:19:04 +0200224 if (!check_sdata_in_driver(sdata))
225 return;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100226
Johannes Berg4efc76b2010-06-10 10:56:20 +0200227 trace_drv_bss_info_changed(local, sdata, info, changed);
Johannes Berg24487982009-04-23 18:52:52 +0200228 if (local->ops->bss_info_changed)
Johannes Berg12375ef2009-11-25 20:30:31 +0100229 local->ops->bss_info_changed(&local->hw, &sdata->vif, info, changed);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200230 trace_drv_return_void(local);
Johannes Berg24487982009-04-23 18:52:52 +0200231}
232
Johannes Berg3ac64be2009-08-17 16:16:53 +0200233static inline u64 drv_prepare_multicast(struct ieee80211_local *local,
Jiri Pirko22bedad32010-04-01 21:22:57 +0000234 struct netdev_hw_addr_list *mc_list)
Johannes Berg24487982009-04-23 18:52:52 +0200235{
Johannes Berg3ac64be2009-08-17 16:16:53 +0200236 u64 ret = 0;
237
Johannes Berg4efc76b2010-06-10 10:56:20 +0200238 trace_drv_prepare_multicast(local, mc_list->count);
239
Johannes Berg3ac64be2009-08-17 16:16:53 +0200240 if (local->ops->prepare_multicast)
Jiri Pirko22bedad32010-04-01 21:22:57 +0000241 ret = local->ops->prepare_multicast(&local->hw, mc_list);
Johannes Berg3ac64be2009-08-17 16:16:53 +0200242
Johannes Berg4efc76b2010-06-10 10:56:20 +0200243 trace_drv_return_u64(local, ret);
Johannes Berg3ac64be2009-08-17 16:16:53 +0200244
245 return ret;
246}
247
248static inline void drv_configure_filter(struct ieee80211_local *local,
249 unsigned int changed_flags,
250 unsigned int *total_flags,
251 u64 multicast)
252{
253 might_sleep();
254
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200255 trace_drv_configure_filter(local, changed_flags, total_flags,
Johannes Berg3ac64be2009-08-17 16:16:53 +0200256 multicast);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200257 local->ops->configure_filter(&local->hw, changed_flags, total_flags,
258 multicast);
259 trace_drv_return_void(local);
Johannes Berg24487982009-04-23 18:52:52 +0200260}
261
262static inline int drv_set_tim(struct ieee80211_local *local,
263 struct ieee80211_sta *sta, bool set)
264{
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200265 int ret = 0;
Johannes Berg4efc76b2010-06-10 10:56:20 +0200266 trace_drv_set_tim(local, sta, set);
Johannes Berg24487982009-04-23 18:52:52 +0200267 if (local->ops->set_tim)
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200268 ret = local->ops->set_tim(&local->hw, sta, set);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200269 trace_drv_return_int(local, ret);
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200270 return ret;
Johannes Berg24487982009-04-23 18:52:52 +0200271}
272
273static inline int drv_set_key(struct ieee80211_local *local,
Johannes Berg12375ef2009-11-25 20:30:31 +0100274 enum set_key_cmd cmd,
275 struct ieee80211_sub_if_data *sdata,
Johannes Berg24487982009-04-23 18:52:52 +0200276 struct ieee80211_sta *sta,
277 struct ieee80211_key_conf *key)
278{
Kalle Valoe1781ed2009-12-23 13:15:47 +0100279 int ret;
280
281 might_sleep();
282
Johannes Berg077f4932012-01-20 13:55:18 +0100283 sdata = get_bss_sdata(sdata);
Johannes Bergf6837ba2014-04-30 14:19:04 +0200284 if (!check_sdata_in_driver(sdata))
285 return -EIO;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100286
Johannes Berg4efc76b2010-06-10 10:56:20 +0200287 trace_drv_set_key(local, cmd, sdata, sta, key);
Kalle Valoe1781ed2009-12-23 13:15:47 +0100288 ret = local->ops->set_key(&local->hw, cmd, &sdata->vif, sta, key);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200289 trace_drv_return_int(local, ret);
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200290 return ret;
Johannes Berg24487982009-04-23 18:52:52 +0200291}
292
293static inline void drv_update_tkip_key(struct ieee80211_local *local,
Johannes Bergb3fbdcf2010-01-21 11:40:47 +0100294 struct ieee80211_sub_if_data *sdata,
Johannes Berg24487982009-04-23 18:52:52 +0200295 struct ieee80211_key_conf *conf,
Johannes Bergb3fbdcf2010-01-21 11:40:47 +0100296 struct sta_info *sta, u32 iv32,
Johannes Berg24487982009-04-23 18:52:52 +0200297 u16 *phase1key)
298{
Johannes Bergb3fbdcf2010-01-21 11:40:47 +0100299 struct ieee80211_sta *ista = NULL;
300
Johannes Bergb3fbdcf2010-01-21 11:40:47 +0100301 if (sta)
302 ista = &sta->sta;
303
Johannes Berg077f4932012-01-20 13:55:18 +0100304 sdata = get_bss_sdata(sdata);
Johannes Bergf6837ba2014-04-30 14:19:04 +0200305 if (!check_sdata_in_driver(sdata))
306 return;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100307
Johannes Berg4efc76b2010-06-10 10:56:20 +0200308 trace_drv_update_tkip_key(local, sdata, conf, ista, iv32);
Johannes Berg24487982009-04-23 18:52:52 +0200309 if (local->ops->update_tkip_key)
Johannes Bergb3fbdcf2010-01-21 11:40:47 +0100310 local->ops->update_tkip_key(&local->hw, &sdata->vif, conf,
311 ista, iv32, phase1key);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200312 trace_drv_return_void(local);
Johannes Berg24487982009-04-23 18:52:52 +0200313}
314
315static inline int drv_hw_scan(struct ieee80211_local *local,
Johannes Berga060bbf2010-04-27 11:59:34 +0200316 struct ieee80211_sub_if_data *sdata,
Johannes Berg24487982009-04-23 18:52:52 +0200317 struct cfg80211_scan_request *req)
318{
Kalle Valoe1781ed2009-12-23 13:15:47 +0100319 int ret;
320
321 might_sleep();
322
Johannes Bergf6837ba2014-04-30 14:19:04 +0200323 if (!check_sdata_in_driver(sdata))
324 return -EIO;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100325
Luciano Coelho79f460c2011-05-11 17:09:36 +0300326 trace_drv_hw_scan(local, sdata);
Johannes Berga060bbf2010-04-27 11:59:34 +0200327 ret = local->ops->hw_scan(&local->hw, &sdata->vif, req);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200328 trace_drv_return_int(local, ret);
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200329 return ret;
Johannes Berg24487982009-04-23 18:52:52 +0200330}
331
Eliad Pellerb8564392011-06-13 12:47:30 +0300332static inline void drv_cancel_hw_scan(struct ieee80211_local *local,
333 struct ieee80211_sub_if_data *sdata)
334{
335 might_sleep();
336
Johannes Bergf6837ba2014-04-30 14:19:04 +0200337 if (!check_sdata_in_driver(sdata))
338 return;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100339
Eliad Pellerb8564392011-06-13 12:47:30 +0300340 trace_drv_cancel_hw_scan(local, sdata);
341 local->ops->cancel_hw_scan(&local->hw, &sdata->vif);
342 trace_drv_return_void(local);
343}
344
Luciano Coelho79f460c2011-05-11 17:09:36 +0300345static inline int
346drv_sched_scan_start(struct ieee80211_local *local,
347 struct ieee80211_sub_if_data *sdata,
348 struct cfg80211_sched_scan_request *req,
349 struct ieee80211_sched_scan_ies *ies)
350{
351 int ret;
352
353 might_sleep();
354
Johannes Bergf6837ba2014-04-30 14:19:04 +0200355 if (!check_sdata_in_driver(sdata))
356 return -EIO;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100357
Luciano Coelho79f460c2011-05-11 17:09:36 +0300358 trace_drv_sched_scan_start(local, sdata);
359 ret = local->ops->sched_scan_start(&local->hw, &sdata->vif,
360 req, ies);
361 trace_drv_return_int(local, ret);
362 return ret;
363}
364
Johannes Berg37e33082014-02-17 10:48:17 +0100365static inline int drv_sched_scan_stop(struct ieee80211_local *local,
366 struct ieee80211_sub_if_data *sdata)
Luciano Coelho79f460c2011-05-11 17:09:36 +0300367{
Johannes Berg37e33082014-02-17 10:48:17 +0100368 int ret;
369
Luciano Coelho79f460c2011-05-11 17:09:36 +0300370 might_sleep();
371
Johannes Bergf6837ba2014-04-30 14:19:04 +0200372 if (!check_sdata_in_driver(sdata))
373 return -EIO;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100374
Luciano Coelho79f460c2011-05-11 17:09:36 +0300375 trace_drv_sched_scan_stop(local, sdata);
Johannes Berg37e33082014-02-17 10:48:17 +0100376 ret = local->ops->sched_scan_stop(&local->hw, &sdata->vif);
377 trace_drv_return_int(local, ret);
378
379 return ret;
Luciano Coelho79f460c2011-05-11 17:09:36 +0300380}
381
Johannes Berg24487982009-04-23 18:52:52 +0200382static inline void drv_sw_scan_start(struct ieee80211_local *local)
383{
Kalle Valoe1781ed2009-12-23 13:15:47 +0100384 might_sleep();
385
Johannes Berg4efc76b2010-06-10 10:56:20 +0200386 trace_drv_sw_scan_start(local);
Johannes Berg24487982009-04-23 18:52:52 +0200387 if (local->ops->sw_scan_start)
388 local->ops->sw_scan_start(&local->hw);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200389 trace_drv_return_void(local);
Johannes Berg24487982009-04-23 18:52:52 +0200390}
391
392static inline void drv_sw_scan_complete(struct ieee80211_local *local)
393{
Kalle Valoe1781ed2009-12-23 13:15:47 +0100394 might_sleep();
395
Johannes Berg4efc76b2010-06-10 10:56:20 +0200396 trace_drv_sw_scan_complete(local);
Johannes Berg24487982009-04-23 18:52:52 +0200397 if (local->ops->sw_scan_complete)
398 local->ops->sw_scan_complete(&local->hw);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200399 trace_drv_return_void(local);
Johannes Berg24487982009-04-23 18:52:52 +0200400}
401
402static inline int drv_get_stats(struct ieee80211_local *local,
403 struct ieee80211_low_level_stats *stats)
404{
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200405 int ret = -EOPNOTSUPP;
406
Kalle Valoe1781ed2009-12-23 13:15:47 +0100407 might_sleep();
408
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200409 if (local->ops->get_stats)
410 ret = local->ops->get_stats(&local->hw, stats);
411 trace_drv_get_stats(local, stats, ret);
412
413 return ret;
Johannes Berg24487982009-04-23 18:52:52 +0200414}
415
416static inline void drv_get_tkip_seq(struct ieee80211_local *local,
417 u8 hw_key_idx, u32 *iv32, u16 *iv16)
418{
419 if (local->ops->get_tkip_seq)
420 local->ops->get_tkip_seq(&local->hw, hw_key_idx, iv32, iv16);
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200421 trace_drv_get_tkip_seq(local, hw_key_idx, iv32, iv16);
Johannes Berg24487982009-04-23 18:52:52 +0200422}
423
Arik Nemtsovf23a4782010-11-08 11:51:06 +0200424static inline int drv_set_frag_threshold(struct ieee80211_local *local,
425 u32 value)
426{
427 int ret = 0;
428
429 might_sleep();
430
431 trace_drv_set_frag_threshold(local, value);
432 if (local->ops->set_frag_threshold)
433 ret = local->ops->set_frag_threshold(&local->hw, value);
434 trace_drv_return_int(local, ret);
435 return ret;
436}
437
Johannes Berg24487982009-04-23 18:52:52 +0200438static inline int drv_set_rts_threshold(struct ieee80211_local *local,
439 u32 value)
440{
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200441 int ret = 0;
Kalle Valoe1781ed2009-12-23 13:15:47 +0100442
443 might_sleep();
444
Johannes Berg4efc76b2010-06-10 10:56:20 +0200445 trace_drv_set_rts_threshold(local, value);
Johannes Berg24487982009-04-23 18:52:52 +0200446 if (local->ops->set_rts_threshold)
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200447 ret = local->ops->set_rts_threshold(&local->hw, value);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200448 trace_drv_return_int(local, ret);
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200449 return ret;
Johannes Berg24487982009-04-23 18:52:52 +0200450}
451
Lukáš Turek310bc672009-12-21 22:50:48 +0100452static inline int drv_set_coverage_class(struct ieee80211_local *local,
453 u8 value)
454{
455 int ret = 0;
456 might_sleep();
457
Johannes Berg4efc76b2010-06-10 10:56:20 +0200458 trace_drv_set_coverage_class(local, value);
Lukáš Turek310bc672009-12-21 22:50:48 +0100459 if (local->ops->set_coverage_class)
460 local->ops->set_coverage_class(&local->hw, value);
461 else
462 ret = -EOPNOTSUPP;
463
Johannes Berg4efc76b2010-06-10 10:56:20 +0200464 trace_drv_return_int(local, ret);
Lukáš Turek310bc672009-12-21 22:50:48 +0100465 return ret;
466}
467
Johannes Berg24487982009-04-23 18:52:52 +0200468static inline void drv_sta_notify(struct ieee80211_local *local,
Johannes Berg12375ef2009-11-25 20:30:31 +0100469 struct ieee80211_sub_if_data *sdata,
Johannes Berg24487982009-04-23 18:52:52 +0200470 enum sta_notify_cmd cmd,
471 struct ieee80211_sta *sta)
472{
Felix Fietkaubc192f82011-11-23 21:09:49 +0700473 sdata = get_bss_sdata(sdata);
Johannes Bergf6837ba2014-04-30 14:19:04 +0200474 if (!check_sdata_in_driver(sdata))
475 return;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100476
Johannes Berg4efc76b2010-06-10 10:56:20 +0200477 trace_drv_sta_notify(local, sdata, cmd, sta);
Johannes Berg24487982009-04-23 18:52:52 +0200478 if (local->ops->sta_notify)
Johannes Berg12375ef2009-11-25 20:30:31 +0100479 local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200480 trace_drv_return_void(local);
Johannes Berg24487982009-04-23 18:52:52 +0200481}
482
Johannes Berg34e89502010-02-03 13:59:58 +0100483static inline int drv_sta_add(struct ieee80211_local *local,
484 struct ieee80211_sub_if_data *sdata,
485 struct ieee80211_sta *sta)
486{
487 int ret = 0;
488
489 might_sleep();
490
Felix Fietkaubc192f82011-11-23 21:09:49 +0700491 sdata = get_bss_sdata(sdata);
Johannes Bergf6837ba2014-04-30 14:19:04 +0200492 if (!check_sdata_in_driver(sdata))
493 return -EIO;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100494
Johannes Berg4efc76b2010-06-10 10:56:20 +0200495 trace_drv_sta_add(local, sdata, sta);
Johannes Berg34e89502010-02-03 13:59:58 +0100496 if (local->ops->sta_add)
497 ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
Johannes Berg34e89502010-02-03 13:59:58 +0100498
Johannes Berg4efc76b2010-06-10 10:56:20 +0200499 trace_drv_return_int(local, ret);
Johannes Berg34e89502010-02-03 13:59:58 +0100500
501 return ret;
502}
503
504static inline void drv_sta_remove(struct ieee80211_local *local,
505 struct ieee80211_sub_if_data *sdata,
506 struct ieee80211_sta *sta)
507{
508 might_sleep();
509
Felix Fietkaubc192f82011-11-23 21:09:49 +0700510 sdata = get_bss_sdata(sdata);
Johannes Bergf6837ba2014-04-30 14:19:04 +0200511 if (!check_sdata_in_driver(sdata))
512 return;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100513
Johannes Berg4efc76b2010-06-10 10:56:20 +0200514 trace_drv_sta_remove(local, sdata, sta);
Johannes Berg34e89502010-02-03 13:59:58 +0100515 if (local->ops->sta_remove)
516 local->ops->sta_remove(&local->hw, &sdata->vif, sta);
Johannes Berg34e89502010-02-03 13:59:58 +0100517
Johannes Berg4efc76b2010-06-10 10:56:20 +0200518 trace_drv_return_void(local);
Johannes Berg34e89502010-02-03 13:59:58 +0100519}
520
Sujith Manoharan77d2ece2012-11-20 08:46:02 +0530521#ifdef CONFIG_MAC80211_DEBUGFS
522static inline void drv_sta_add_debugfs(struct ieee80211_local *local,
523 struct ieee80211_sub_if_data *sdata,
524 struct ieee80211_sta *sta,
525 struct dentry *dir)
526{
527 might_sleep();
528
529 sdata = get_bss_sdata(sdata);
Johannes Bergf6837ba2014-04-30 14:19:04 +0200530 if (!check_sdata_in_driver(sdata))
531 return;
Sujith Manoharan77d2ece2012-11-20 08:46:02 +0530532
533 if (local->ops->sta_add_debugfs)
534 local->ops->sta_add_debugfs(&local->hw, &sdata->vif,
535 sta, dir);
536}
537
538static inline void drv_sta_remove_debugfs(struct ieee80211_local *local,
539 struct ieee80211_sub_if_data *sdata,
540 struct ieee80211_sta *sta,
541 struct dentry *dir)
542{
543 might_sleep();
544
545 sdata = get_bss_sdata(sdata);
546 check_sdata_in_driver(sdata);
547
548 if (local->ops->sta_remove_debugfs)
549 local->ops->sta_remove_debugfs(&local->hw, &sdata->vif,
550 sta, dir);
551}
552#endif
553
Johannes Berg6a9d1b92013-12-04 22:39:17 +0100554static inline void drv_sta_pre_rcu_remove(struct ieee80211_local *local,
555 struct ieee80211_sub_if_data *sdata,
556 struct sta_info *sta)
557{
558 might_sleep();
559
560 sdata = get_bss_sdata(sdata);
Johannes Bergf6837ba2014-04-30 14:19:04 +0200561 if (!check_sdata_in_driver(sdata))
562 return;
Johannes Berg6a9d1b92013-12-04 22:39:17 +0100563
564 trace_drv_sta_pre_rcu_remove(local, sdata, &sta->sta);
565 if (local->ops->sta_pre_rcu_remove)
566 local->ops->sta_pre_rcu_remove(&local->hw, &sdata->vif,
567 &sta->sta);
568 trace_drv_return_void(local);
569}
570
Johannes Bergf09603a2012-01-20 13:55:21 +0100571static inline __must_check
572int drv_sta_state(struct ieee80211_local *local,
573 struct ieee80211_sub_if_data *sdata,
574 struct sta_info *sta,
575 enum ieee80211_sta_state old_state,
576 enum ieee80211_sta_state new_state)
577{
578 int ret = 0;
579
580 might_sleep();
581
582 sdata = get_bss_sdata(sdata);
Johannes Bergf6837ba2014-04-30 14:19:04 +0200583 if (!check_sdata_in_driver(sdata))
584 return -EIO;
Johannes Bergf09603a2012-01-20 13:55:21 +0100585
586 trace_drv_sta_state(local, sdata, &sta->sta, old_state, new_state);
Johannes Berga4ec45a2012-01-20 13:55:22 +0100587 if (local->ops->sta_state) {
Johannes Bergf09603a2012-01-20 13:55:21 +0100588 ret = local->ops->sta_state(&local->hw, &sdata->vif, &sta->sta,
589 old_state, new_state);
Johannes Berga4ec45a2012-01-20 13:55:22 +0100590 } else if (old_state == IEEE80211_STA_AUTH &&
591 new_state == IEEE80211_STA_ASSOC) {
592 ret = drv_sta_add(local, sdata, &sta->sta);
593 if (ret == 0)
594 sta->uploaded = true;
595 } else if (old_state == IEEE80211_STA_ASSOC &&
596 new_state == IEEE80211_STA_AUTH) {
597 drv_sta_remove(local, sdata, &sta->sta);
598 }
Johannes Bergf09603a2012-01-20 13:55:21 +0100599 trace_drv_return_int(local, ret);
600 return ret;
601}
602
Johannes Berg8f727ef2012-03-30 08:43:32 +0200603static inline void drv_sta_rc_update(struct ieee80211_local *local,
604 struct ieee80211_sub_if_data *sdata,
605 struct ieee80211_sta *sta, u32 changed)
606{
607 sdata = get_bss_sdata(sdata);
Johannes Bergf6837ba2014-04-30 14:19:04 +0200608 if (!check_sdata_in_driver(sdata))
609 return;
Johannes Berg8f727ef2012-03-30 08:43:32 +0200610
Antonio Quartullie687f612012-08-12 18:24:55 +0200611 WARN_ON(changed & IEEE80211_RC_SUPP_RATES_CHANGED &&
Thomas Pedersenf68d7762013-01-23 12:18:13 -0800612 (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
613 sdata->vif.type != NL80211_IFTYPE_MESH_POINT));
Antonio Quartullie687f612012-08-12 18:24:55 +0200614
Johannes Berg8f727ef2012-03-30 08:43:32 +0200615 trace_drv_sta_rc_update(local, sdata, sta, changed);
616 if (local->ops->sta_rc_update)
617 local->ops->sta_rc_update(&local->hw, &sdata->vif,
618 sta, changed);
619
620 trace_drv_return_void(local);
621}
622
Eliad Pellerf6f3def2011-09-25 20:06:54 +0300623static inline int drv_conf_tx(struct ieee80211_local *local,
Johannes Berga3304b02012-03-28 11:04:24 +0200624 struct ieee80211_sub_if_data *sdata, u16 ac,
Johannes Berg24487982009-04-23 18:52:52 +0200625 const struct ieee80211_tx_queue_params *params)
626{
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200627 int ret = -EOPNOTSUPP;
Kalle Valoe1781ed2009-12-23 13:15:47 +0100628
629 might_sleep();
630
Johannes Bergf6837ba2014-04-30 14:19:04 +0200631 if (!check_sdata_in_driver(sdata))
632 return -EIO;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100633
Johannes Berga3304b02012-03-28 11:04:24 +0200634 trace_drv_conf_tx(local, sdata, ac, params);
Johannes Berg24487982009-04-23 18:52:52 +0200635 if (local->ops->conf_tx)
Eliad Peller8a3a3c82011-10-02 10:15:52 +0200636 ret = local->ops->conf_tx(&local->hw, &sdata->vif,
Johannes Berga3304b02012-03-28 11:04:24 +0200637 ac, params);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200638 trace_drv_return_int(local, ret);
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200639 return ret;
Johannes Berg24487982009-04-23 18:52:52 +0200640}
641
Eliad Peller37a41b42011-09-21 14:06:11 +0300642static inline u64 drv_get_tsf(struct ieee80211_local *local,
643 struct ieee80211_sub_if_data *sdata)
Johannes Berg24487982009-04-23 18:52:52 +0200644{
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200645 u64 ret = -1ULL;
Kalle Valoe1781ed2009-12-23 13:15:47 +0100646
647 might_sleep();
648
Johannes Bergf6837ba2014-04-30 14:19:04 +0200649 if (!check_sdata_in_driver(sdata))
650 return ret;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100651
Eliad Peller37a41b42011-09-21 14:06:11 +0300652 trace_drv_get_tsf(local, sdata);
Johannes Berg24487982009-04-23 18:52:52 +0200653 if (local->ops->get_tsf)
Eliad Peller37a41b42011-09-21 14:06:11 +0300654 ret = local->ops->get_tsf(&local->hw, &sdata->vif);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200655 trace_drv_return_u64(local, ret);
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200656 return ret;
Johannes Berg24487982009-04-23 18:52:52 +0200657}
658
Eliad Peller37a41b42011-09-21 14:06:11 +0300659static inline void drv_set_tsf(struct ieee80211_local *local,
660 struct ieee80211_sub_if_data *sdata,
661 u64 tsf)
Johannes Berg24487982009-04-23 18:52:52 +0200662{
Kalle Valoe1781ed2009-12-23 13:15:47 +0100663 might_sleep();
664
Johannes Bergf6837ba2014-04-30 14:19:04 +0200665 if (!check_sdata_in_driver(sdata))
666 return;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100667
Eliad Peller37a41b42011-09-21 14:06:11 +0300668 trace_drv_set_tsf(local, sdata, tsf);
Johannes Berg24487982009-04-23 18:52:52 +0200669 if (local->ops->set_tsf)
Eliad Peller37a41b42011-09-21 14:06:11 +0300670 local->ops->set_tsf(&local->hw, &sdata->vif, tsf);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200671 trace_drv_return_void(local);
Johannes Berg24487982009-04-23 18:52:52 +0200672}
673
Eliad Peller37a41b42011-09-21 14:06:11 +0300674static inline void drv_reset_tsf(struct ieee80211_local *local,
675 struct ieee80211_sub_if_data *sdata)
Johannes Berg24487982009-04-23 18:52:52 +0200676{
Kalle Valoe1781ed2009-12-23 13:15:47 +0100677 might_sleep();
678
Johannes Bergf6837ba2014-04-30 14:19:04 +0200679 if (!check_sdata_in_driver(sdata))
680 return;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100681
Eliad Peller37a41b42011-09-21 14:06:11 +0300682 trace_drv_reset_tsf(local, sdata);
Johannes Berg24487982009-04-23 18:52:52 +0200683 if (local->ops->reset_tsf)
Eliad Peller37a41b42011-09-21 14:06:11 +0300684 local->ops->reset_tsf(&local->hw, &sdata->vif);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200685 trace_drv_return_void(local);
Johannes Berg24487982009-04-23 18:52:52 +0200686}
687
688static inline int drv_tx_last_beacon(struct ieee80211_local *local)
689{
Masanari Iida02582e92012-08-22 19:11:26 +0900690 int ret = 0; /* default unsupported op for less congestion */
Kalle Valoe1781ed2009-12-23 13:15:47 +0100691
692 might_sleep();
693
Johannes Berg4efc76b2010-06-10 10:56:20 +0200694 trace_drv_tx_last_beacon(local);
Johannes Berg24487982009-04-23 18:52:52 +0200695 if (local->ops->tx_last_beacon)
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200696 ret = local->ops->tx_last_beacon(&local->hw);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200697 trace_drv_return_int(local, ret);
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200698 return ret;
Johannes Berg24487982009-04-23 18:52:52 +0200699}
700
701static inline int drv_ampdu_action(struct ieee80211_local *local,
Johannes Berg12375ef2009-11-25 20:30:31 +0100702 struct ieee80211_sub_if_data *sdata,
Johannes Berg24487982009-04-23 18:52:52 +0200703 enum ieee80211_ampdu_mlme_action action,
704 struct ieee80211_sta *sta, u16 tid,
Johannes Berg0b01f032011-01-18 13:51:05 +0100705 u16 *ssn, u8 buf_size)
Johannes Berg24487982009-04-23 18:52:52 +0200706{
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200707 int ret = -EOPNOTSUPP;
Johannes Bergcfcdbde2010-06-10 10:21:48 +0200708
709 might_sleep();
710
Felix Fietkaubc192f82011-11-23 21:09:49 +0700711 sdata = get_bss_sdata(sdata);
Johannes Bergf6837ba2014-04-30 14:19:04 +0200712 if (!check_sdata_in_driver(sdata))
713 return -EIO;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100714
Johannes Berg0b01f032011-01-18 13:51:05 +0100715 trace_drv_ampdu_action(local, sdata, action, sta, tid, ssn, buf_size);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200716
Johannes Berg24487982009-04-23 18:52:52 +0200717 if (local->ops->ampdu_action)
Johannes Berg12375ef2009-11-25 20:30:31 +0100718 ret = local->ops->ampdu_action(&local->hw, &sdata->vif, action,
Johannes Berg0b01f032011-01-18 13:51:05 +0100719 sta, tid, ssn, buf_size);
Johannes Berg85ad1812010-06-10 10:21:49 +0200720
Johannes Berg4efc76b2010-06-10 10:56:20 +0200721 trace_drv_return_int(local, ret);
722
Johannes Berg0a2b8bb2009-07-07 13:46:22 +0200723 return ret;
Johannes Berg24487982009-04-23 18:52:52 +0200724}
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200725
Holger Schurig12897232010-04-19 10:23:57 +0200726static inline int drv_get_survey(struct ieee80211_local *local, int idx,
727 struct survey_info *survey)
728{
729 int ret = -EOPNOTSUPP;
John W. Linvillec466d4e2010-06-29 14:51:23 -0400730
731 trace_drv_get_survey(local, idx, survey);
732
Holger Schurig35dd0502010-06-07 16:33:49 +0200733 if (local->ops->get_survey)
Holger Schurig12897232010-04-19 10:23:57 +0200734 ret = local->ops->get_survey(&local->hw, idx, survey);
John W. Linvillec466d4e2010-06-29 14:51:23 -0400735
736 trace_drv_return_int(local, ret);
737
Holger Schurig12897232010-04-19 10:23:57 +0200738 return ret;
739}
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200740
741static inline void drv_rfkill_poll(struct ieee80211_local *local)
742{
Kalle Valoe1781ed2009-12-23 13:15:47 +0100743 might_sleep();
744
Johannes Berg1f87f7d2009-06-02 13:01:41 +0200745 if (local->ops->rfkill_poll)
746 local->ops->rfkill_poll(&local->hw);
747}
Johannes Berga80f7c02009-12-23 13:15:32 +0100748
Johannes Berg39ecc012013-02-13 12:11:00 +0100749static inline void drv_flush(struct ieee80211_local *local,
Emmanuel Grumbach77be2c52014-03-27 11:30:29 +0200750 struct ieee80211_sub_if_data *sdata,
Johannes Berg39ecc012013-02-13 12:11:00 +0100751 u32 queues, bool drop)
Johannes Berga80f7c02009-12-23 13:15:32 +0100752{
Emmanuel Grumbach77be2c52014-03-27 11:30:29 +0200753 struct ieee80211_vif *vif = sdata ? &sdata->vif : NULL;
754
Kalle Valoe1781ed2009-12-23 13:15:47 +0100755 might_sleep();
756
Johannes Bergf6837ba2014-04-30 14:19:04 +0200757 if (sdata && !check_sdata_in_driver(sdata))
758 return;
Emmanuel Grumbach77be2c52014-03-27 11:30:29 +0200759
Johannes Berg39ecc012013-02-13 12:11:00 +0100760 trace_drv_flush(local, queues, drop);
Johannes Berga80f7c02009-12-23 13:15:32 +0100761 if (local->ops->flush)
Emmanuel Grumbach77be2c52014-03-27 11:30:29 +0200762 local->ops->flush(&local->hw, vif, queues, drop);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200763 trace_drv_return_void(local);
Johannes Berga80f7c02009-12-23 13:15:32 +0100764}
Johannes Berg5ce6e432010-05-11 16:20:57 +0200765
766static inline void drv_channel_switch(struct ieee80211_local *local,
767 struct ieee80211_channel_switch *ch_switch)
768{
769 might_sleep();
770
Johannes Berg5ce6e432010-05-11 16:20:57 +0200771 trace_drv_channel_switch(local, ch_switch);
Johannes Berg4efc76b2010-06-10 10:56:20 +0200772 local->ops->channel_switch(&local->hw, ch_switch);
773 trace_drv_return_void(local);
Johannes Berg5ce6e432010-05-11 16:20:57 +0200774}
775
Bruno Randolf15d96752010-11-10 12:50:56 +0900776
777static inline int drv_set_antenna(struct ieee80211_local *local,
778 u32 tx_ant, u32 rx_ant)
779{
780 int ret = -EOPNOTSUPP;
781 might_sleep();
782 if (local->ops->set_antenna)
783 ret = local->ops->set_antenna(&local->hw, tx_ant, rx_ant);
784 trace_drv_set_antenna(local, tx_ant, rx_ant, ret);
785 return ret;
786}
787
788static inline int drv_get_antenna(struct ieee80211_local *local,
789 u32 *tx_ant, u32 *rx_ant)
790{
791 int ret = -EOPNOTSUPP;
792 might_sleep();
793 if (local->ops->get_antenna)
794 ret = local->ops->get_antenna(&local->hw, tx_ant, rx_ant);
795 trace_drv_get_antenna(local, *tx_ant, *rx_ant, ret);
796 return ret;
797}
798
Johannes Berg21f83582010-12-18 17:20:47 +0100799static inline int drv_remain_on_channel(struct ieee80211_local *local,
Eliad Peller49884562012-11-19 17:05:09 +0200800 struct ieee80211_sub_if_data *sdata,
Johannes Berg21f83582010-12-18 17:20:47 +0100801 struct ieee80211_channel *chan,
Ilan Peerd339d5c2013-02-12 09:34:13 +0200802 unsigned int duration,
803 enum ieee80211_roc_type type)
Johannes Berg21f83582010-12-18 17:20:47 +0100804{
805 int ret;
806
807 might_sleep();
808
Ilan Peerd339d5c2013-02-12 09:34:13 +0200809 trace_drv_remain_on_channel(local, sdata, chan, duration, type);
Eliad Peller49884562012-11-19 17:05:09 +0200810 ret = local->ops->remain_on_channel(&local->hw, &sdata->vif,
Ilan Peerd339d5c2013-02-12 09:34:13 +0200811 chan, duration, type);
Johannes Berg21f83582010-12-18 17:20:47 +0100812 trace_drv_return_int(local, ret);
813
814 return ret;
815}
816
817static inline int drv_cancel_remain_on_channel(struct ieee80211_local *local)
818{
819 int ret;
820
821 might_sleep();
822
823 trace_drv_cancel_remain_on_channel(local);
824 ret = local->ops->cancel_remain_on_channel(&local->hw);
825 trace_drv_return_int(local, ret);
826
827 return ret;
828}
829
John W. Linville38c09152011-03-07 16:19:18 -0500830static inline int drv_set_ringparam(struct ieee80211_local *local,
831 u32 tx, u32 rx)
832{
833 int ret = -ENOTSUPP;
834
835 might_sleep();
836
837 trace_drv_set_ringparam(local, tx, rx);
838 if (local->ops->set_ringparam)
839 ret = local->ops->set_ringparam(&local->hw, tx, rx);
840 trace_drv_return_int(local, ret);
841
842 return ret;
843}
844
845static inline void drv_get_ringparam(struct ieee80211_local *local,
846 u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
847{
848 might_sleep();
849
850 trace_drv_get_ringparam(local, tx, tx_max, rx, rx_max);
851 if (local->ops->get_ringparam)
852 local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max);
853 trace_drv_return_void(local);
854}
855
Vivek Natarajane8306f92011-04-06 11:41:10 +0530856static inline bool drv_tx_frames_pending(struct ieee80211_local *local)
857{
858 bool ret = false;
859
860 might_sleep();
861
862 trace_drv_tx_frames_pending(local);
863 if (local->ops->tx_frames_pending)
864 ret = local->ops->tx_frames_pending(&local->hw);
865 trace_drv_return_bool(local, ret);
866
867 return ret;
868}
Sujith Manoharanbdbfd6b2011-04-27 16:56:51 +0530869
870static inline int drv_set_bitrate_mask(struct ieee80211_local *local,
871 struct ieee80211_sub_if_data *sdata,
872 const struct cfg80211_bitrate_mask *mask)
873{
874 int ret = -EOPNOTSUPP;
875
876 might_sleep();
877
Johannes Bergf6837ba2014-04-30 14:19:04 +0200878 if (!check_sdata_in_driver(sdata))
879 return -EIO;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100880
Sujith Manoharanbdbfd6b2011-04-27 16:56:51 +0530881 trace_drv_set_bitrate_mask(local, sdata, mask);
882 if (local->ops->set_bitrate_mask)
883 ret = local->ops->set_bitrate_mask(&local->hw,
884 &sdata->vif, mask);
885 trace_drv_return_int(local, ret);
886
887 return ret;
888}
889
Johannes Bergc68f4b82011-07-05 16:35:41 +0200890static inline void drv_set_rekey_data(struct ieee80211_local *local,
891 struct ieee80211_sub_if_data *sdata,
892 struct cfg80211_gtk_rekey_data *data)
893{
Johannes Bergf6837ba2014-04-30 14:19:04 +0200894 if (!check_sdata_in_driver(sdata))
895 return;
Johannes Berg7b7eab62011-11-03 14:41:13 +0100896
Johannes Bergc68f4b82011-07-05 16:35:41 +0200897 trace_drv_set_rekey_data(local, sdata, data);
898 if (local->ops->set_rekey_data)
899 local->ops->set_rekey_data(&local->hw, &sdata->vif, data);
900 trace_drv_return_void(local);
901}
902
Meenakshi Venkataraman615f7b92011-07-08 08:46:22 -0700903static inline void drv_rssi_callback(struct ieee80211_local *local,
Emmanuel Grumbach887da912013-01-20 17:32:41 +0200904 struct ieee80211_sub_if_data *sdata,
Meenakshi Venkataraman615f7b92011-07-08 08:46:22 -0700905 const enum ieee80211_rssi_event event)
906{
Emmanuel Grumbach887da912013-01-20 17:32:41 +0200907 trace_drv_rssi_callback(local, sdata, event);
Meenakshi Venkataraman615f7b92011-07-08 08:46:22 -0700908 if (local->ops->rssi_callback)
Emmanuel Grumbach887da912013-01-20 17:32:41 +0200909 local->ops->rssi_callback(&local->hw, &sdata->vif, event);
Meenakshi Venkataraman615f7b92011-07-08 08:46:22 -0700910 trace_drv_return_void(local);
911}
Johannes Berg4049e092011-09-29 16:04:32 +0200912
913static inline void
914drv_release_buffered_frames(struct ieee80211_local *local,
915 struct sta_info *sta, u16 tids, int num_frames,
916 enum ieee80211_frame_release_type reason,
917 bool more_data)
918{
919 trace_drv_release_buffered_frames(local, &sta->sta, tids, num_frames,
920 reason, more_data);
921 if (local->ops->release_buffered_frames)
922 local->ops->release_buffered_frames(&local->hw, &sta->sta, tids,
923 num_frames, reason,
924 more_data);
925 trace_drv_return_void(local);
926}
Johannes Berg40b96402011-09-29 16:04:38 +0200927
928static inline void
929drv_allow_buffered_frames(struct ieee80211_local *local,
930 struct sta_info *sta, u16 tids, int num_frames,
931 enum ieee80211_frame_release_type reason,
932 bool more_data)
933{
934 trace_drv_allow_buffered_frames(local, &sta->sta, tids, num_frames,
935 reason, more_data);
936 if (local->ops->allow_buffered_frames)
937 local->ops->allow_buffered_frames(&local->hw, &sta->sta,
938 tids, num_frames, reason,
939 more_data);
940 trace_drv_return_void(local);
941}
Victor Goldenshtein66572cf2012-06-21 10:56:46 +0300942
943static inline int drv_get_rssi(struct ieee80211_local *local,
944 struct ieee80211_sub_if_data *sdata,
945 struct ieee80211_sta *sta,
946 s8 *rssi_dbm)
947{
948 int ret;
949
950 might_sleep();
951
952 ret = local->ops->get_rssi(&local->hw, &sdata->vif, sta, rssi_dbm);
953 trace_drv_get_rssi(local, sta, *rssi_dbm, ret);
954
955 return ret;
956}
Johannes Berga1845fc2012-06-27 13:18:36 +0200957
958static inline void drv_mgd_prepare_tx(struct ieee80211_local *local,
959 struct ieee80211_sub_if_data *sdata)
960{
961 might_sleep();
962
Johannes Bergf6837ba2014-04-30 14:19:04 +0200963 if (!check_sdata_in_driver(sdata))
964 return;
Johannes Berga1845fc2012-06-27 13:18:36 +0200965 WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION);
966
967 trace_drv_mgd_prepare_tx(local, sdata);
968 if (local->ops->mgd_prepare_tx)
969 local->ops->mgd_prepare_tx(&local->hw, &sdata->vif);
970 trace_drv_return_void(local);
971}
Michal Kaziorc3645ea2012-06-26 14:37:17 +0200972
973static inline int drv_add_chanctx(struct ieee80211_local *local,
974 struct ieee80211_chanctx *ctx)
975{
976 int ret = -EOPNOTSUPP;
977
978 trace_drv_add_chanctx(local, ctx);
979 if (local->ops->add_chanctx)
980 ret = local->ops->add_chanctx(&local->hw, &ctx->conf);
981 trace_drv_return_int(local, ret);
Johannes Berg8a61af62012-12-13 17:42:30 +0100982 if (!ret)
983 ctx->driver_present = true;
Michal Kaziorc3645ea2012-06-26 14:37:17 +0200984
985 return ret;
986}
987
988static inline void drv_remove_chanctx(struct ieee80211_local *local,
989 struct ieee80211_chanctx *ctx)
990{
Johannes Bergf6837ba2014-04-30 14:19:04 +0200991 if (WARN_ON(!ctx->driver_present))
992 return;
993
Michal Kaziorc3645ea2012-06-26 14:37:17 +0200994 trace_drv_remove_chanctx(local, ctx);
995 if (local->ops->remove_chanctx)
996 local->ops->remove_chanctx(&local->hw, &ctx->conf);
997 trace_drv_return_void(local);
Johannes Berg8a61af62012-12-13 17:42:30 +0100998 ctx->driver_present = false;
Michal Kaziorc3645ea2012-06-26 14:37:17 +0200999}
1000
1001static inline void drv_change_chanctx(struct ieee80211_local *local,
1002 struct ieee80211_chanctx *ctx,
1003 u32 changed)
1004{
1005 trace_drv_change_chanctx(local, ctx, changed);
Johannes Berg8a61af62012-12-13 17:42:30 +01001006 if (local->ops->change_chanctx) {
1007 WARN_ON_ONCE(!ctx->driver_present);
Michal Kaziorc3645ea2012-06-26 14:37:17 +02001008 local->ops->change_chanctx(&local->hw, &ctx->conf, changed);
Johannes Berg8a61af62012-12-13 17:42:30 +01001009 }
Michal Kaziorc3645ea2012-06-26 14:37:17 +02001010 trace_drv_return_void(local);
1011}
1012
1013static inline int drv_assign_vif_chanctx(struct ieee80211_local *local,
1014 struct ieee80211_sub_if_data *sdata,
1015 struct ieee80211_chanctx *ctx)
1016{
1017 int ret = 0;
1018
Johannes Bergf6837ba2014-04-30 14:19:04 +02001019 if (!check_sdata_in_driver(sdata))
1020 return -EIO;
Michal Kaziorc3645ea2012-06-26 14:37:17 +02001021
1022 trace_drv_assign_vif_chanctx(local, sdata, ctx);
Johannes Berg8a61af62012-12-13 17:42:30 +01001023 if (local->ops->assign_vif_chanctx) {
1024 WARN_ON_ONCE(!ctx->driver_present);
Michal Kaziorc3645ea2012-06-26 14:37:17 +02001025 ret = local->ops->assign_vif_chanctx(&local->hw,
1026 &sdata->vif,
1027 &ctx->conf);
Johannes Berg8a61af62012-12-13 17:42:30 +01001028 }
Michal Kaziorc3645ea2012-06-26 14:37:17 +02001029 trace_drv_return_int(local, ret);
1030
1031 return ret;
1032}
1033
1034static inline void drv_unassign_vif_chanctx(struct ieee80211_local *local,
1035 struct ieee80211_sub_if_data *sdata,
1036 struct ieee80211_chanctx *ctx)
1037{
Johannes Bergf6837ba2014-04-30 14:19:04 +02001038 if (!check_sdata_in_driver(sdata))
1039 return;
Michal Kaziorc3645ea2012-06-26 14:37:17 +02001040
1041 trace_drv_unassign_vif_chanctx(local, sdata, ctx);
Johannes Berg8a61af62012-12-13 17:42:30 +01001042 if (local->ops->unassign_vif_chanctx) {
1043 WARN_ON_ONCE(!ctx->driver_present);
Michal Kaziorc3645ea2012-06-26 14:37:17 +02001044 local->ops->unassign_vif_chanctx(&local->hw,
1045 &sdata->vif,
1046 &ctx->conf);
Johannes Berg8a61af62012-12-13 17:42:30 +01001047 }
Michal Kaziorc3645ea2012-06-26 14:37:17 +02001048 trace_drv_return_void(local);
1049}
1050
Luciano Coelho1a5f0c12014-05-23 14:33:12 +03001051static inline int
1052drv_switch_vif_chanctx(struct ieee80211_local *local,
1053 struct ieee80211_vif_chanctx_switch *vifs,
1054 int n_vifs,
1055 enum ieee80211_chanctx_switch_mode mode)
1056{
1057 int ret = 0;
1058 int i;
1059
1060 if (!local->ops->switch_vif_chanctx)
1061 return -EOPNOTSUPP;
1062
1063 for (i = 0; i < n_vifs; i++) {
1064 struct ieee80211_chanctx *new_ctx =
1065 container_of(vifs[i].new_ctx,
1066 struct ieee80211_chanctx,
1067 conf);
1068 struct ieee80211_chanctx *old_ctx =
1069 container_of(vifs[i].old_ctx,
1070 struct ieee80211_chanctx,
1071 conf);
1072
1073 WARN_ON_ONCE(!old_ctx->driver_present);
1074 WARN_ON_ONCE((mode == CHANCTX_SWMODE_SWAP_CONTEXTS &&
1075 new_ctx->driver_present) ||
1076 (mode == CHANCTX_SWMODE_REASSIGN_VIF &&
1077 !new_ctx->driver_present));
1078 }
1079
1080 trace_drv_switch_vif_chanctx(local, vifs, n_vifs, mode);
1081 ret = local->ops->switch_vif_chanctx(&local->hw,
1082 vifs, n_vifs, mode);
1083 trace_drv_return_int(local, ret);
1084
1085 if (!ret && mode == CHANCTX_SWMODE_SWAP_CONTEXTS) {
1086 for (i = 0; i < n_vifs; i++) {
1087 struct ieee80211_chanctx *new_ctx =
1088 container_of(vifs[i].new_ctx,
1089 struct ieee80211_chanctx,
1090 conf);
1091 struct ieee80211_chanctx *old_ctx =
1092 container_of(vifs[i].old_ctx,
1093 struct ieee80211_chanctx,
1094 conf);
1095
1096 new_ctx->driver_present = true;
1097 old_ctx->driver_present = false;
1098 }
1099 }
1100
1101 return ret;
1102}
1103
Johannes Berg10416382012-10-19 15:44:42 +02001104static inline int drv_start_ap(struct ieee80211_local *local,
1105 struct ieee80211_sub_if_data *sdata)
1106{
1107 int ret = 0;
1108
Johannes Bergf6837ba2014-04-30 14:19:04 +02001109 if (!check_sdata_in_driver(sdata))
1110 return -EIO;
Johannes Berg10416382012-10-19 15:44:42 +02001111
1112 trace_drv_start_ap(local, sdata, &sdata->vif.bss_conf);
1113 if (local->ops->start_ap)
1114 ret = local->ops->start_ap(&local->hw, &sdata->vif);
1115 trace_drv_return_int(local, ret);
1116 return ret;
1117}
1118
1119static inline void drv_stop_ap(struct ieee80211_local *local,
1120 struct ieee80211_sub_if_data *sdata)
1121{
Johannes Bergf6837ba2014-04-30 14:19:04 +02001122 if (!check_sdata_in_driver(sdata))
1123 return;
Johannes Berg10416382012-10-19 15:44:42 +02001124
1125 trace_drv_stop_ap(local, sdata);
1126 if (local->ops->stop_ap)
1127 local->ops->stop_ap(&local->hw, &sdata->vif);
1128 trace_drv_return_void(local);
1129}
1130
Johannes Berg9214ad72012-11-06 19:18:13 +01001131static inline void drv_restart_complete(struct ieee80211_local *local)
1132{
1133 might_sleep();
1134
1135 trace_drv_restart_complete(local);
1136 if (local->ops->restart_complete)
1137 local->ops->restart_complete(&local->hw);
1138 trace_drv_return_void(local);
1139}
1140
Yoni Divinskyde5fad82012-05-30 11:36:39 +03001141static inline void
1142drv_set_default_unicast_key(struct ieee80211_local *local,
1143 struct ieee80211_sub_if_data *sdata,
1144 int key_idx)
1145{
Johannes Bergf6837ba2014-04-30 14:19:04 +02001146 if (!check_sdata_in_driver(sdata))
1147 return;
Yoni Divinskyde5fad82012-05-30 11:36:39 +03001148
1149 WARN_ON_ONCE(key_idx < -1 || key_idx > 3);
1150
1151 trace_drv_set_default_unicast_key(local, sdata, key_idx);
1152 if (local->ops->set_default_unicast_key)
1153 local->ops->set_default_unicast_key(&local->hw, &sdata->vif,
1154 key_idx);
1155 trace_drv_return_void(local);
1156}
1157
Johannes Berga65240c2013-01-14 15:14:34 +01001158#if IS_ENABLED(CONFIG_IPV6)
1159static inline void drv_ipv6_addr_change(struct ieee80211_local *local,
1160 struct ieee80211_sub_if_data *sdata,
1161 struct inet6_dev *idev)
1162{
1163 trace_drv_ipv6_addr_change(local, sdata);
1164 if (local->ops->ipv6_addr_change)
1165 local->ops->ipv6_addr_change(&local->hw, &sdata->vif, idev);
1166 trace_drv_return_void(local);
1167}
1168#endif
1169
Simon Wunderlich73da7d52013-07-11 16:09:06 +02001170static inline void
1171drv_channel_switch_beacon(struct ieee80211_sub_if_data *sdata,
1172 struct cfg80211_chan_def *chandef)
1173{
1174 struct ieee80211_local *local = sdata->local;
1175
1176 if (local->ops->channel_switch_beacon) {
1177 trace_drv_channel_switch_beacon(local, sdata, chandef);
1178 local->ops->channel_switch_beacon(&local->hw, &sdata->vif,
1179 chandef);
1180 }
1181}
1182
Johannes Berg55fff502013-08-19 18:48:41 +02001183static inline int drv_join_ibss(struct ieee80211_local *local,
1184 struct ieee80211_sub_if_data *sdata)
1185{
1186 int ret = 0;
1187
1188 might_sleep();
Johannes Bergf6837ba2014-04-30 14:19:04 +02001189 if (!check_sdata_in_driver(sdata))
1190 return -EIO;
Johannes Berg55fff502013-08-19 18:48:41 +02001191
1192 trace_drv_join_ibss(local, sdata, &sdata->vif.bss_conf);
1193 if (local->ops->join_ibss)
1194 ret = local->ops->join_ibss(&local->hw, &sdata->vif);
1195 trace_drv_return_int(local, ret);
1196 return ret;
1197}
1198
1199static inline void drv_leave_ibss(struct ieee80211_local *local,
1200 struct ieee80211_sub_if_data *sdata)
1201{
1202 might_sleep();
Johannes Bergf6837ba2014-04-30 14:19:04 +02001203 if (!check_sdata_in_driver(sdata))
1204 return;
Johannes Berg55fff502013-08-19 18:48:41 +02001205
1206 trace_drv_leave_ibss(local, sdata);
1207 if (local->ops->leave_ibss)
1208 local->ops->leave_ibss(&local->hw, &sdata->vif);
1209 trace_drv_return_void(local);
1210}
1211
Antonio Quartullicca674d2014-05-19 21:53:20 +02001212static inline u32 drv_get_expected_throughput(struct ieee80211_local *local,
1213 struct ieee80211_sta *sta)
1214{
1215 u32 ret = 0;
1216
1217 trace_drv_get_expected_throughput(sta);
1218 if (local->ops->get_expected_throughput)
1219 ret = local->ops->get_expected_throughput(sta);
1220 trace_drv_return_u32(local, ret);
1221
1222 return ret;
1223}
1224
Johannes Berg24487982009-04-23 18:52:52 +02001225#endif /* __MAC80211_DRIVER_OPS */