mac80211: implement support for cfg80211_ops->{get,set}_ringparam
[linux-2.6.git] / net / mac80211 / driver-ops.h
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 void drv_tx(struct ieee80211_local *local, struct sk_buff *skb)
9 {
10         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         trace_drv_start(local);
20         local->started = true;
21         smp_mb();
22         ret = local->ops->start(&local->hw);
23         trace_drv_return_int(local, ret);
24         return ret;
25 }
26
27 static inline void drv_stop(struct ieee80211_local *local)
28 {
29         might_sleep();
30
31         trace_drv_stop(local);
32         local->ops->stop(&local->hw);
33         trace_drv_return_void(local);
34
35         /* sync away all work on the tasklet before clearing started */
36         tasklet_disable(&local->tasklet);
37         tasklet_enable(&local->tasklet);
38
39         barrier();
40
41         local->started = false;
42 }
43
44 static inline int drv_add_interface(struct ieee80211_local *local,
45                                     struct ieee80211_vif *vif)
46 {
47         int ret;
48
49         might_sleep();
50
51         trace_drv_add_interface(local, vif_to_sdata(vif));
52         ret = local->ops->add_interface(&local->hw, vif);
53         trace_drv_return_int(local, ret);
54         return ret;
55 }
56
57 static inline int drv_change_interface(struct ieee80211_local *local,
58                                        struct ieee80211_sub_if_data *sdata,
59                                        enum nl80211_iftype type, bool p2p)
60 {
61         int ret;
62
63         might_sleep();
64
65         trace_drv_change_interface(local, sdata, type, p2p);
66         ret = local->ops->change_interface(&local->hw, &sdata->vif, type, p2p);
67         trace_drv_return_int(local, ret);
68         return ret;
69 }
70
71 static inline void drv_remove_interface(struct ieee80211_local *local,
72                                         struct ieee80211_vif *vif)
73 {
74         might_sleep();
75
76         trace_drv_remove_interface(local, vif_to_sdata(vif));
77         local->ops->remove_interface(&local->hw, vif);
78         trace_drv_return_void(local);
79 }
80
81 static inline int drv_config(struct ieee80211_local *local, u32 changed)
82 {
83         int ret;
84
85         might_sleep();
86
87         trace_drv_config(local, changed);
88         ret = local->ops->config(&local->hw, changed);
89         trace_drv_return_int(local, ret);
90         return ret;
91 }
92
93 static inline void drv_bss_info_changed(struct ieee80211_local *local,
94                                         struct ieee80211_sub_if_data *sdata,
95                                         struct ieee80211_bss_conf *info,
96                                         u32 changed)
97 {
98         might_sleep();
99
100         trace_drv_bss_info_changed(local, sdata, info, changed);
101         if (local->ops->bss_info_changed)
102                 local->ops->bss_info_changed(&local->hw, &sdata->vif, info, changed);
103         trace_drv_return_void(local);
104 }
105
106 static inline u64 drv_prepare_multicast(struct ieee80211_local *local,
107                                         struct netdev_hw_addr_list *mc_list)
108 {
109         u64 ret = 0;
110
111         trace_drv_prepare_multicast(local, mc_list->count);
112
113         if (local->ops->prepare_multicast)
114                 ret = local->ops->prepare_multicast(&local->hw, mc_list);
115
116         trace_drv_return_u64(local, ret);
117
118         return ret;
119 }
120
121 static inline void drv_configure_filter(struct ieee80211_local *local,
122                                         unsigned int changed_flags,
123                                         unsigned int *total_flags,
124                                         u64 multicast)
125 {
126         might_sleep();
127
128         trace_drv_configure_filter(local, changed_flags, total_flags,
129                                    multicast);
130         local->ops->configure_filter(&local->hw, changed_flags, total_flags,
131                                      multicast);
132         trace_drv_return_void(local);
133 }
134
135 static inline int drv_set_tim(struct ieee80211_local *local,
136                               struct ieee80211_sta *sta, bool set)
137 {
138         int ret = 0;
139         trace_drv_set_tim(local, sta, set);
140         if (local->ops->set_tim)
141                 ret = local->ops->set_tim(&local->hw, sta, set);
142         trace_drv_return_int(local, ret);
143         return ret;
144 }
145
146 static inline int drv_set_key(struct ieee80211_local *local,
147                               enum set_key_cmd cmd,
148                               struct ieee80211_sub_if_data *sdata,
149                               struct ieee80211_sta *sta,
150                               struct ieee80211_key_conf *key)
151 {
152         int ret;
153
154         might_sleep();
155
156         trace_drv_set_key(local, cmd, sdata, sta, key);
157         ret = local->ops->set_key(&local->hw, cmd, &sdata->vif, sta, key);
158         trace_drv_return_int(local, ret);
159         return ret;
160 }
161
162 static inline void drv_update_tkip_key(struct ieee80211_local *local,
163                                        struct ieee80211_sub_if_data *sdata,
164                                        struct ieee80211_key_conf *conf,
165                                        struct sta_info *sta, u32 iv32,
166                                        u16 *phase1key)
167 {
168         struct ieee80211_sta *ista = NULL;
169
170         if (sta)
171                 ista = &sta->sta;
172
173         trace_drv_update_tkip_key(local, sdata, conf, ista, iv32);
174         if (local->ops->update_tkip_key)
175                 local->ops->update_tkip_key(&local->hw, &sdata->vif, conf,
176                                             ista, iv32, phase1key);
177         trace_drv_return_void(local);
178 }
179
180 static inline int drv_hw_scan(struct ieee80211_local *local,
181                               struct ieee80211_sub_if_data *sdata,
182                               struct cfg80211_scan_request *req)
183 {
184         int ret;
185
186         might_sleep();
187
188         trace_drv_hw_scan(local, sdata, req);
189         ret = local->ops->hw_scan(&local->hw, &sdata->vif, req);
190         trace_drv_return_int(local, ret);
191         return ret;
192 }
193
194 static inline void drv_sw_scan_start(struct ieee80211_local *local)
195 {
196         might_sleep();
197
198         trace_drv_sw_scan_start(local);
199         if (local->ops->sw_scan_start)
200                 local->ops->sw_scan_start(&local->hw);
201         trace_drv_return_void(local);
202 }
203
204 static inline void drv_sw_scan_complete(struct ieee80211_local *local)
205 {
206         might_sleep();
207
208         trace_drv_sw_scan_complete(local);
209         if (local->ops->sw_scan_complete)
210                 local->ops->sw_scan_complete(&local->hw);
211         trace_drv_return_void(local);
212 }
213
214 static inline int drv_get_stats(struct ieee80211_local *local,
215                                 struct ieee80211_low_level_stats *stats)
216 {
217         int ret = -EOPNOTSUPP;
218
219         might_sleep();
220
221         if (local->ops->get_stats)
222                 ret = local->ops->get_stats(&local->hw, stats);
223         trace_drv_get_stats(local, stats, ret);
224
225         return ret;
226 }
227
228 static inline void drv_get_tkip_seq(struct ieee80211_local *local,
229                                     u8 hw_key_idx, u32 *iv32, u16 *iv16)
230 {
231         if (local->ops->get_tkip_seq)
232                 local->ops->get_tkip_seq(&local->hw, hw_key_idx, iv32, iv16);
233         trace_drv_get_tkip_seq(local, hw_key_idx, iv32, iv16);
234 }
235
236 static inline int drv_set_frag_threshold(struct ieee80211_local *local,
237                                         u32 value)
238 {
239         int ret = 0;
240
241         might_sleep();
242
243         trace_drv_set_frag_threshold(local, value);
244         if (local->ops->set_frag_threshold)
245                 ret = local->ops->set_frag_threshold(&local->hw, value);
246         trace_drv_return_int(local, ret);
247         return ret;
248 }
249
250 static inline int drv_set_rts_threshold(struct ieee80211_local *local,
251                                         u32 value)
252 {
253         int ret = 0;
254
255         might_sleep();
256
257         trace_drv_set_rts_threshold(local, value);
258         if (local->ops->set_rts_threshold)
259                 ret = local->ops->set_rts_threshold(&local->hw, value);
260         trace_drv_return_int(local, ret);
261         return ret;
262 }
263
264 static inline int drv_set_coverage_class(struct ieee80211_local *local,
265                                          u8 value)
266 {
267         int ret = 0;
268         might_sleep();
269
270         trace_drv_set_coverage_class(local, value);
271         if (local->ops->set_coverage_class)
272                 local->ops->set_coverage_class(&local->hw, value);
273         else
274                 ret = -EOPNOTSUPP;
275
276         trace_drv_return_int(local, ret);
277         return ret;
278 }
279
280 static inline void drv_sta_notify(struct ieee80211_local *local,
281                                   struct ieee80211_sub_if_data *sdata,
282                                   enum sta_notify_cmd cmd,
283                                   struct ieee80211_sta *sta)
284 {
285         trace_drv_sta_notify(local, sdata, cmd, sta);
286         if (local->ops->sta_notify)
287                 local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta);
288         trace_drv_return_void(local);
289 }
290
291 static inline int drv_sta_add(struct ieee80211_local *local,
292                               struct ieee80211_sub_if_data *sdata,
293                               struct ieee80211_sta *sta)
294 {
295         int ret = 0;
296
297         might_sleep();
298
299         trace_drv_sta_add(local, sdata, sta);
300         if (local->ops->sta_add)
301                 ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
302
303         trace_drv_return_int(local, ret);
304
305         return ret;
306 }
307
308 static inline void drv_sta_remove(struct ieee80211_local *local,
309                                   struct ieee80211_sub_if_data *sdata,
310                                   struct ieee80211_sta *sta)
311 {
312         might_sleep();
313
314         trace_drv_sta_remove(local, sdata, sta);
315         if (local->ops->sta_remove)
316                 local->ops->sta_remove(&local->hw, &sdata->vif, sta);
317
318         trace_drv_return_void(local);
319 }
320
321 static inline int drv_conf_tx(struct ieee80211_local *local, u16 queue,
322                               const struct ieee80211_tx_queue_params *params)
323 {
324         int ret = -EOPNOTSUPP;
325
326         might_sleep();
327
328         trace_drv_conf_tx(local, queue, params);
329         if (local->ops->conf_tx)
330                 ret = local->ops->conf_tx(&local->hw, queue, params);
331         trace_drv_return_int(local, ret);
332         return ret;
333 }
334
335 static inline u64 drv_get_tsf(struct ieee80211_local *local)
336 {
337         u64 ret = -1ULL;
338
339         might_sleep();
340
341         trace_drv_get_tsf(local);
342         if (local->ops->get_tsf)
343                 ret = local->ops->get_tsf(&local->hw);
344         trace_drv_return_u64(local, ret);
345         return ret;
346 }
347
348 static inline void drv_set_tsf(struct ieee80211_local *local, u64 tsf)
349 {
350         might_sleep();
351
352         trace_drv_set_tsf(local, tsf);
353         if (local->ops->set_tsf)
354                 local->ops->set_tsf(&local->hw, tsf);
355         trace_drv_return_void(local);
356 }
357
358 static inline void drv_reset_tsf(struct ieee80211_local *local)
359 {
360         might_sleep();
361
362         trace_drv_reset_tsf(local);
363         if (local->ops->reset_tsf)
364                 local->ops->reset_tsf(&local->hw);
365         trace_drv_return_void(local);
366 }
367
368 static inline int drv_tx_last_beacon(struct ieee80211_local *local)
369 {
370         int ret = 0; /* default unsuported op for less congestion */
371
372         might_sleep();
373
374         trace_drv_tx_last_beacon(local);
375         if (local->ops->tx_last_beacon)
376                 ret = local->ops->tx_last_beacon(&local->hw);
377         trace_drv_return_int(local, ret);
378         return ret;
379 }
380
381 static inline int drv_ampdu_action(struct ieee80211_local *local,
382                                    struct ieee80211_sub_if_data *sdata,
383                                    enum ieee80211_ampdu_mlme_action action,
384                                    struct ieee80211_sta *sta, u16 tid,
385                                    u16 *ssn, u8 buf_size)
386 {
387         int ret = -EOPNOTSUPP;
388
389         might_sleep();
390
391         trace_drv_ampdu_action(local, sdata, action, sta, tid, ssn, buf_size);
392
393         if (local->ops->ampdu_action)
394                 ret = local->ops->ampdu_action(&local->hw, &sdata->vif, action,
395                                                sta, tid, ssn, buf_size);
396
397         trace_drv_return_int(local, ret);
398
399         return ret;
400 }
401
402 static inline int drv_get_survey(struct ieee80211_local *local, int idx,
403                                 struct survey_info *survey)
404 {
405         int ret = -EOPNOTSUPP;
406
407         trace_drv_get_survey(local, idx, survey);
408
409         if (local->ops->get_survey)
410                 ret = local->ops->get_survey(&local->hw, idx, survey);
411
412         trace_drv_return_int(local, ret);
413
414         return ret;
415 }
416
417 static inline void drv_rfkill_poll(struct ieee80211_local *local)
418 {
419         might_sleep();
420
421         if (local->ops->rfkill_poll)
422                 local->ops->rfkill_poll(&local->hw);
423 }
424
425 static inline void drv_flush(struct ieee80211_local *local, bool drop)
426 {
427         might_sleep();
428
429         trace_drv_flush(local, drop);
430         if (local->ops->flush)
431                 local->ops->flush(&local->hw, drop);
432         trace_drv_return_void(local);
433 }
434
435 static inline void drv_channel_switch(struct ieee80211_local *local,
436                                      struct ieee80211_channel_switch *ch_switch)
437 {
438         might_sleep();
439
440         trace_drv_channel_switch(local, ch_switch);
441         local->ops->channel_switch(&local->hw, ch_switch);
442         trace_drv_return_void(local);
443 }
444
445
446 static inline int drv_set_antenna(struct ieee80211_local *local,
447                                   u32 tx_ant, u32 rx_ant)
448 {
449         int ret = -EOPNOTSUPP;
450         might_sleep();
451         if (local->ops->set_antenna)
452                 ret = local->ops->set_antenna(&local->hw, tx_ant, rx_ant);
453         trace_drv_set_antenna(local, tx_ant, rx_ant, ret);
454         return ret;
455 }
456
457 static inline int drv_get_antenna(struct ieee80211_local *local,
458                                   u32 *tx_ant, u32 *rx_ant)
459 {
460         int ret = -EOPNOTSUPP;
461         might_sleep();
462         if (local->ops->get_antenna)
463                 ret = local->ops->get_antenna(&local->hw, tx_ant, rx_ant);
464         trace_drv_get_antenna(local, *tx_ant, *rx_ant, ret);
465         return ret;
466 }
467
468 static inline int drv_remain_on_channel(struct ieee80211_local *local,
469                                         struct ieee80211_channel *chan,
470                                         enum nl80211_channel_type chantype,
471                                         unsigned int duration)
472 {
473         int ret;
474
475         might_sleep();
476
477         trace_drv_remain_on_channel(local, chan, chantype, duration);
478         ret = local->ops->remain_on_channel(&local->hw, chan, chantype,
479                                             duration);
480         trace_drv_return_int(local, ret);
481
482         return ret;
483 }
484
485 static inline int drv_cancel_remain_on_channel(struct ieee80211_local *local)
486 {
487         int ret;
488
489         might_sleep();
490
491         trace_drv_cancel_remain_on_channel(local);
492         ret = local->ops->cancel_remain_on_channel(&local->hw);
493         trace_drv_return_int(local, ret);
494
495         return ret;
496 }
497
498 static inline int drv_offchannel_tx(struct ieee80211_local *local,
499                                     struct sk_buff *skb,
500                                     struct ieee80211_channel *chan,
501                                     enum nl80211_channel_type channel_type,
502                                     unsigned int wait)
503 {
504         int ret;
505
506         might_sleep();
507
508         trace_drv_offchannel_tx(local, skb, chan, channel_type, wait);
509         ret = local->ops->offchannel_tx(&local->hw, skb, chan,
510                                         channel_type, wait);
511         trace_drv_return_int(local, ret);
512
513         return ret;
514 }
515
516 static inline int drv_offchannel_tx_cancel_wait(struct ieee80211_local *local)
517 {
518         int ret;
519
520         might_sleep();
521
522         trace_drv_offchannel_tx_cancel_wait(local);
523         ret = local->ops->offchannel_tx_cancel_wait(&local->hw);
524         trace_drv_return_int(local, ret);
525
526         return ret;
527 }
528
529 static inline int drv_set_ringparam(struct ieee80211_local *local,
530                                     u32 tx, u32 rx)
531 {
532         int ret = -ENOTSUPP;
533
534         might_sleep();
535
536         trace_drv_set_ringparam(local, tx, rx);
537         if (local->ops->set_ringparam)
538                 ret = local->ops->set_ringparam(&local->hw, tx, rx);
539         trace_drv_return_int(local, ret);
540
541         return ret;
542 }
543
544 static inline void drv_get_ringparam(struct ieee80211_local *local,
545                                      u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max)
546 {
547         might_sleep();
548
549         trace_drv_get_ringparam(local, tx, tx_max, rx, rx_max);
550         if (local->ops->get_ringparam)
551                 local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max);
552         trace_drv_return_void(local);
553 }
554
555 #endif /* __MAC80211_DRIVER_OPS */