]>
Commit | Line | Data |
---|---|---|
e35e4d28 HG |
1 | #ifndef __CFG80211_RDEV_OPS |
2 | #define __CFG80211_RDEV_OPS | |
3 | ||
4 | #include <linux/rtnetlink.h> | |
5 | #include <net/cfg80211.h> | |
6 | #include "core.h" | |
14e8a3c4 | 7 | #include "trace.h" |
e35e4d28 HG |
8 | |
9 | static inline int rdev_suspend(struct cfg80211_registered_device *rdev) | |
10 | { | |
14e8a3c4 BL |
11 | int ret; |
12 | trace_rdev_suspend(&rdev->wiphy, rdev->wowlan); | |
13 | ret = rdev->ops->suspend(&rdev->wiphy, rdev->wowlan); | |
14 | trace_rdev_return_int(&rdev->wiphy, ret); | |
15 | return ret; | |
e35e4d28 HG |
16 | } |
17 | ||
18 | static inline int rdev_resume(struct cfg80211_registered_device *rdev) | |
19 | { | |
14e8a3c4 BL |
20 | int ret; |
21 | trace_rdev_resume(&rdev->wiphy); | |
22 | ret = rdev->ops->resume(&rdev->wiphy); | |
23 | trace_rdev_return_int(&rdev->wiphy, ret); | |
24 | return ret; | |
e35e4d28 HG |
25 | } |
26 | ||
27 | static inline void rdev_set_wakeup(struct cfg80211_registered_device *rdev, | |
28 | bool enabled) | |
29 | { | |
14e8a3c4 | 30 | trace_rdev_set_wakeup(&rdev->wiphy, enabled); |
e35e4d28 | 31 | rdev->ops->set_wakeup(&rdev->wiphy, enabled); |
14e8a3c4 | 32 | trace_rdev_return_void(&rdev->wiphy); |
e35e4d28 HG |
33 | } |
34 | ||
35 | static inline struct wireless_dev | |
36 | *rdev_add_virtual_intf(struct cfg80211_registered_device *rdev, char *name, | |
37 | enum nl80211_iftype type, u32 *flags, | |
38 | struct vif_params *params) | |
39 | { | |
14e8a3c4 BL |
40 | struct wireless_dev *ret; |
41 | trace_rdev_add_virtual_intf(&rdev->wiphy, name, type); | |
42 | ret = rdev->ops->add_virtual_intf(&rdev->wiphy, name, type, flags, | |
43 | params); | |
44 | trace_rdev_return_wdev(&rdev->wiphy, ret); | |
45 | return ret; | |
e35e4d28 HG |
46 | } |
47 | ||
48 | static inline int | |
49 | rdev_del_virtual_intf(struct cfg80211_registered_device *rdev, | |
50 | struct wireless_dev *wdev) | |
51 | { | |
14e8a3c4 BL |
52 | int ret; |
53 | trace_rdev_del_virtual_intf(&rdev->wiphy, wdev); | |
54 | ret = rdev->ops->del_virtual_intf(&rdev->wiphy, wdev); | |
55 | trace_rdev_return_int(&rdev->wiphy, ret); | |
56 | return ret; | |
e35e4d28 HG |
57 | } |
58 | ||
59 | static inline int | |
60 | rdev_change_virtual_intf(struct cfg80211_registered_device *rdev, | |
61 | struct net_device *dev, enum nl80211_iftype type, | |
62 | u32 *flags, struct vif_params *params) | |
63 | { | |
14e8a3c4 BL |
64 | int ret; |
65 | trace_rdev_change_virtual_intf(&rdev->wiphy, dev, type); | |
66 | ret = rdev->ops->change_virtual_intf(&rdev->wiphy, dev, type, flags, | |
67 | params); | |
68 | trace_rdev_return_int(&rdev->wiphy, ret); | |
69 | return ret; | |
e35e4d28 HG |
70 | } |
71 | ||
72 | static inline int rdev_add_key(struct cfg80211_registered_device *rdev, | |
73 | struct net_device *netdev, u8 key_index, | |
74 | bool pairwise, const u8 *mac_addr, | |
75 | struct key_params *params) | |
76 | { | |
14e8a3c4 BL |
77 | int ret; |
78 | trace_rdev_add_key(&rdev->wiphy, netdev, key_index, pairwise, mac_addr); | |
79 | ret = rdev->ops->add_key(&rdev->wiphy, netdev, key_index, pairwise, | |
e35e4d28 | 80 | mac_addr, params); |
14e8a3c4 BL |
81 | trace_rdev_return_int(&rdev->wiphy, ret); |
82 | return ret; | |
e35e4d28 HG |
83 | } |
84 | ||
85 | static inline int | |
86 | rdev_get_key(struct cfg80211_registered_device *rdev, struct net_device *netdev, | |
87 | u8 key_index, bool pairwise, const u8 *mac_addr, void *cookie, | |
88 | void (*callback)(void *cookie, struct key_params*)) | |
89 | { | |
14e8a3c4 BL |
90 | int ret; |
91 | trace_rdev_get_key(&rdev->wiphy, netdev, key_index, pairwise, mac_addr); | |
92 | ret = rdev->ops->get_key(&rdev->wiphy, netdev, key_index, pairwise, | |
e35e4d28 | 93 | mac_addr, cookie, callback); |
14e8a3c4 BL |
94 | trace_rdev_return_int(&rdev->wiphy, ret); |
95 | return ret; | |
e35e4d28 HG |
96 | } |
97 | ||
98 | static inline int rdev_del_key(struct cfg80211_registered_device *rdev, | |
99 | struct net_device *netdev, u8 key_index, | |
100 | bool pairwise, const u8 *mac_addr) | |
101 | { | |
14e8a3c4 BL |
102 | int ret; |
103 | trace_rdev_del_key(&rdev->wiphy, netdev, key_index, pairwise, mac_addr); | |
104 | ret = rdev->ops->del_key(&rdev->wiphy, netdev, key_index, pairwise, | |
e35e4d28 | 105 | mac_addr); |
14e8a3c4 BL |
106 | trace_rdev_return_int(&rdev->wiphy, ret); |
107 | return ret; | |
e35e4d28 HG |
108 | } |
109 | ||
110 | static inline int | |
111 | rdev_set_default_key(struct cfg80211_registered_device *rdev, | |
112 | struct net_device *netdev, u8 key_index, bool unicast, | |
113 | bool multicast) | |
114 | { | |
14e8a3c4 BL |
115 | int ret; |
116 | trace_rdev_set_default_key(&rdev->wiphy, netdev, key_index, | |
117 | unicast, multicast); | |
118 | ret = rdev->ops->set_default_key(&rdev->wiphy, netdev, key_index, | |
e35e4d28 | 119 | unicast, multicast); |
14e8a3c4 BL |
120 | trace_rdev_return_int(&rdev->wiphy, ret); |
121 | return ret; | |
e35e4d28 HG |
122 | } |
123 | ||
124 | static inline int | |
125 | rdev_set_default_mgmt_key(struct cfg80211_registered_device *rdev, | |
126 | struct net_device *netdev, u8 key_index) | |
127 | { | |
14e8a3c4 BL |
128 | int ret; |
129 | trace_rdev_set_default_mgmt_key(&rdev->wiphy, netdev, key_index); | |
130 | ret = rdev->ops->set_default_mgmt_key(&rdev->wiphy, netdev, | |
e35e4d28 | 131 | key_index); |
14e8a3c4 BL |
132 | trace_rdev_return_int(&rdev->wiphy, ret); |
133 | return ret; | |
e35e4d28 HG |
134 | } |
135 | ||
136 | static inline int rdev_start_ap(struct cfg80211_registered_device *rdev, | |
137 | struct net_device *dev, | |
138 | struct cfg80211_ap_settings *settings) | |
139 | { | |
14e8a3c4 BL |
140 | int ret; |
141 | trace_rdev_start_ap(&rdev->wiphy, dev, settings); | |
142 | ret = rdev->ops->start_ap(&rdev->wiphy, dev, settings); | |
143 | trace_rdev_return_int(&rdev->wiphy, ret); | |
144 | return ret; | |
e35e4d28 HG |
145 | } |
146 | ||
147 | static inline int rdev_change_beacon(struct cfg80211_registered_device *rdev, | |
148 | struct net_device *dev, | |
149 | struct cfg80211_beacon_data *info) | |
150 | { | |
14e8a3c4 BL |
151 | int ret; |
152 | trace_rdev_change_beacon(&rdev->wiphy, dev, info); | |
153 | ret = rdev->ops->change_beacon(&rdev->wiphy, dev, info); | |
154 | trace_rdev_return_int(&rdev->wiphy, ret); | |
155 | return ret; | |
e35e4d28 HG |
156 | } |
157 | ||
158 | static inline int rdev_stop_ap(struct cfg80211_registered_device *rdev, | |
159 | struct net_device *dev) | |
160 | { | |
14e8a3c4 BL |
161 | int ret; |
162 | trace_rdev_stop_ap(&rdev->wiphy, dev); | |
163 | ret = rdev->ops->stop_ap(&rdev->wiphy, dev); | |
164 | trace_rdev_return_int(&rdev->wiphy, ret); | |
165 | return ret; | |
e35e4d28 HG |
166 | } |
167 | ||
168 | static inline int rdev_add_station(struct cfg80211_registered_device *rdev, | |
169 | struct net_device *dev, u8 *mac, | |
170 | struct station_parameters *params) | |
171 | { | |
14e8a3c4 BL |
172 | int ret; |
173 | trace_rdev_add_station(&rdev->wiphy, dev, mac, params); | |
174 | ret = rdev->ops->add_station(&rdev->wiphy, dev, mac, params); | |
175 | trace_rdev_return_int(&rdev->wiphy, ret); | |
176 | return ret; | |
e35e4d28 HG |
177 | } |
178 | ||
179 | static inline int rdev_del_station(struct cfg80211_registered_device *rdev, | |
180 | struct net_device *dev, u8 *mac) | |
181 | { | |
14e8a3c4 BL |
182 | int ret; |
183 | trace_rdev_del_station(&rdev->wiphy, dev, mac); | |
184 | ret = rdev->ops->del_station(&rdev->wiphy, dev, mac); | |
185 | trace_rdev_return_int(&rdev->wiphy, ret); | |
186 | return ret; | |
e35e4d28 HG |
187 | } |
188 | ||
189 | static inline int rdev_change_station(struct cfg80211_registered_device *rdev, | |
190 | struct net_device *dev, u8 *mac, | |
191 | struct station_parameters *params) | |
192 | { | |
14e8a3c4 BL |
193 | int ret; |
194 | trace_rdev_change_station(&rdev->wiphy, dev, mac, params); | |
195 | ret = rdev->ops->change_station(&rdev->wiphy, dev, mac, params); | |
196 | trace_rdev_return_int(&rdev->wiphy, ret); | |
197 | return ret; | |
e35e4d28 HG |
198 | } |
199 | ||
200 | static inline int rdev_get_station(struct cfg80211_registered_device *rdev, | |
201 | struct net_device *dev, u8 *mac, | |
202 | struct station_info *sinfo) | |
203 | { | |
14e8a3c4 BL |
204 | int ret; |
205 | trace_rdev_get_station(&rdev->wiphy, dev, mac); | |
206 | ret = rdev->ops->get_station(&rdev->wiphy, dev, mac, sinfo); | |
207 | trace_rdev_return_int_station_info(&rdev->wiphy, ret, sinfo); | |
208 | return ret; | |
e35e4d28 HG |
209 | } |
210 | ||
211 | static inline int rdev_dump_station(struct cfg80211_registered_device *rdev, | |
212 | struct net_device *dev, int idx, u8 *mac, | |
213 | struct station_info *sinfo) | |
214 | { | |
14e8a3c4 BL |
215 | int ret; |
216 | trace_rdev_dump_station(&rdev->wiphy, dev, idx, mac); | |
217 | ret = rdev->ops->dump_station(&rdev->wiphy, dev, idx, mac, sinfo); | |
218 | trace_rdev_return_int_station_info(&rdev->wiphy, ret, sinfo); | |
219 | return ret; | |
e35e4d28 HG |
220 | } |
221 | ||
222 | static inline int rdev_add_mpath(struct cfg80211_registered_device *rdev, | |
223 | struct net_device *dev, u8 *dst, u8 *next_hop) | |
224 | { | |
14e8a3c4 BL |
225 | int ret; |
226 | trace_rdev_add_mpath(&rdev->wiphy, dev, dst, next_hop); | |
227 | ret = rdev->ops->add_mpath(&rdev->wiphy, dev, dst, next_hop); | |
228 | trace_rdev_return_int(&rdev->wiphy, ret); | |
229 | return ret; | |
e35e4d28 HG |
230 | } |
231 | ||
232 | static inline int rdev_del_mpath(struct cfg80211_registered_device *rdev, | |
233 | struct net_device *dev, u8 *dst) | |
234 | { | |
14e8a3c4 BL |
235 | int ret; |
236 | trace_rdev_del_mpath(&rdev->wiphy, dev, dst); | |
237 | ret = rdev->ops->del_mpath(&rdev->wiphy, dev, dst); | |
238 | trace_rdev_return_int(&rdev->wiphy, ret); | |
239 | return ret; | |
e35e4d28 HG |
240 | } |
241 | ||
242 | static inline int rdev_change_mpath(struct cfg80211_registered_device *rdev, | |
243 | struct net_device *dev, u8 *dst, | |
244 | u8 *next_hop) | |
245 | { | |
14e8a3c4 BL |
246 | int ret; |
247 | trace_rdev_change_mpath(&rdev->wiphy, dev, dst, next_hop); | |
248 | ret = rdev->ops->change_mpath(&rdev->wiphy, dev, dst, next_hop); | |
249 | trace_rdev_return_int(&rdev->wiphy, ret); | |
250 | return ret; | |
e35e4d28 HG |
251 | } |
252 | ||
253 | static inline int rdev_get_mpath(struct cfg80211_registered_device *rdev, | |
254 | struct net_device *dev, u8 *dst, u8 *next_hop, | |
255 | struct mpath_info *pinfo) | |
256 | { | |
14e8a3c4 BL |
257 | int ret; |
258 | trace_rdev_get_mpath(&rdev->wiphy, dev, dst, next_hop); | |
259 | ret = rdev->ops->get_mpath(&rdev->wiphy, dev, dst, next_hop, pinfo); | |
260 | trace_rdev_return_int_mpath_info(&rdev->wiphy, ret, pinfo); | |
261 | return ret; | |
262 | ||
e35e4d28 HG |
263 | } |
264 | ||
265 | static inline int rdev_dump_mpath(struct cfg80211_registered_device *rdev, | |
266 | struct net_device *dev, int idx, u8 *dst, | |
267 | u8 *next_hop, struct mpath_info *pinfo) | |
268 | ||
269 | { | |
14e8a3c4 BL |
270 | int ret; |
271 | trace_rdev_dump_mpath(&rdev->wiphy, dev, idx, dst, next_hop); | |
272 | ret = rdev->ops->dump_mpath(&rdev->wiphy, dev, idx, dst, next_hop, | |
e35e4d28 | 273 | pinfo); |
14e8a3c4 BL |
274 | trace_rdev_return_int_mpath_info(&rdev->wiphy, ret, pinfo); |
275 | return ret; | |
e35e4d28 HG |
276 | } |
277 | ||
278 | static inline int | |
279 | rdev_get_mesh_config(struct cfg80211_registered_device *rdev, | |
280 | struct net_device *dev, struct mesh_config *conf) | |
281 | { | |
14e8a3c4 BL |
282 | int ret; |
283 | trace_rdev_get_mesh_config(&rdev->wiphy, dev); | |
284 | ret = rdev->ops->get_mesh_config(&rdev->wiphy, dev, conf); | |
285 | trace_rdev_return_int_mesh_config(&rdev->wiphy, ret, conf); | |
286 | return ret; | |
e35e4d28 HG |
287 | } |
288 | ||
289 | static inline int | |
290 | rdev_update_mesh_config(struct cfg80211_registered_device *rdev, | |
291 | struct net_device *dev, u32 mask, | |
292 | const struct mesh_config *nconf) | |
293 | { | |
14e8a3c4 BL |
294 | int ret; |
295 | trace_rdev_update_mesh_config(&rdev->wiphy, dev, mask, nconf); | |
296 | ret = rdev->ops->update_mesh_config(&rdev->wiphy, dev, mask, nconf); | |
297 | trace_rdev_return_int(&rdev->wiphy, ret); | |
298 | return ret; | |
e35e4d28 HG |
299 | } |
300 | ||
301 | static inline int rdev_join_mesh(struct cfg80211_registered_device *rdev, | |
302 | struct net_device *dev, | |
303 | const struct mesh_config *conf, | |
304 | const struct mesh_setup *setup) | |
305 | { | |
14e8a3c4 BL |
306 | int ret; |
307 | trace_rdev_join_mesh(&rdev->wiphy, dev, conf, setup); | |
308 | ret = rdev->ops->join_mesh(&rdev->wiphy, dev, conf, setup); | |
309 | trace_rdev_return_int(&rdev->wiphy, ret); | |
310 | return ret; | |
e35e4d28 HG |
311 | } |
312 | ||
313 | ||
314 | static inline int rdev_leave_mesh(struct cfg80211_registered_device *rdev, | |
315 | struct net_device *dev) | |
316 | { | |
14e8a3c4 BL |
317 | int ret; |
318 | trace_rdev_leave_mesh(&rdev->wiphy, dev); | |
319 | ret = rdev->ops->leave_mesh(&rdev->wiphy, dev); | |
320 | trace_rdev_return_int(&rdev->wiphy, ret); | |
321 | return ret; | |
e35e4d28 HG |
322 | } |
323 | ||
324 | static inline int rdev_change_bss(struct cfg80211_registered_device *rdev, | |
325 | struct net_device *dev, | |
326 | struct bss_parameters *params) | |
327 | ||
328 | { | |
14e8a3c4 BL |
329 | int ret; |
330 | trace_rdev_change_bss(&rdev->wiphy, dev, params); | |
331 | ret = rdev->ops->change_bss(&rdev->wiphy, dev, params); | |
332 | trace_rdev_return_int(&rdev->wiphy, ret); | |
333 | return ret; | |
e35e4d28 HG |
334 | } |
335 | ||
336 | static inline int rdev_set_txq_params(struct cfg80211_registered_device *rdev, | |
337 | struct net_device *dev, | |
338 | struct ieee80211_txq_params *params) | |
339 | ||
340 | { | |
14e8a3c4 BL |
341 | int ret; |
342 | trace_rdev_set_txq_params(&rdev->wiphy, dev, params); | |
343 | ret = rdev->ops->set_txq_params(&rdev->wiphy, dev, params); | |
344 | trace_rdev_return_int(&rdev->wiphy, ret); | |
345 | return ret; | |
e35e4d28 HG |
346 | } |
347 | ||
348 | static inline int | |
349 | rdev_libertas_set_mesh_channel(struct cfg80211_registered_device *rdev, | |
350 | struct net_device *dev, | |
351 | struct ieee80211_channel *chan) | |
352 | { | |
14e8a3c4 BL |
353 | int ret; |
354 | trace_rdev_libertas_set_mesh_channel(&rdev->wiphy, dev, chan); | |
355 | ret = rdev->ops->libertas_set_mesh_channel(&rdev->wiphy, dev, chan); | |
356 | trace_rdev_return_int(&rdev->wiphy, ret); | |
357 | return ret; | |
e35e4d28 HG |
358 | } |
359 | ||
360 | static inline int | |
361 | rdev_set_monitor_channel(struct cfg80211_registered_device *rdev, | |
362 | struct ieee80211_channel *chan, | |
363 | enum nl80211_channel_type channel_type) | |
364 | { | |
14e8a3c4 BL |
365 | int ret; |
366 | trace_rdev_set_monitor_channel(&rdev->wiphy, chan, channel_type); | |
367 | ret = rdev->ops->set_monitor_channel(&rdev->wiphy, chan, channel_type); | |
368 | trace_rdev_return_int(&rdev->wiphy, ret); | |
369 | return ret; | |
e35e4d28 HG |
370 | } |
371 | ||
372 | static inline int rdev_scan(struct cfg80211_registered_device *rdev, | |
373 | struct cfg80211_scan_request *request) | |
374 | { | |
14e8a3c4 BL |
375 | int ret; |
376 | trace_rdev_scan(&rdev->wiphy, request); | |
377 | ret = rdev->ops->scan(&rdev->wiphy, request); | |
378 | trace_rdev_return_int(&rdev->wiphy, ret); | |
379 | return ret; | |
e35e4d28 HG |
380 | } |
381 | ||
382 | static inline int rdev_auth(struct cfg80211_registered_device *rdev, | |
383 | struct net_device *dev, | |
384 | struct cfg80211_auth_request *req) | |
385 | { | |
14e8a3c4 BL |
386 | int ret; |
387 | trace_rdev_auth(&rdev->wiphy, dev, req); | |
388 | ret = rdev->ops->auth(&rdev->wiphy, dev, req); | |
389 | trace_rdev_return_int(&rdev->wiphy, ret); | |
390 | return ret; | |
e35e4d28 HG |
391 | } |
392 | ||
393 | static inline int rdev_assoc(struct cfg80211_registered_device *rdev, | |
394 | struct net_device *dev, | |
395 | struct cfg80211_assoc_request *req) | |
396 | { | |
14e8a3c4 BL |
397 | int ret; |
398 | trace_rdev_assoc(&rdev->wiphy, dev, req); | |
399 | ret = rdev->ops->assoc(&rdev->wiphy, dev, req); | |
400 | trace_rdev_return_int(&rdev->wiphy, ret); | |
401 | return ret; | |
e35e4d28 HG |
402 | } |
403 | ||
404 | static inline int rdev_deauth(struct cfg80211_registered_device *rdev, | |
405 | struct net_device *dev, | |
406 | struct cfg80211_deauth_request *req) | |
407 | { | |
14e8a3c4 BL |
408 | int ret; |
409 | trace_rdev_deauth(&rdev->wiphy, dev, req); | |
410 | ret = rdev->ops->deauth(&rdev->wiphy, dev, req); | |
411 | trace_rdev_return_int(&rdev->wiphy, ret); | |
412 | return ret; | |
e35e4d28 HG |
413 | } |
414 | ||
415 | static inline int rdev_disassoc(struct cfg80211_registered_device *rdev, | |
416 | struct net_device *dev, | |
417 | struct cfg80211_disassoc_request *req) | |
418 | { | |
14e8a3c4 BL |
419 | int ret; |
420 | trace_rdev_disassoc(&rdev->wiphy, dev, req); | |
421 | ret = rdev->ops->disassoc(&rdev->wiphy, dev, req); | |
422 | trace_rdev_return_int(&rdev->wiphy, ret); | |
423 | return ret; | |
e35e4d28 HG |
424 | } |
425 | ||
426 | static inline int rdev_connect(struct cfg80211_registered_device *rdev, | |
427 | struct net_device *dev, | |
428 | struct cfg80211_connect_params *sme) | |
429 | { | |
14e8a3c4 BL |
430 | int ret; |
431 | trace_rdev_connect(&rdev->wiphy, dev, sme); | |
432 | ret = rdev->ops->connect(&rdev->wiphy, dev, sme); | |
433 | trace_rdev_return_int(&rdev->wiphy, ret); | |
434 | return ret; | |
e35e4d28 HG |
435 | } |
436 | ||
437 | static inline int rdev_disconnect(struct cfg80211_registered_device *rdev, | |
438 | struct net_device *dev, u16 reason_code) | |
439 | { | |
14e8a3c4 BL |
440 | int ret; |
441 | trace_rdev_disconnect(&rdev->wiphy, dev, reason_code); | |
442 | ret = rdev->ops->disconnect(&rdev->wiphy, dev, reason_code); | |
443 | trace_rdev_return_int(&rdev->wiphy, ret); | |
444 | return ret; | |
e35e4d28 HG |
445 | } |
446 | ||
447 | static inline int rdev_join_ibss(struct cfg80211_registered_device *rdev, | |
448 | struct net_device *dev, | |
449 | struct cfg80211_ibss_params *params) | |
450 | { | |
14e8a3c4 BL |
451 | int ret; |
452 | trace_rdev_join_ibss(&rdev->wiphy, dev, params); | |
453 | ret = rdev->ops->join_ibss(&rdev->wiphy, dev, params); | |
454 | trace_rdev_return_int(&rdev->wiphy, ret); | |
455 | return ret; | |
e35e4d28 HG |
456 | } |
457 | ||
458 | static inline int rdev_leave_ibss(struct cfg80211_registered_device *rdev, | |
459 | struct net_device *dev) | |
460 | { | |
14e8a3c4 BL |
461 | int ret; |
462 | trace_rdev_leave_ibss(&rdev->wiphy, dev); | |
463 | ret = rdev->ops->leave_ibss(&rdev->wiphy, dev); | |
464 | trace_rdev_return_int(&rdev->wiphy, ret); | |
465 | return ret; | |
e35e4d28 HG |
466 | } |
467 | ||
468 | static inline int | |
469 | rdev_set_wiphy_params(struct cfg80211_registered_device *rdev, u32 changed) | |
470 | { | |
14e8a3c4 BL |
471 | int ret; |
472 | trace_rdev_set_wiphy_params(&rdev->wiphy, changed); | |
473 | ret = rdev->ops->set_wiphy_params(&rdev->wiphy, changed); | |
474 | trace_rdev_return_int(&rdev->wiphy, ret); | |
475 | return ret; | |
e35e4d28 HG |
476 | } |
477 | ||
478 | static inline int rdev_set_tx_power(struct cfg80211_registered_device *rdev, | |
c8442118 | 479 | struct wireless_dev *wdev, |
e35e4d28 HG |
480 | enum nl80211_tx_power_setting type, int mbm) |
481 | { | |
14e8a3c4 | 482 | int ret; |
c8442118 JB |
483 | trace_rdev_set_tx_power(&rdev->wiphy, wdev, type, mbm); |
484 | ret = rdev->ops->set_tx_power(&rdev->wiphy, wdev, type, mbm); | |
14e8a3c4 BL |
485 | trace_rdev_return_int(&rdev->wiphy, ret); |
486 | return ret; | |
e35e4d28 HG |
487 | } |
488 | ||
489 | static inline int rdev_get_tx_power(struct cfg80211_registered_device *rdev, | |
c8442118 | 490 | struct wireless_dev *wdev, int *dbm) |
e35e4d28 | 491 | { |
14e8a3c4 | 492 | int ret; |
c8442118 JB |
493 | trace_rdev_get_tx_power(&rdev->wiphy, wdev); |
494 | ret = rdev->ops->get_tx_power(&rdev->wiphy, wdev, dbm); | |
14e8a3c4 BL |
495 | trace_rdev_return_int_int(&rdev->wiphy, ret, *dbm); |
496 | return ret; | |
e35e4d28 HG |
497 | } |
498 | ||
499 | static inline int rdev_set_wds_peer(struct cfg80211_registered_device *rdev, | |
500 | struct net_device *dev, const u8 *addr) | |
501 | { | |
14e8a3c4 BL |
502 | int ret; |
503 | trace_rdev_set_wds_peer(&rdev->wiphy, dev, addr); | |
504 | ret = rdev->ops->set_wds_peer(&rdev->wiphy, dev, addr); | |
505 | trace_rdev_return_int(&rdev->wiphy, ret); | |
506 | return ret; | |
e35e4d28 HG |
507 | } |
508 | ||
509 | static inline void rdev_rfkill_poll(struct cfg80211_registered_device *rdev) | |
510 | { | |
14e8a3c4 | 511 | trace_rdev_rfkill_poll(&rdev->wiphy); |
e35e4d28 | 512 | rdev->ops->rfkill_poll(&rdev->wiphy); |
14e8a3c4 | 513 | trace_rdev_return_void(&rdev->wiphy); |
e35e4d28 HG |
514 | } |
515 | ||
516 | ||
517 | #ifdef CONFIG_NL80211_TESTMODE | |
518 | static inline int rdev_testmode_cmd(struct cfg80211_registered_device *rdev, | |
519 | void *data, int len) | |
520 | { | |
14e8a3c4 BL |
521 | int ret; |
522 | trace_rdev_testmode_cmd(&rdev->wiphy); | |
523 | ret = rdev->ops->testmode_cmd(&rdev->wiphy, data, len); | |
524 | trace_rdev_return_int(&rdev->wiphy, ret); | |
525 | return ret; | |
e35e4d28 HG |
526 | } |
527 | ||
528 | static inline int rdev_testmode_dump(struct cfg80211_registered_device *rdev, | |
529 | struct sk_buff *skb, | |
530 | struct netlink_callback *cb, void *data, | |
531 | int len) | |
532 | { | |
14e8a3c4 BL |
533 | int ret; |
534 | trace_rdev_testmode_dump(&rdev->wiphy); | |
535 | ret = rdev->ops->testmode_dump(&rdev->wiphy, skb, cb, data, len); | |
536 | trace_rdev_return_int(&rdev->wiphy, ret); | |
537 | return ret; | |
e35e4d28 HG |
538 | } |
539 | #endif | |
540 | ||
541 | static inline int | |
542 | rdev_set_bitrate_mask(struct cfg80211_registered_device *rdev, | |
543 | struct net_device *dev, const u8 *peer, | |
544 | const struct cfg80211_bitrate_mask *mask) | |
545 | { | |
14e8a3c4 BL |
546 | int ret; |
547 | trace_rdev_set_bitrate_mask(&rdev->wiphy, dev, peer, mask); | |
548 | ret = rdev->ops->set_bitrate_mask(&rdev->wiphy, dev, peer, mask); | |
549 | trace_rdev_return_int(&rdev->wiphy, ret); | |
550 | return ret; | |
e35e4d28 HG |
551 | } |
552 | ||
553 | static inline int rdev_dump_survey(struct cfg80211_registered_device *rdev, | |
554 | struct net_device *netdev, int idx, | |
555 | struct survey_info *info) | |
556 | { | |
14e8a3c4 BL |
557 | int ret; |
558 | trace_rdev_dump_survey(&rdev->wiphy, netdev, idx); | |
559 | ret = rdev->ops->dump_survey(&rdev->wiphy, netdev, idx, info); | |
560 | if (ret < 0) | |
561 | trace_rdev_return_int(&rdev->wiphy, ret); | |
562 | else | |
563 | trace_rdev_return_int_survey_info(&rdev->wiphy, ret, info); | |
564 | return ret; | |
e35e4d28 HG |
565 | } |
566 | ||
567 | static inline int rdev_set_pmksa(struct cfg80211_registered_device *rdev, | |
568 | struct net_device *netdev, | |
569 | struct cfg80211_pmksa *pmksa) | |
570 | { | |
14e8a3c4 BL |
571 | int ret; |
572 | trace_rdev_set_pmksa(&rdev->wiphy, netdev, pmksa); | |
573 | ret = rdev->ops->set_pmksa(&rdev->wiphy, netdev, pmksa); | |
574 | trace_rdev_return_int(&rdev->wiphy, ret); | |
575 | return ret; | |
e35e4d28 HG |
576 | } |
577 | ||
578 | static inline int rdev_del_pmksa(struct cfg80211_registered_device *rdev, | |
579 | struct net_device *netdev, | |
580 | struct cfg80211_pmksa *pmksa) | |
581 | { | |
14e8a3c4 BL |
582 | int ret; |
583 | trace_rdev_del_pmksa(&rdev->wiphy, netdev, pmksa); | |
584 | ret = rdev->ops->del_pmksa(&rdev->wiphy, netdev, pmksa); | |
585 | trace_rdev_return_int(&rdev->wiphy, ret); | |
586 | return ret; | |
e35e4d28 HG |
587 | } |
588 | ||
589 | static inline int rdev_flush_pmksa(struct cfg80211_registered_device *rdev, | |
590 | struct net_device *netdev) | |
591 | { | |
14e8a3c4 BL |
592 | int ret; |
593 | trace_rdev_flush_pmksa(&rdev->wiphy, netdev); | |
594 | ret = rdev->ops->flush_pmksa(&rdev->wiphy, netdev); | |
595 | trace_rdev_return_int(&rdev->wiphy, ret); | |
596 | return ret; | |
e35e4d28 HG |
597 | } |
598 | ||
599 | static inline int | |
600 | rdev_remain_on_channel(struct cfg80211_registered_device *rdev, | |
601 | struct wireless_dev *wdev, | |
602 | struct ieee80211_channel *chan, | |
603 | enum nl80211_channel_type channel_type, | |
604 | unsigned int duration, u64 *cookie) | |
605 | { | |
14e8a3c4 BL |
606 | int ret; |
607 | trace_rdev_remain_on_channel(&rdev->wiphy, wdev, chan, channel_type, | |
608 | duration); | |
609 | ret = rdev->ops->remain_on_channel(&rdev->wiphy, wdev, chan, | |
e35e4d28 | 610 | channel_type, duration, cookie); |
14e8a3c4 BL |
611 | trace_rdev_return_int_cookie(&rdev->wiphy, ret, *cookie); |
612 | return ret; | |
e35e4d28 HG |
613 | } |
614 | ||
615 | static inline int | |
616 | rdev_cancel_remain_on_channel(struct cfg80211_registered_device *rdev, | |
617 | struct wireless_dev *wdev, u64 cookie) | |
618 | { | |
14e8a3c4 BL |
619 | int ret; |
620 | trace_rdev_cancel_remain_on_channel(&rdev->wiphy, wdev, cookie); | |
621 | ret = rdev->ops->cancel_remain_on_channel(&rdev->wiphy, wdev, cookie); | |
622 | trace_rdev_return_int(&rdev->wiphy, ret); | |
623 | return ret; | |
e35e4d28 HG |
624 | } |
625 | ||
626 | static inline int rdev_mgmt_tx(struct cfg80211_registered_device *rdev, | |
627 | struct wireless_dev *wdev, | |
628 | struct ieee80211_channel *chan, bool offchan, | |
629 | enum nl80211_channel_type channel_type, | |
630 | bool channel_type_valid, unsigned int wait, | |
631 | const u8 *buf, size_t len, bool no_cck, | |
632 | bool dont_wait_for_ack, u64 *cookie) | |
633 | { | |
14e8a3c4 BL |
634 | int ret; |
635 | trace_rdev_mgmt_tx(&rdev->wiphy, wdev, chan, offchan, channel_type, | |
636 | channel_type_valid, wait, no_cck, dont_wait_for_ack); | |
637 | ret = rdev->ops->mgmt_tx(&rdev->wiphy, wdev, chan, offchan, | |
e35e4d28 HG |
638 | channel_type, channel_type_valid, wait, buf, |
639 | len, no_cck, dont_wait_for_ack, cookie); | |
14e8a3c4 BL |
640 | trace_rdev_return_int_cookie(&rdev->wiphy, ret, *cookie); |
641 | return ret; | |
e35e4d28 HG |
642 | } |
643 | ||
644 | static inline int | |
645 | rdev_mgmt_tx_cancel_wait(struct cfg80211_registered_device *rdev, | |
646 | struct wireless_dev *wdev, u64 cookie) | |
647 | { | |
14e8a3c4 BL |
648 | int ret; |
649 | trace_rdev_mgmt_tx_cancel_wait(&rdev->wiphy, wdev, cookie); | |
650 | ret = rdev->ops->mgmt_tx_cancel_wait(&rdev->wiphy, wdev, cookie); | |
651 | trace_rdev_return_int(&rdev->wiphy, ret); | |
652 | return ret; | |
e35e4d28 HG |
653 | } |
654 | ||
655 | static inline int rdev_set_power_mgmt(struct cfg80211_registered_device *rdev, | |
656 | struct net_device *dev, bool enabled, | |
657 | int timeout) | |
658 | { | |
14e8a3c4 BL |
659 | int ret; |
660 | trace_rdev_set_power_mgmt(&rdev->wiphy, dev, enabled, timeout); | |
661 | ret = rdev->ops->set_power_mgmt(&rdev->wiphy, dev, enabled, timeout); | |
662 | trace_rdev_return_int(&rdev->wiphy, ret); | |
663 | return ret; | |
e35e4d28 HG |
664 | } |
665 | ||
666 | static inline int | |
667 | rdev_set_cqm_rssi_config(struct cfg80211_registered_device *rdev, | |
668 | struct net_device *dev, s32 rssi_thold, u32 rssi_hyst) | |
669 | { | |
14e8a3c4 BL |
670 | int ret; |
671 | trace_rdev_set_cqm_rssi_config(&rdev->wiphy, dev, rssi_thold, | |
672 | rssi_hyst); | |
673 | ret = rdev->ops->set_cqm_rssi_config(&rdev->wiphy, dev, rssi_thold, | |
674 | rssi_hyst); | |
675 | trace_rdev_return_int(&rdev->wiphy, ret); | |
676 | return ret; | |
e35e4d28 HG |
677 | } |
678 | ||
679 | static inline int | |
680 | rdev_set_cqm_txe_config(struct cfg80211_registered_device *rdev, | |
681 | struct net_device *dev, u32 rate, u32 pkts, u32 intvl) | |
682 | { | |
14e8a3c4 BL |
683 | int ret; |
684 | trace_rdev_set_cqm_txe_config(&rdev->wiphy, dev, rate, pkts, intvl); | |
685 | ret = rdev->ops->set_cqm_txe_config(&rdev->wiphy, dev, rate, pkts, | |
e35e4d28 | 686 | intvl); |
14e8a3c4 BL |
687 | trace_rdev_return_int(&rdev->wiphy, ret); |
688 | return ret; | |
e35e4d28 HG |
689 | } |
690 | ||
691 | static inline void | |
692 | rdev_mgmt_frame_register(struct cfg80211_registered_device *rdev, | |
693 | struct wireless_dev *wdev, u16 frame_type, bool reg) | |
694 | { | |
14e8a3c4 BL |
695 | trace_rdev_mgmt_frame_register(&rdev->wiphy, wdev , frame_type, reg); |
696 | rdev->ops->mgmt_frame_register(&rdev->wiphy, wdev , frame_type, reg); | |
697 | trace_rdev_return_void(&rdev->wiphy); | |
e35e4d28 HG |
698 | } |
699 | ||
700 | static inline int rdev_set_antenna(struct cfg80211_registered_device *rdev, | |
701 | u32 tx_ant, u32 rx_ant) | |
702 | { | |
14e8a3c4 BL |
703 | int ret; |
704 | trace_rdev_set_antenna(&rdev->wiphy, tx_ant, rx_ant); | |
705 | ret = rdev->ops->set_antenna(&rdev->wiphy, tx_ant, rx_ant); | |
706 | trace_rdev_return_int(&rdev->wiphy, ret); | |
707 | return ret; | |
e35e4d28 HG |
708 | } |
709 | ||
710 | static inline int rdev_get_antenna(struct cfg80211_registered_device *rdev, | |
711 | u32 *tx_ant, u32 *rx_ant) | |
712 | { | |
14e8a3c4 BL |
713 | int ret; |
714 | trace_rdev_get_antenna(&rdev->wiphy); | |
715 | ret = rdev->ops->get_antenna(&rdev->wiphy, tx_ant, rx_ant); | |
716 | if (ret) | |
717 | trace_rdev_return_int(&rdev->wiphy, ret); | |
718 | else | |
719 | trace_rdev_return_int_tx_rx(&rdev->wiphy, ret, *tx_ant, | |
720 | *rx_ant); | |
721 | return ret; | |
e35e4d28 HG |
722 | } |
723 | ||
724 | static inline int rdev_set_ringparam(struct cfg80211_registered_device *rdev, | |
725 | u32 tx, u32 rx) | |
726 | { | |
14e8a3c4 BL |
727 | int ret; |
728 | trace_rdev_set_ringparam(&rdev->wiphy, tx, rx); | |
729 | ret = rdev->ops->set_ringparam(&rdev->wiphy, tx, rx); | |
730 | trace_rdev_return_int(&rdev->wiphy, ret); | |
731 | return ret; | |
e35e4d28 HG |
732 | } |
733 | ||
734 | static inline void rdev_get_ringparam(struct cfg80211_registered_device *rdev, | |
735 | u32 *tx, u32 *tx_max, u32 *rx, | |
736 | u32 *rx_max) | |
737 | { | |
14e8a3c4 | 738 | trace_rdev_get_ringparam(&rdev->wiphy); |
e35e4d28 | 739 | rdev->ops->get_ringparam(&rdev->wiphy, tx, tx_max, rx, rx_max); |
14e8a3c4 | 740 | trace_rdev_return_void_tx_rx(&rdev->wiphy, *tx, *tx_max, *rx, *rx_max); |
e35e4d28 HG |
741 | } |
742 | ||
743 | static inline int | |
744 | rdev_sched_scan_start(struct cfg80211_registered_device *rdev, | |
745 | struct net_device *dev, | |
746 | struct cfg80211_sched_scan_request *request) | |
747 | { | |
14e8a3c4 BL |
748 | int ret; |
749 | trace_rdev_sched_scan_start(&rdev->wiphy, dev, request); | |
750 | ret = rdev->ops->sched_scan_start(&rdev->wiphy, dev, request); | |
751 | trace_rdev_return_int(&rdev->wiphy, ret); | |
752 | return ret; | |
e35e4d28 HG |
753 | } |
754 | ||
755 | static inline int rdev_sched_scan_stop(struct cfg80211_registered_device *rdev, | |
756 | struct net_device *dev) | |
757 | { | |
14e8a3c4 BL |
758 | int ret; |
759 | trace_rdev_sched_scan_stop(&rdev->wiphy, dev); | |
760 | ret = rdev->ops->sched_scan_stop(&rdev->wiphy, dev); | |
761 | trace_rdev_return_int(&rdev->wiphy, ret); | |
762 | return ret; | |
e35e4d28 HG |
763 | } |
764 | ||
765 | static inline int rdev_set_rekey_data(struct cfg80211_registered_device *rdev, | |
766 | struct net_device *dev, | |
767 | struct cfg80211_gtk_rekey_data *data) | |
768 | { | |
14e8a3c4 BL |
769 | int ret; |
770 | trace_rdev_set_rekey_data(&rdev->wiphy, dev); | |
771 | ret = rdev->ops->set_rekey_data(&rdev->wiphy, dev, data); | |
772 | trace_rdev_return_int(&rdev->wiphy, ret); | |
773 | return ret; | |
e35e4d28 HG |
774 | } |
775 | ||
776 | static inline int rdev_tdls_mgmt(struct cfg80211_registered_device *rdev, | |
777 | struct net_device *dev, u8 *peer, | |
778 | u8 action_code, u8 dialog_token, | |
779 | u16 status_code, const u8 *buf, size_t len) | |
780 | { | |
14e8a3c4 BL |
781 | int ret; |
782 | trace_rdev_tdls_mgmt(&rdev->wiphy, dev, peer, action_code, | |
783 | dialog_token, status_code, buf, len); | |
784 | ret = rdev->ops->tdls_mgmt(&rdev->wiphy, dev, peer, action_code, | |
785 | dialog_token, status_code, buf, len); | |
786 | trace_rdev_return_int(&rdev->wiphy, ret); | |
787 | return ret; | |
e35e4d28 HG |
788 | } |
789 | ||
790 | static inline int rdev_tdls_oper(struct cfg80211_registered_device *rdev, | |
791 | struct net_device *dev, u8 *peer, | |
792 | enum nl80211_tdls_operation oper) | |
793 | { | |
14e8a3c4 BL |
794 | int ret; |
795 | trace_rdev_tdls_oper(&rdev->wiphy, dev, peer, oper); | |
796 | ret = rdev->ops->tdls_oper(&rdev->wiphy, dev, peer, oper); | |
797 | trace_rdev_return_int(&rdev->wiphy, ret); | |
798 | return ret; | |
e35e4d28 HG |
799 | } |
800 | ||
801 | static inline int rdev_probe_client(struct cfg80211_registered_device *rdev, | |
802 | struct net_device *dev, const u8 *peer, | |
803 | u64 *cookie) | |
804 | { | |
14e8a3c4 BL |
805 | int ret; |
806 | trace_rdev_probe_client(&rdev->wiphy, dev, peer); | |
807 | ret = rdev->ops->probe_client(&rdev->wiphy, dev, peer, cookie); | |
808 | trace_rdev_return_int_cookie(&rdev->wiphy, ret, *cookie); | |
809 | return ret; | |
e35e4d28 HG |
810 | } |
811 | ||
812 | static inline int rdev_set_noack_map(struct cfg80211_registered_device *rdev, | |
813 | struct net_device *dev, u16 noack_map) | |
814 | { | |
14e8a3c4 BL |
815 | int ret; |
816 | trace_rdev_set_noack_map(&rdev->wiphy, dev, noack_map); | |
817 | ret = rdev->ops->set_noack_map(&rdev->wiphy, dev, noack_map); | |
818 | trace_rdev_return_int(&rdev->wiphy, ret); | |
819 | return ret; | |
e35e4d28 HG |
820 | } |
821 | ||
822 | static inline int | |
823 | rdev_get_et_sset_count(struct cfg80211_registered_device *rdev, | |
824 | struct net_device *dev, int sset) | |
825 | { | |
14e8a3c4 BL |
826 | int ret; |
827 | trace_rdev_get_et_sset_count(&rdev->wiphy, dev, sset); | |
828 | ret = rdev->ops->get_et_sset_count(&rdev->wiphy, dev, sset); | |
829 | trace_rdev_return_int(&rdev->wiphy, ret); | |
830 | return ret; | |
e35e4d28 HG |
831 | } |
832 | ||
833 | static inline void rdev_get_et_stats(struct cfg80211_registered_device *rdev, | |
834 | struct net_device *dev, | |
835 | struct ethtool_stats *stats, u64 *data) | |
836 | { | |
14e8a3c4 | 837 | trace_rdev_get_et_stats(&rdev->wiphy, dev); |
e35e4d28 | 838 | rdev->ops->get_et_stats(&rdev->wiphy, dev, stats, data); |
14e8a3c4 | 839 | trace_rdev_return_void(&rdev->wiphy); |
e35e4d28 HG |
840 | } |
841 | ||
842 | static inline void rdev_get_et_strings(struct cfg80211_registered_device *rdev, | |
843 | struct net_device *dev, u32 sset, | |
844 | u8 *data) | |
845 | { | |
14e8a3c4 | 846 | trace_rdev_get_et_strings(&rdev->wiphy, dev, sset); |
e35e4d28 | 847 | rdev->ops->get_et_strings(&rdev->wiphy, dev, sset, data); |
14e8a3c4 | 848 | trace_rdev_return_void(&rdev->wiphy); |
e35e4d28 HG |
849 | } |
850 | ||
851 | static inline struct ieee80211_channel | |
852 | *rdev_get_channel(struct cfg80211_registered_device *rdev, | |
853 | struct wireless_dev *wdev, enum nl80211_channel_type *type) | |
854 | { | |
14e8a3c4 BL |
855 | struct ieee80211_channel *ret; |
856 | trace_rdev_get_channel(&rdev->wiphy, wdev); | |
857 | ret = rdev->ops->get_channel(&rdev->wiphy, wdev, type); | |
858 | trace_rdev_return_channel(&rdev->wiphy, ret, *type); | |
859 | return ret; | |
e35e4d28 HG |
860 | } |
861 | ||
eeb126e9 JB |
862 | static inline int rdev_start_p2p_device(struct cfg80211_registered_device *rdev, |
863 | struct wireless_dev *wdev) | |
864 | { | |
865 | int ret; | |
866 | ||
867 | trace_rdev_start_p2p_device(&rdev->wiphy, wdev); | |
868 | ret = rdev->ops->start_p2p_device(&rdev->wiphy, wdev); | |
869 | trace_rdev_return_int(&rdev->wiphy, ret); | |
870 | return ret; | |
871 | } | |
872 | ||
873 | static inline void rdev_stop_p2p_device(struct cfg80211_registered_device *rdev, | |
874 | struct wireless_dev *wdev) | |
875 | { | |
876 | trace_rdev_stop_p2p_device(&rdev->wiphy, wdev); | |
877 | rdev->ops->stop_p2p_device(&rdev->wiphy, wdev); | |
878 | trace_rdev_return_void(&rdev->wiphy); | |
879 | } | |
e35e4d28 | 880 | #endif /* __CFG80211_RDEV_OPS */ |