Root/
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 check_sdata_in_driver(struct ieee80211_sub_if_data *sdata) |
9 | { |
10 | WARN_ON(!(sdata->flags & IEEE80211_SDATA_IN_DRIVER)); |
11 | } |
12 | |
13 | static inline struct ieee80211_sub_if_data * |
14 | get_bss_sdata(struct ieee80211_sub_if_data *sdata) |
15 | { |
16 | if (sdata->vif.type == NL80211_IFTYPE_AP_VLAN) |
17 | sdata = container_of(sdata->bss, struct ieee80211_sub_if_data, |
18 | u.ap); |
19 | |
20 | return sdata; |
21 | } |
22 | |
23 | static inline void drv_tx(struct ieee80211_local *local, struct sk_buff *skb) |
24 | { |
25 | local->ops->tx(&local->hw, skb); |
26 | } |
27 | |
28 | static inline void drv_tx_frags(struct ieee80211_local *local, |
29 | struct ieee80211_vif *vif, |
30 | struct ieee80211_sta *sta, |
31 | struct sk_buff_head *skbs) |
32 | { |
33 | local->ops->tx_frags(&local->hw, vif, sta, skbs); |
34 | } |
35 | |
36 | static inline int drv_start(struct ieee80211_local *local) |
37 | { |
38 | int ret; |
39 | |
40 | might_sleep(); |
41 | |
42 | trace_drv_start(local); |
43 | local->started = true; |
44 | smp_mb(); |
45 | ret = local->ops->start(&local->hw); |
46 | trace_drv_return_int(local, ret); |
47 | return ret; |
48 | } |
49 | |
50 | static inline void drv_stop(struct ieee80211_local *local) |
51 | { |
52 | might_sleep(); |
53 | |
54 | trace_drv_stop(local); |
55 | local->ops->stop(&local->hw); |
56 | trace_drv_return_void(local); |
57 | |
58 | /* sync away all work on the tasklet before clearing started */ |
59 | tasklet_disable(&local->tasklet); |
60 | tasklet_enable(&local->tasklet); |
61 | |
62 | barrier(); |
63 | |
64 | local->started = false; |
65 | } |
66 | |
67 | #ifdef CONFIG_PM |
68 | static inline int drv_suspend(struct ieee80211_local *local, |
69 | struct cfg80211_wowlan *wowlan) |
70 | { |
71 | int ret; |
72 | |
73 | might_sleep(); |
74 | |
75 | trace_drv_suspend(local); |
76 | ret = local->ops->suspend(&local->hw, wowlan); |
77 | trace_drv_return_int(local, ret); |
78 | return ret; |
79 | } |
80 | |
81 | static inline int drv_resume(struct ieee80211_local *local) |
82 | { |
83 | int ret; |
84 | |
85 | might_sleep(); |
86 | |
87 | trace_drv_resume(local); |
88 | ret = local->ops->resume(&local->hw); |
89 | trace_drv_return_int(local, ret); |
90 | return ret; |
91 | } |
92 | #endif |
93 | |
94 | static inline int drv_add_interface(struct ieee80211_local *local, |
95 | struct ieee80211_sub_if_data *sdata) |
96 | { |
97 | int ret; |
98 | |
99 | might_sleep(); |
100 | |
101 | if (WARN_ON(sdata->vif.type == NL80211_IFTYPE_AP_VLAN || |
102 | sdata->vif.type == NL80211_IFTYPE_MONITOR)) |
103 | return -EINVAL; |
104 | |
105 | trace_drv_add_interface(local, sdata); |
106 | ret = local->ops->add_interface(&local->hw, &sdata->vif); |
107 | trace_drv_return_int(local, ret); |
108 | |
109 | if (ret == 0) |
110 | sdata->flags |= IEEE80211_SDATA_IN_DRIVER; |
111 | |
112 | return ret; |
113 | } |
114 | |
115 | static inline int drv_change_interface(struct ieee80211_local *local, |
116 | struct ieee80211_sub_if_data *sdata, |
117 | enum nl80211_iftype type, bool p2p) |
118 | { |
119 | int ret; |
120 | |
121 | might_sleep(); |
122 | |
123 | check_sdata_in_driver(sdata); |
124 | |
125 | trace_drv_change_interface(local, sdata, type, p2p); |
126 | ret = local->ops->change_interface(&local->hw, &sdata->vif, type, p2p); |
127 | trace_drv_return_int(local, ret); |
128 | return ret; |
129 | } |
130 | |
131 | static inline void drv_remove_interface(struct ieee80211_local *local, |
132 | struct ieee80211_sub_if_data *sdata) |
133 | { |
134 | might_sleep(); |
135 | |
136 | check_sdata_in_driver(sdata); |
137 | |
138 | trace_drv_remove_interface(local, sdata); |
139 | local->ops->remove_interface(&local->hw, &sdata->vif); |
140 | sdata->flags &= ~IEEE80211_SDATA_IN_DRIVER; |
141 | trace_drv_return_void(local); |
142 | } |
143 | |
144 | static inline int drv_config(struct ieee80211_local *local, u32 changed) |
145 | { |
146 | int ret; |
147 | |
148 | might_sleep(); |
149 | |
150 | trace_drv_config(local, changed); |
151 | ret = local->ops->config(&local->hw, changed); |
152 | trace_drv_return_int(local, ret); |
153 | return ret; |
154 | } |
155 | |
156 | static inline void drv_bss_info_changed(struct ieee80211_local *local, |
157 | struct ieee80211_sub_if_data *sdata, |
158 | struct ieee80211_bss_conf *info, |
159 | u32 changed) |
160 | { |
161 | might_sleep(); |
162 | |
163 | check_sdata_in_driver(sdata); |
164 | |
165 | trace_drv_bss_info_changed(local, sdata, info, changed); |
166 | if (local->ops->bss_info_changed) |
167 | local->ops->bss_info_changed(&local->hw, &sdata->vif, info, changed); |
168 | trace_drv_return_void(local); |
169 | } |
170 | |
171 | static inline u64 drv_prepare_multicast(struct ieee80211_local *local, |
172 | struct netdev_hw_addr_list *mc_list) |
173 | { |
174 | u64 ret = 0; |
175 | |
176 | trace_drv_prepare_multicast(local, mc_list->count); |
177 | |
178 | if (local->ops->prepare_multicast) |
179 | ret = local->ops->prepare_multicast(&local->hw, mc_list); |
180 | |
181 | trace_drv_return_u64(local, ret); |
182 | |
183 | return ret; |
184 | } |
185 | |
186 | static inline void drv_configure_filter(struct ieee80211_local *local, |
187 | unsigned int changed_flags, |
188 | unsigned int *total_flags, |
189 | u64 multicast) |
190 | { |
191 | might_sleep(); |
192 | |
193 | trace_drv_configure_filter(local, changed_flags, total_flags, |
194 | multicast); |
195 | local->ops->configure_filter(&local->hw, changed_flags, total_flags, |
196 | multicast); |
197 | trace_drv_return_void(local); |
198 | } |
199 | |
200 | static inline int drv_set_tim(struct ieee80211_local *local, |
201 | struct ieee80211_sta *sta, bool set) |
202 | { |
203 | int ret = 0; |
204 | trace_drv_set_tim(local, sta, set); |
205 | if (local->ops->set_tim) |
206 | ret = local->ops->set_tim(&local->hw, sta, set); |
207 | trace_drv_return_int(local, ret); |
208 | return ret; |
209 | } |
210 | |
211 | static inline int drv_set_key(struct ieee80211_local *local, |
212 | enum set_key_cmd cmd, |
213 | struct ieee80211_sub_if_data *sdata, |
214 | struct ieee80211_sta *sta, |
215 | struct ieee80211_key_conf *key) |
216 | { |
217 | int ret; |
218 | |
219 | might_sleep(); |
220 | |
221 | sdata = get_bss_sdata(sdata); |
222 | check_sdata_in_driver(sdata); |
223 | |
224 | trace_drv_set_key(local, cmd, sdata, sta, key); |
225 | ret = local->ops->set_key(&local->hw, cmd, &sdata->vif, sta, key); |
226 | trace_drv_return_int(local, ret); |
227 | return ret; |
228 | } |
229 | |
230 | static inline void drv_update_tkip_key(struct ieee80211_local *local, |
231 | struct ieee80211_sub_if_data *sdata, |
232 | struct ieee80211_key_conf *conf, |
233 | struct sta_info *sta, u32 iv32, |
234 | u16 *phase1key) |
235 | { |
236 | struct ieee80211_sta *ista = NULL; |
237 | |
238 | if (sta) |
239 | ista = &sta->sta; |
240 | |
241 | sdata = get_bss_sdata(sdata); |
242 | check_sdata_in_driver(sdata); |
243 | |
244 | trace_drv_update_tkip_key(local, sdata, conf, ista, iv32); |
245 | if (local->ops->update_tkip_key) |
246 | local->ops->update_tkip_key(&local->hw, &sdata->vif, conf, |
247 | ista, iv32, phase1key); |
248 | trace_drv_return_void(local); |
249 | } |
250 | |
251 | static inline int drv_hw_scan(struct ieee80211_local *local, |
252 | struct ieee80211_sub_if_data *sdata, |
253 | struct cfg80211_scan_request *req) |
254 | { |
255 | int ret; |
256 | |
257 | might_sleep(); |
258 | |
259 | check_sdata_in_driver(sdata); |
260 | |
261 | trace_drv_hw_scan(local, sdata); |
262 | ret = local->ops->hw_scan(&local->hw, &sdata->vif, req); |
263 | trace_drv_return_int(local, ret); |
264 | return ret; |
265 | } |
266 | |
267 | static inline void drv_cancel_hw_scan(struct ieee80211_local *local, |
268 | struct ieee80211_sub_if_data *sdata) |
269 | { |
270 | might_sleep(); |
271 | |
272 | check_sdata_in_driver(sdata); |
273 | |
274 | trace_drv_cancel_hw_scan(local, sdata); |
275 | local->ops->cancel_hw_scan(&local->hw, &sdata->vif); |
276 | trace_drv_return_void(local); |
277 | } |
278 | |
279 | static inline int |
280 | drv_sched_scan_start(struct ieee80211_local *local, |
281 | struct ieee80211_sub_if_data *sdata, |
282 | struct cfg80211_sched_scan_request *req, |
283 | struct ieee80211_sched_scan_ies *ies) |
284 | { |
285 | int ret; |
286 | |
287 | might_sleep(); |
288 | |
289 | check_sdata_in_driver(sdata); |
290 | |
291 | trace_drv_sched_scan_start(local, sdata); |
292 | ret = local->ops->sched_scan_start(&local->hw, &sdata->vif, |
293 | req, ies); |
294 | trace_drv_return_int(local, ret); |
295 | return ret; |
296 | } |
297 | |
298 | static inline void drv_sched_scan_stop(struct ieee80211_local *local, |
299 | struct ieee80211_sub_if_data *sdata) |
300 | { |
301 | might_sleep(); |
302 | |
303 | check_sdata_in_driver(sdata); |
304 | |
305 | trace_drv_sched_scan_stop(local, sdata); |
306 | local->ops->sched_scan_stop(&local->hw, &sdata->vif); |
307 | trace_drv_return_void(local); |
308 | } |
309 | |
310 | static inline void drv_sw_scan_start(struct ieee80211_local *local) |
311 | { |
312 | might_sleep(); |
313 | |
314 | trace_drv_sw_scan_start(local); |
315 | if (local->ops->sw_scan_start) |
316 | local->ops->sw_scan_start(&local->hw); |
317 | trace_drv_return_void(local); |
318 | } |
319 | |
320 | static inline void drv_sw_scan_complete(struct ieee80211_local *local) |
321 | { |
322 | might_sleep(); |
323 | |
324 | trace_drv_sw_scan_complete(local); |
325 | if (local->ops->sw_scan_complete) |
326 | local->ops->sw_scan_complete(&local->hw); |
327 | trace_drv_return_void(local); |
328 | } |
329 | |
330 | static inline int drv_get_stats(struct ieee80211_local *local, |
331 | struct ieee80211_low_level_stats *stats) |
332 | { |
333 | int ret = -EOPNOTSUPP; |
334 | |
335 | might_sleep(); |
336 | |
337 | if (local->ops->get_stats) |
338 | ret = local->ops->get_stats(&local->hw, stats); |
339 | trace_drv_get_stats(local, stats, ret); |
340 | |
341 | return ret; |
342 | } |
343 | |
344 | static inline void drv_get_tkip_seq(struct ieee80211_local *local, |
345 | u8 hw_key_idx, u32 *iv32, u16 *iv16) |
346 | { |
347 | if (local->ops->get_tkip_seq) |
348 | local->ops->get_tkip_seq(&local->hw, hw_key_idx, iv32, iv16); |
349 | trace_drv_get_tkip_seq(local, hw_key_idx, iv32, iv16); |
350 | } |
351 | |
352 | static inline int drv_set_frag_threshold(struct ieee80211_local *local, |
353 | u32 value) |
354 | { |
355 | int ret = 0; |
356 | |
357 | might_sleep(); |
358 | |
359 | trace_drv_set_frag_threshold(local, value); |
360 | if (local->ops->set_frag_threshold) |
361 | ret = local->ops->set_frag_threshold(&local->hw, value); |
362 | trace_drv_return_int(local, ret); |
363 | return ret; |
364 | } |
365 | |
366 | static inline int drv_set_rts_threshold(struct ieee80211_local *local, |
367 | u32 value) |
368 | { |
369 | int ret = 0; |
370 | |
371 | might_sleep(); |
372 | |
373 | trace_drv_set_rts_threshold(local, value); |
374 | if (local->ops->set_rts_threshold) |
375 | ret = local->ops->set_rts_threshold(&local->hw, value); |
376 | trace_drv_return_int(local, ret); |
377 | return ret; |
378 | } |
379 | |
380 | static inline int drv_set_coverage_class(struct ieee80211_local *local, |
381 | u8 value) |
382 | { |
383 | int ret = 0; |
384 | might_sleep(); |
385 | |
386 | trace_drv_set_coverage_class(local, value); |
387 | if (local->ops->set_coverage_class) |
388 | local->ops->set_coverage_class(&local->hw, value); |
389 | else |
390 | ret = -EOPNOTSUPP; |
391 | |
392 | trace_drv_return_int(local, ret); |
393 | return ret; |
394 | } |
395 | |
396 | static inline void drv_sta_notify(struct ieee80211_local *local, |
397 | struct ieee80211_sub_if_data *sdata, |
398 | enum sta_notify_cmd cmd, |
399 | struct ieee80211_sta *sta) |
400 | { |
401 | sdata = get_bss_sdata(sdata); |
402 | check_sdata_in_driver(sdata); |
403 | |
404 | trace_drv_sta_notify(local, sdata, cmd, sta); |
405 | if (local->ops->sta_notify) |
406 | local->ops->sta_notify(&local->hw, &sdata->vif, cmd, sta); |
407 | trace_drv_return_void(local); |
408 | } |
409 | |
410 | static inline int drv_sta_add(struct ieee80211_local *local, |
411 | struct ieee80211_sub_if_data *sdata, |
412 | struct ieee80211_sta *sta) |
413 | { |
414 | int ret = 0; |
415 | |
416 | might_sleep(); |
417 | |
418 | sdata = get_bss_sdata(sdata); |
419 | check_sdata_in_driver(sdata); |
420 | |
421 | trace_drv_sta_add(local, sdata, sta); |
422 | if (local->ops->sta_add) |
423 | ret = local->ops->sta_add(&local->hw, &sdata->vif, sta); |
424 | |
425 | trace_drv_return_int(local, ret); |
426 | |
427 | return ret; |
428 | } |
429 | |
430 | static inline void drv_sta_remove(struct ieee80211_local *local, |
431 | struct ieee80211_sub_if_data *sdata, |
432 | struct ieee80211_sta *sta) |
433 | { |
434 | might_sleep(); |
435 | |
436 | sdata = get_bss_sdata(sdata); |
437 | check_sdata_in_driver(sdata); |
438 | |
439 | trace_drv_sta_remove(local, sdata, sta); |
440 | if (local->ops->sta_remove) |
441 | local->ops->sta_remove(&local->hw, &sdata->vif, sta); |
442 | |
443 | trace_drv_return_void(local); |
444 | } |
445 | |
446 | static inline __must_check |
447 | int drv_sta_state(struct ieee80211_local *local, |
448 | struct ieee80211_sub_if_data *sdata, |
449 | struct sta_info *sta, |
450 | enum ieee80211_sta_state old_state, |
451 | enum ieee80211_sta_state new_state) |
452 | { |
453 | int ret = 0; |
454 | |
455 | might_sleep(); |
456 | |
457 | sdata = get_bss_sdata(sdata); |
458 | check_sdata_in_driver(sdata); |
459 | |
460 | trace_drv_sta_state(local, sdata, &sta->sta, old_state, new_state); |
461 | if (local->ops->sta_state) { |
462 | ret = local->ops->sta_state(&local->hw, &sdata->vif, &sta->sta, |
463 | old_state, new_state); |
464 | } else if (old_state == IEEE80211_STA_AUTH && |
465 | new_state == IEEE80211_STA_ASSOC) { |
466 | ret = drv_sta_add(local, sdata, &sta->sta); |
467 | if (ret == 0) |
468 | sta->uploaded = true; |
469 | } else if (old_state == IEEE80211_STA_ASSOC && |
470 | new_state == IEEE80211_STA_AUTH) { |
471 | drv_sta_remove(local, sdata, &sta->sta); |
472 | } |
473 | trace_drv_return_int(local, ret); |
474 | return ret; |
475 | } |
476 | |
477 | static inline int drv_conf_tx(struct ieee80211_local *local, |
478 | struct ieee80211_sub_if_data *sdata, u16 queue, |
479 | const struct ieee80211_tx_queue_params *params) |
480 | { |
481 | int ret = -EOPNOTSUPP; |
482 | |
483 | might_sleep(); |
484 | |
485 | check_sdata_in_driver(sdata); |
486 | |
487 | trace_drv_conf_tx(local, sdata, queue, params); |
488 | if (local->ops->conf_tx) |
489 | ret = local->ops->conf_tx(&local->hw, &sdata->vif, |
490 | queue, params); |
491 | trace_drv_return_int(local, ret); |
492 | return ret; |
493 | } |
494 | |
495 | static inline u64 drv_get_tsf(struct ieee80211_local *local, |
496 | struct ieee80211_sub_if_data *sdata) |
497 | { |
498 | u64 ret = -1ULL; |
499 | |
500 | might_sleep(); |
501 | |
502 | check_sdata_in_driver(sdata); |
503 | |
504 | trace_drv_get_tsf(local, sdata); |
505 | if (local->ops->get_tsf) |
506 | ret = local->ops->get_tsf(&local->hw, &sdata->vif); |
507 | trace_drv_return_u64(local, ret); |
508 | return ret; |
509 | } |
510 | |
511 | static inline void drv_set_tsf(struct ieee80211_local *local, |
512 | struct ieee80211_sub_if_data *sdata, |
513 | u64 tsf) |
514 | { |
515 | might_sleep(); |
516 | |
517 | check_sdata_in_driver(sdata); |
518 | |
519 | trace_drv_set_tsf(local, sdata, tsf); |
520 | if (local->ops->set_tsf) |
521 | local->ops->set_tsf(&local->hw, &sdata->vif, tsf); |
522 | trace_drv_return_void(local); |
523 | } |
524 | |
525 | static inline void drv_reset_tsf(struct ieee80211_local *local, |
526 | struct ieee80211_sub_if_data *sdata) |
527 | { |
528 | might_sleep(); |
529 | |
530 | check_sdata_in_driver(sdata); |
531 | |
532 | trace_drv_reset_tsf(local, sdata); |
533 | if (local->ops->reset_tsf) |
534 | local->ops->reset_tsf(&local->hw, &sdata->vif); |
535 | trace_drv_return_void(local); |
536 | } |
537 | |
538 | static inline int drv_tx_last_beacon(struct ieee80211_local *local) |
539 | { |
540 | int ret = 0; /* default unsuported op for less congestion */ |
541 | |
542 | might_sleep(); |
543 | |
544 | trace_drv_tx_last_beacon(local); |
545 | if (local->ops->tx_last_beacon) |
546 | ret = local->ops->tx_last_beacon(&local->hw); |
547 | trace_drv_return_int(local, ret); |
548 | return ret; |
549 | } |
550 | |
551 | static inline int drv_ampdu_action(struct ieee80211_local *local, |
552 | struct ieee80211_sub_if_data *sdata, |
553 | enum ieee80211_ampdu_mlme_action action, |
554 | struct ieee80211_sta *sta, u16 tid, |
555 | u16 *ssn, u8 buf_size) |
556 | { |
557 | int ret = -EOPNOTSUPP; |
558 | |
559 | might_sleep(); |
560 | |
561 | sdata = get_bss_sdata(sdata); |
562 | check_sdata_in_driver(sdata); |
563 | |
564 | trace_drv_ampdu_action(local, sdata, action, sta, tid, ssn, buf_size); |
565 | |
566 | if (local->ops->ampdu_action) |
567 | ret = local->ops->ampdu_action(&local->hw, &sdata->vif, action, |
568 | sta, tid, ssn, buf_size); |
569 | |
570 | trace_drv_return_int(local, ret); |
571 | |
572 | return ret; |
573 | } |
574 | |
575 | static inline int drv_get_survey(struct ieee80211_local *local, int idx, |
576 | struct survey_info *survey) |
577 | { |
578 | int ret = -EOPNOTSUPP; |
579 | |
580 | trace_drv_get_survey(local, idx, survey); |
581 | |
582 | if (local->ops->get_survey) |
583 | ret = local->ops->get_survey(&local->hw, idx, survey); |
584 | |
585 | trace_drv_return_int(local, ret); |
586 | |
587 | return ret; |
588 | } |
589 | |
590 | static inline void drv_rfkill_poll(struct ieee80211_local *local) |
591 | { |
592 | might_sleep(); |
593 | |
594 | if (local->ops->rfkill_poll) |
595 | local->ops->rfkill_poll(&local->hw); |
596 | } |
597 | |
598 | static inline void drv_flush(struct ieee80211_local *local, bool drop) |
599 | { |
600 | might_sleep(); |
601 | |
602 | trace_drv_flush(local, drop); |
603 | if (local->ops->flush) |
604 | local->ops->flush(&local->hw, drop); |
605 | trace_drv_return_void(local); |
606 | } |
607 | |
608 | static inline void drv_channel_switch(struct ieee80211_local *local, |
609 | struct ieee80211_channel_switch *ch_switch) |
610 | { |
611 | might_sleep(); |
612 | |
613 | trace_drv_channel_switch(local, ch_switch); |
614 | local->ops->channel_switch(&local->hw, ch_switch); |
615 | trace_drv_return_void(local); |
616 | } |
617 | |
618 | |
619 | static inline int drv_set_antenna(struct ieee80211_local *local, |
620 | u32 tx_ant, u32 rx_ant) |
621 | { |
622 | int ret = -EOPNOTSUPP; |
623 | might_sleep(); |
624 | if (local->ops->set_antenna) |
625 | ret = local->ops->set_antenna(&local->hw, tx_ant, rx_ant); |
626 | trace_drv_set_antenna(local, tx_ant, rx_ant, ret); |
627 | return ret; |
628 | } |
629 | |
630 | static inline int drv_get_antenna(struct ieee80211_local *local, |
631 | u32 *tx_ant, u32 *rx_ant) |
632 | { |
633 | int ret = -EOPNOTSUPP; |
634 | might_sleep(); |
635 | if (local->ops->get_antenna) |
636 | ret = local->ops->get_antenna(&local->hw, tx_ant, rx_ant); |
637 | trace_drv_get_antenna(local, *tx_ant, *rx_ant, ret); |
638 | return ret; |
639 | } |
640 | |
641 | static inline int drv_remain_on_channel(struct ieee80211_local *local, |
642 | struct ieee80211_channel *chan, |
643 | enum nl80211_channel_type chantype, |
644 | unsigned int duration) |
645 | { |
646 | int ret; |
647 | |
648 | might_sleep(); |
649 | |
650 | trace_drv_remain_on_channel(local, chan, chantype, duration); |
651 | ret = local->ops->remain_on_channel(&local->hw, chan, chantype, |
652 | duration); |
653 | trace_drv_return_int(local, ret); |
654 | |
655 | return ret; |
656 | } |
657 | |
658 | static inline int drv_cancel_remain_on_channel(struct ieee80211_local *local) |
659 | { |
660 | int ret; |
661 | |
662 | might_sleep(); |
663 | |
664 | trace_drv_cancel_remain_on_channel(local); |
665 | ret = local->ops->cancel_remain_on_channel(&local->hw); |
666 | trace_drv_return_int(local, ret); |
667 | |
668 | return ret; |
669 | } |
670 | |
671 | static inline int drv_set_ringparam(struct ieee80211_local *local, |
672 | u32 tx, u32 rx) |
673 | { |
674 | int ret = -ENOTSUPP; |
675 | |
676 | might_sleep(); |
677 | |
678 | trace_drv_set_ringparam(local, tx, rx); |
679 | if (local->ops->set_ringparam) |
680 | ret = local->ops->set_ringparam(&local->hw, tx, rx); |
681 | trace_drv_return_int(local, ret); |
682 | |
683 | return ret; |
684 | } |
685 | |
686 | static inline void drv_get_ringparam(struct ieee80211_local *local, |
687 | u32 *tx, u32 *tx_max, u32 *rx, u32 *rx_max) |
688 | { |
689 | might_sleep(); |
690 | |
691 | trace_drv_get_ringparam(local, tx, tx_max, rx, rx_max); |
692 | if (local->ops->get_ringparam) |
693 | local->ops->get_ringparam(&local->hw, tx, tx_max, rx, rx_max); |
694 | trace_drv_return_void(local); |
695 | } |
696 | |
697 | static inline bool drv_tx_frames_pending(struct ieee80211_local *local) |
698 | { |
699 | bool ret = false; |
700 | |
701 | might_sleep(); |
702 | |
703 | trace_drv_tx_frames_pending(local); |
704 | if (local->ops->tx_frames_pending) |
705 | ret = local->ops->tx_frames_pending(&local->hw); |
706 | trace_drv_return_bool(local, ret); |
707 | |
708 | return ret; |
709 | } |
710 | |
711 | static inline int drv_set_bitrate_mask(struct ieee80211_local *local, |
712 | struct ieee80211_sub_if_data *sdata, |
713 | const struct cfg80211_bitrate_mask *mask) |
714 | { |
715 | int ret = -EOPNOTSUPP; |
716 | |
717 | might_sleep(); |
718 | |
719 | check_sdata_in_driver(sdata); |
720 | |
721 | trace_drv_set_bitrate_mask(local, sdata, mask); |
722 | if (local->ops->set_bitrate_mask) |
723 | ret = local->ops->set_bitrate_mask(&local->hw, |
724 | &sdata->vif, mask); |
725 | trace_drv_return_int(local, ret); |
726 | |
727 | return ret; |
728 | } |
729 | |
730 | static inline void drv_set_rekey_data(struct ieee80211_local *local, |
731 | struct ieee80211_sub_if_data *sdata, |
732 | struct cfg80211_gtk_rekey_data *data) |
733 | { |
734 | check_sdata_in_driver(sdata); |
735 | |
736 | trace_drv_set_rekey_data(local, sdata, data); |
737 | if (local->ops->set_rekey_data) |
738 | local->ops->set_rekey_data(&local->hw, &sdata->vif, data); |
739 | trace_drv_return_void(local); |
740 | } |
741 | |
742 | static inline void drv_rssi_callback(struct ieee80211_local *local, |
743 | const enum ieee80211_rssi_event event) |
744 | { |
745 | trace_drv_rssi_callback(local, event); |
746 | if (local->ops->rssi_callback) |
747 | local->ops->rssi_callback(&local->hw, event); |
748 | trace_drv_return_void(local); |
749 | } |
750 | |
751 | static inline void |
752 | drv_release_buffered_frames(struct ieee80211_local *local, |
753 | struct sta_info *sta, u16 tids, int num_frames, |
754 | enum ieee80211_frame_release_type reason, |
755 | bool more_data) |
756 | { |
757 | trace_drv_release_buffered_frames(local, &sta->sta, tids, num_frames, |
758 | reason, more_data); |
759 | if (local->ops->release_buffered_frames) |
760 | local->ops->release_buffered_frames(&local->hw, &sta->sta, tids, |
761 | num_frames, reason, |
762 | more_data); |
763 | trace_drv_return_void(local); |
764 | } |
765 | |
766 | static inline void |
767 | drv_allow_buffered_frames(struct ieee80211_local *local, |
768 | struct sta_info *sta, u16 tids, int num_frames, |
769 | enum ieee80211_frame_release_type reason, |
770 | bool more_data) |
771 | { |
772 | trace_drv_allow_buffered_frames(local, &sta->sta, tids, num_frames, |
773 | reason, more_data); |
774 | if (local->ops->allow_buffered_frames) |
775 | local->ops->allow_buffered_frames(&local->hw, &sta->sta, |
776 | tids, num_frames, reason, |
777 | more_data); |
778 | trace_drv_return_void(local); |
779 | } |
780 | #endif /* __MAC80211_DRIVER_OPS */ |
781 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9