6064b7b09e0142f719b1e744ee124267f8d61d1a
[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 int drv_tx(struct ieee80211_local *local, struct sk_buff *skb)
9 {
10         return local->ops->tx(&local->hw, skb);
11 }
12
13 static inline int drv_start(struct ieee80211_local *local)
14 {
15         int ret;
16
17         might_sleep();
18
19         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)
60 {
61         int ret;
62
63         might_sleep();
64
65         trace_drv_change_interface(local, sdata, type);
66         ret = local->ops->change_interface(&local->hw, &sdata->vif, type);
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_rts_threshold(struct ieee80211_local *local,
237                                         u32 value)
238 {
239         int ret = 0;
240
241         might_sleep();
242
243         trace_drv_set_rts_threshold(local, value);
244         if (local->ops->set_rts_threshold)
245                 ret = local->ops->set_rts_threshold(&local->hw, value);
246         trace_drv_return_int(local, ret);
247         return ret;
248 }
249
250 static inline int drv_set_coverage_class(struct ieee80211_local *local,
251                                          u8 value)
252 {
253         int ret = 0;
254         might_sleep();
255
256         trace_drv_set_coverage_class(local, value);
257         if (local->ops->set_coverage_class)
258                 local->ops->set_coverage_class(&local->hw, value);
259         else
260                 ret = -EOPNOTSUPP;
261
262         trace_drv_return_int(local, ret);
263         return ret;
264 }
265
266 static inline void drv_sta_notify(struct ieee80211_local *local,
267                                   struct ieee80211_sub_if_data *sdata,
268                                   enum sta_notify_cmd cmd,
269                                   struct ieee80211_sta *sta)
270 {
271         trace_drv_sta_notify(local, sdata, cmd, sta);
272         if (local->ops->sta_notify)
273                 local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta);
274         trace_drv_return_void(local);
275 }
276
277 static inline int drv_sta_add(struct ieee80211_local *local,
278                               struct ieee80211_sub_if_data *sdata,
279                               struct ieee80211_sta *sta)
280 {
281         int ret = 0;
282
283         might_sleep();
284
285         trace_drv_sta_add(local, sdata, sta);
286         if (local->ops->sta_add)
287                 ret = local->ops->sta_add(&local->hw, &sdata->vif, sta);
288
289         trace_drv_return_int(local, ret);
290
291         return ret;
292 }
293
294 static inline void drv_sta_remove(struct ieee80211_local *local,
295                                   struct ieee80211_sub_if_data *sdata,
296                                   struct ieee80211_sta *sta)
297 {
298         might_sleep();
299
300         trace_drv_sta_remove(local, sdata, sta);
301         if (local->ops->sta_remove)
302                 local->ops->sta_remove(&local->hw, &sdata->vif, sta);
303
304         trace_drv_return_void(local);
305 }
306
307 static inline int drv_conf_tx(struct ieee80211_local *local, u16 queue,
308                               const struct ieee80211_tx_queue_params *params)
309 {
310         int ret = -EOPNOTSUPP;
311
312         might_sleep();
313
314         trace_drv_conf_tx(local, queue, params);
315         if (local->ops->conf_tx)
316                 ret = local->ops->conf_tx(&local->hw, queue, params);
317         trace_drv_return_int(local, ret);
318         return ret;
319 }
320
321 static inline u64 drv_get_tsf(struct ieee80211_local *local)
322 {
323         u64 ret = -1ULL;
324
325         might_sleep();
326
327         trace_drv_get_tsf(local);
328         if (local->ops->get_tsf)
329                 ret = local->ops->get_tsf(&local->hw);
330         trace_drv_return_u64(local, ret);
331         return ret;
332 }
333
334 static inline void drv_set_tsf(struct ieee80211_local *local, u64 tsf)
335 {
336         might_sleep();
337
338         trace_drv_set_tsf(local, tsf);
339         if (local->ops->set_tsf)
340                 local->ops->set_tsf(&local->hw, tsf);
341         trace_drv_return_void(local);
342 }
343
344 static inline void drv_reset_tsf(struct ieee80211_local *local)
345 {
346         might_sleep();
347
348         trace_drv_reset_tsf(local);
349         if (local->ops->reset_tsf)
350                 local->ops->reset_tsf(&local->hw);
351         trace_drv_return_void(local);
352 }
353
354 static inline int drv_tx_last_beacon(struct ieee80211_local *local)
355 {
356         int ret = 1;
357
358         might_sleep();
359
360         trace_drv_tx_last_beacon(local);
361         if (local->ops->tx_last_beacon)
362                 ret = local->ops->tx_last_beacon(&local->hw);
363         trace_drv_return_int(local, ret);
364         return ret;
365 }
366
367 static inline int drv_ampdu_action(struct ieee80211_local *local,
368                                    struct ieee80211_sub_if_data *sdata,
369                                    enum ieee80211_ampdu_mlme_action action,
370                                    struct ieee80211_sta *sta, u16 tid,
371                                    u16 *ssn)
372 {
373         int ret = -EOPNOTSUPP;
374
375         might_sleep();
376
377         trace_drv_ampdu_action(local, sdata, action, sta, tid, ssn);
378
379         if (local->ops->ampdu_action)
380                 ret = local->ops->ampdu_action(&local->hw, &sdata->vif, action,
381                                                sta, tid, ssn);
382
383         trace_drv_return_int(local, ret);
384
385         return ret;
386 }
387
388 static inline int drv_get_survey(struct ieee80211_local *local, int idx,
389                                 struct survey_info *survey)
390 {
391         int ret = -EOPNOTSUPP;
392
393         trace_drv_get_survey(local, idx, survey);
394
395         if (local->ops->get_survey)
396                 ret = local->ops->get_survey(&local->hw, idx, survey);
397
398         trace_drv_return_int(local, ret);
399
400         return ret;
401 }
402
403 static inline void drv_rfkill_poll(struct ieee80211_local *local)
404 {
405         might_sleep();
406
407         if (local->ops->rfkill_poll)
408                 local->ops->rfkill_poll(&local->hw);
409 }
410
411 static inline void drv_flush(struct ieee80211_local *local, bool drop)
412 {
413         might_sleep();
414
415         trace_drv_flush(local, drop);
416         if (local->ops->flush)
417                 local->ops->flush(&local->hw, drop);
418         trace_drv_return_void(local);
419 }
420
421 static inline void drv_channel_switch(struct ieee80211_local *local,
422                                      struct ieee80211_channel_switch *ch_switch)
423 {
424         might_sleep();
425
426         trace_drv_channel_switch(local, ch_switch);
427         local->ops->channel_switch(&local->hw, ch_switch);
428         trace_drv_return_void(local);
429 }
430
431 #endif /* __MAC80211_DRIVER_OPS */