Merge branch 'master' of master.kernel.org:/pub/scm/linux/kernel/git/linville/wireles...
[linux-2.6] / drivers / net / wireless / rt2x00 / rt2x00dev.c
1 /*
2         Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
3         <http://rt2x00.serialmonkey.com>
4
5         This program is free software; you can redistribute it and/or modify
6         it under the terms of the GNU General Public License as published by
7         the Free Software Foundation; either version 2 of the License, or
8         (at your option) any later version.
9
10         This program is distributed in the hope that it will be useful,
11         but WITHOUT ANY WARRANTY; without even the implied warranty of
12         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13         GNU General Public License for more details.
14
15         You should have received a copy of the GNU General Public License
16         along with this program; if not, write to the
17         Free Software Foundation, Inc.,
18         59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
19  */
20
21 /*
22         Module: rt2x00lib
23         Abstract: rt2x00 generic device routines.
24  */
25
26 #include <linux/kernel.h>
27 #include <linux/module.h>
28
29 #include "rt2x00.h"
30 #include "rt2x00lib.h"
31 #include "rt2x00dump.h"
32
33 /*
34  * Link tuning handlers
35  */
36 void rt2x00lib_reset_link_tuner(struct rt2x00_dev *rt2x00dev)
37 {
38         if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
39                 return;
40
41         /*
42          * Reset link information.
43          * Both the currently active vgc level as well as
44          * the link tuner counter should be reset. Resetting
45          * the counter is important for devices where the
46          * device should only perform link tuning during the
47          * first minute after being enabled.
48          */
49         rt2x00dev->link.count = 0;
50         rt2x00dev->link.vgc_level = 0;
51
52         /*
53          * Reset the link tuner.
54          */
55         rt2x00dev->ops->lib->reset_tuner(rt2x00dev);
56 }
57
58 static void rt2x00lib_start_link_tuner(struct rt2x00_dev *rt2x00dev)
59 {
60         /*
61          * Clear all (possibly) pre-existing quality statistics.
62          */
63         memset(&rt2x00dev->link.qual, 0, sizeof(rt2x00dev->link.qual));
64
65         /*
66          * The RX and TX percentage should start at 50%
67          * this will assure we will get at least get some
68          * decent value when the link tuner starts.
69          * The value will be dropped and overwritten with
70          * the correct (measured )value anyway during the
71          * first run of the link tuner.
72          */
73         rt2x00dev->link.qual.rx_percentage = 50;
74         rt2x00dev->link.qual.tx_percentage = 50;
75
76         rt2x00lib_reset_link_tuner(rt2x00dev);
77
78         queue_delayed_work(rt2x00dev->hw->workqueue,
79                            &rt2x00dev->link.work, LINK_TUNE_INTERVAL);
80 }
81
82 static void rt2x00lib_stop_link_tuner(struct rt2x00_dev *rt2x00dev)
83 {
84         cancel_delayed_work_sync(&rt2x00dev->link.work);
85 }
86
87 /*
88  * Radio control handlers.
89  */
90 int rt2x00lib_enable_radio(struct rt2x00_dev *rt2x00dev)
91 {
92         int status;
93
94         /*
95          * Don't enable the radio twice.
96          * And check if the hardware button has been disabled.
97          */
98         if (test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) ||
99             test_bit(DEVICE_DISABLED_RADIO_HW, &rt2x00dev->flags))
100                 return 0;
101
102         /*
103          * Initialize all data queues.
104          */
105         rt2x00queue_init_rx(rt2x00dev);
106         rt2x00queue_init_tx(rt2x00dev);
107
108         /*
109          * Enable radio.
110          */
111         status =
112             rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_ON);
113         if (status)
114                 return status;
115
116         rt2x00leds_led_radio(rt2x00dev, true);
117         rt2x00led_led_activity(rt2x00dev, true);
118
119         __set_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags);
120
121         /*
122          * Enable RX.
123          */
124         rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_ON);
125
126         /*
127          * Start the TX queues.
128          */
129         ieee80211_start_queues(rt2x00dev->hw);
130
131         return 0;
132 }
133
134 void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
135 {
136         if (!__test_and_clear_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
137                 return;
138
139         /*
140          * Stop all scheduled work.
141          */
142         if (work_pending(&rt2x00dev->intf_work))
143                 cancel_work_sync(&rt2x00dev->intf_work);
144         if (work_pending(&rt2x00dev->filter_work))
145                 cancel_work_sync(&rt2x00dev->filter_work);
146
147         /*
148          * Stop the TX queues.
149          */
150         ieee80211_stop_queues(rt2x00dev->hw);
151
152         /*
153          * Disable RX.
154          */
155         rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_OFF);
156
157         /*
158          * Disable radio.
159          */
160         rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF);
161         rt2x00led_led_activity(rt2x00dev, false);
162         rt2x00leds_led_radio(rt2x00dev, false);
163 }
164
165 void rt2x00lib_toggle_rx(struct rt2x00_dev *rt2x00dev, enum dev_state state)
166 {
167         /*
168          * When we are disabling the RX, we should also stop the link tuner.
169          */
170         if (state == STATE_RADIO_RX_OFF)
171                 rt2x00lib_stop_link_tuner(rt2x00dev);
172
173         rt2x00dev->ops->lib->set_device_state(rt2x00dev, state);
174
175         /*
176          * When we are enabling the RX, we should also start the link tuner.
177          */
178         if (state == STATE_RADIO_RX_ON &&
179             (rt2x00dev->intf_ap_count || rt2x00dev->intf_sta_count))
180                 rt2x00lib_start_link_tuner(rt2x00dev);
181 }
182
183 static void rt2x00lib_evaluate_antenna_sample(struct rt2x00_dev *rt2x00dev)
184 {
185         enum antenna rx = rt2x00dev->link.ant.active.rx;
186         enum antenna tx = rt2x00dev->link.ant.active.tx;
187         int sample_a =
188             rt2x00_get_link_ant_rssi_history(&rt2x00dev->link, ANTENNA_A);
189         int sample_b =
190             rt2x00_get_link_ant_rssi_history(&rt2x00dev->link, ANTENNA_B);
191
192         /*
193          * We are done sampling. Now we should evaluate the results.
194          */
195         rt2x00dev->link.ant.flags &= ~ANTENNA_MODE_SAMPLE;
196
197         /*
198          * During the last period we have sampled the RSSI
199          * from both antenna's. It now is time to determine
200          * which antenna demonstrated the best performance.
201          * When we are already on the antenna with the best
202          * performance, then there really is nothing for us
203          * left to do.
204          */
205         if (sample_a == sample_b)
206                 return;
207
208         if (rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY)
209                 rx = (sample_a > sample_b) ? ANTENNA_A : ANTENNA_B;
210
211         if (rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)
212                 tx = (sample_a > sample_b) ? ANTENNA_A : ANTENNA_B;
213
214         rt2x00lib_config_antenna(rt2x00dev, rx, tx);
215 }
216
217 static void rt2x00lib_evaluate_antenna_eval(struct rt2x00_dev *rt2x00dev)
218 {
219         enum antenna rx = rt2x00dev->link.ant.active.rx;
220         enum antenna tx = rt2x00dev->link.ant.active.tx;
221         int rssi_curr = rt2x00_get_link_ant_rssi(&rt2x00dev->link);
222         int rssi_old = rt2x00_update_ant_rssi(&rt2x00dev->link, rssi_curr);
223
224         /*
225          * Legacy driver indicates that we should swap antenna's
226          * when the difference in RSSI is greater that 5. This
227          * also should be done when the RSSI was actually better
228          * then the previous sample.
229          * When the difference exceeds the threshold we should
230          * sample the rssi from the other antenna to make a valid
231          * comparison between the 2 antennas.
232          */
233         if (abs(rssi_curr - rssi_old) < 5)
234                 return;
235
236         rt2x00dev->link.ant.flags |= ANTENNA_MODE_SAMPLE;
237
238         if (rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY)
239                 rx = (rx == ANTENNA_A) ? ANTENNA_B : ANTENNA_A;
240
241         if (rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)
242                 tx = (tx == ANTENNA_A) ? ANTENNA_B : ANTENNA_A;
243
244         rt2x00lib_config_antenna(rt2x00dev, rx, tx);
245 }
246
247 static void rt2x00lib_evaluate_antenna(struct rt2x00_dev *rt2x00dev)
248 {
249         /*
250          * Determine if software diversity is enabled for
251          * either the TX or RX antenna (or both).
252          * Always perform this check since within the link
253          * tuner interval the configuration might have changed.
254          */
255         rt2x00dev->link.ant.flags &= ~ANTENNA_RX_DIVERSITY;
256         rt2x00dev->link.ant.flags &= ~ANTENNA_TX_DIVERSITY;
257
258         if (rt2x00dev->hw->conf.antenna_sel_rx == 0 &&
259             rt2x00dev->default_ant.rx == ANTENNA_SW_DIVERSITY)
260                 rt2x00dev->link.ant.flags |= ANTENNA_RX_DIVERSITY;
261         if (rt2x00dev->hw->conf.antenna_sel_tx == 0 &&
262             rt2x00dev->default_ant.tx == ANTENNA_SW_DIVERSITY)
263                 rt2x00dev->link.ant.flags |= ANTENNA_TX_DIVERSITY;
264
265         if (!(rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY) &&
266             !(rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)) {
267                 rt2x00dev->link.ant.flags = 0;
268                 return;
269         }
270
271         /*
272          * If we have only sampled the data over the last period
273          * we should now harvest the data. Otherwise just evaluate
274          * the data. The latter should only be performed once
275          * every 2 seconds.
276          */
277         if (rt2x00dev->link.ant.flags & ANTENNA_MODE_SAMPLE)
278                 rt2x00lib_evaluate_antenna_sample(rt2x00dev);
279         else if (rt2x00dev->link.count & 1)
280                 rt2x00lib_evaluate_antenna_eval(rt2x00dev);
281 }
282
283 static void rt2x00lib_update_link_stats(struct link *link, int rssi)
284 {
285         int avg_rssi = rssi;
286
287         /*
288          * Update global RSSI
289          */
290         if (link->qual.avg_rssi)
291                 avg_rssi = MOVING_AVERAGE(link->qual.avg_rssi, rssi, 8);
292         link->qual.avg_rssi = avg_rssi;
293
294         /*
295          * Update antenna RSSI
296          */
297         if (link->ant.rssi_ant)
298                 rssi = MOVING_AVERAGE(link->ant.rssi_ant, rssi, 8);
299         link->ant.rssi_ant = rssi;
300 }
301
302 static void rt2x00lib_precalculate_link_signal(struct link_qual *qual)
303 {
304         if (qual->rx_failed || qual->rx_success)
305                 qual->rx_percentage =
306                     (qual->rx_success * 100) /
307                     (qual->rx_failed + qual->rx_success);
308         else
309                 qual->rx_percentage = 50;
310
311         if (qual->tx_failed || qual->tx_success)
312                 qual->tx_percentage =
313                     (qual->tx_success * 100) /
314                     (qual->tx_failed + qual->tx_success);
315         else
316                 qual->tx_percentage = 50;
317
318         qual->rx_success = 0;
319         qual->rx_failed = 0;
320         qual->tx_success = 0;
321         qual->tx_failed = 0;
322 }
323
324 static int rt2x00lib_calculate_link_signal(struct rt2x00_dev *rt2x00dev,
325                                            int rssi)
326 {
327         int rssi_percentage = 0;
328         int signal;
329
330         /*
331          * We need a positive value for the RSSI.
332          */
333         if (rssi < 0)
334                 rssi += rt2x00dev->rssi_offset;
335
336         /*
337          * Calculate the different percentages,
338          * which will be used for the signal.
339          */
340         if (rt2x00dev->rssi_offset)
341                 rssi_percentage = (rssi * 100) / rt2x00dev->rssi_offset;
342
343         /*
344          * Add the individual percentages and use the WEIGHT
345          * defines to calculate the current link signal.
346          */
347         signal = ((WEIGHT_RSSI * rssi_percentage) +
348                   (WEIGHT_TX * rt2x00dev->link.qual.tx_percentage) +
349                   (WEIGHT_RX * rt2x00dev->link.qual.rx_percentage)) / 100;
350
351         return (signal > 100) ? 100 : signal;
352 }
353
354 static void rt2x00lib_link_tuner(struct work_struct *work)
355 {
356         struct rt2x00_dev *rt2x00dev =
357             container_of(work, struct rt2x00_dev, link.work.work);
358
359         /*
360          * When the radio is shutting down we should
361          * immediately cease all link tuning.
362          */
363         if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
364                 return;
365
366         /*
367          * Update statistics.
368          */
369         rt2x00dev->ops->lib->link_stats(rt2x00dev, &rt2x00dev->link.qual);
370         rt2x00dev->low_level_stats.dot11FCSErrorCount +=
371             rt2x00dev->link.qual.rx_failed;
372
373         /*
374          * Only perform the link tuning when Link tuning
375          * has been enabled (This could have been disabled from the EEPROM).
376          */
377         if (!test_bit(CONFIG_DISABLE_LINK_TUNING, &rt2x00dev->flags))
378                 rt2x00dev->ops->lib->link_tuner(rt2x00dev);
379
380         /*
381          * Precalculate a portion of the link signal which is
382          * in based on the tx/rx success/failure counters.
383          */
384         rt2x00lib_precalculate_link_signal(&rt2x00dev->link.qual);
385
386         /*
387          * Send a signal to the led to update the led signal strength.
388          */
389         rt2x00leds_led_quality(rt2x00dev, rt2x00dev->link.qual.avg_rssi);
390
391         /*
392          * Evaluate antenna setup, make this the last step since this could
393          * possibly reset some statistics.
394          */
395         rt2x00lib_evaluate_antenna(rt2x00dev);
396
397         /*
398          * Increase tuner counter, and reschedule the next link tuner run.
399          */
400         rt2x00dev->link.count++;
401         queue_delayed_work(rt2x00dev->hw->workqueue, &rt2x00dev->link.work,
402                            LINK_TUNE_INTERVAL);
403 }
404
405 static void rt2x00lib_packetfilter_scheduled(struct work_struct *work)
406 {
407         struct rt2x00_dev *rt2x00dev =
408             container_of(work, struct rt2x00_dev, filter_work);
409
410         rt2x00dev->ops->lib->config_filter(rt2x00dev, rt2x00dev->packet_filter);
411 }
412
413 static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
414                                           struct ieee80211_vif *vif)
415 {
416         struct rt2x00_dev *rt2x00dev = data;
417         struct rt2x00_intf *intf = vif_to_intf(vif);
418         struct sk_buff *skb;
419         struct ieee80211_tx_control control;
420         struct ieee80211_bss_conf conf;
421         int delayed_flags;
422
423         /*
424          * Copy all data we need during this action under the protection
425          * of a spinlock. Otherwise race conditions might occur which results
426          * into an invalid configuration.
427          */
428         spin_lock(&intf->lock);
429
430         memcpy(&conf, &intf->conf, sizeof(conf));
431         delayed_flags = intf->delayed_flags;
432         intf->delayed_flags = 0;
433
434         spin_unlock(&intf->lock);
435
436         if (delayed_flags & DELAYED_UPDATE_BEACON) {
437                 skb = ieee80211_beacon_get(rt2x00dev->hw, vif, &control);
438                 if (skb && rt2x00dev->ops->hw->beacon_update(rt2x00dev->hw,
439                                                              skb, &control))
440                         dev_kfree_skb(skb);
441         }
442
443         if (delayed_flags & DELAYED_CONFIG_ERP)
444                 rt2x00lib_config_erp(rt2x00dev, intf, &intf->conf);
445
446         if (delayed_flags & DELAYED_LED_ASSOC)
447                 rt2x00leds_led_assoc(rt2x00dev, !!rt2x00dev->intf_associated);
448 }
449
450 static void rt2x00lib_intf_scheduled(struct work_struct *work)
451 {
452         struct rt2x00_dev *rt2x00dev =
453             container_of(work, struct rt2x00_dev, intf_work);
454
455         /*
456          * Iterate over each interface and perform the
457          * requested configurations.
458          */
459         ieee80211_iterate_active_interfaces(rt2x00dev->hw,
460                                             rt2x00lib_intf_scheduled_iter,
461                                             rt2x00dev);
462 }
463
464 /*
465  * Interrupt context handlers.
466  */
467 static void rt2x00lib_beacondone_iter(void *data, u8 *mac,
468                                       struct ieee80211_vif *vif)
469 {
470         struct rt2x00_intf *intf = vif_to_intf(vif);
471
472         if (vif->type != IEEE80211_IF_TYPE_AP &&
473             vif->type != IEEE80211_IF_TYPE_IBSS)
474                 return;
475
476         spin_lock(&intf->lock);
477         intf->delayed_flags |= DELAYED_UPDATE_BEACON;
478         spin_unlock(&intf->lock);
479 }
480
481 void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
482 {
483         if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
484                 return;
485
486         ieee80211_iterate_active_interfaces_atomic(rt2x00dev->hw,
487                                                    rt2x00lib_beacondone_iter,
488                                                    rt2x00dev);
489
490         queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->intf_work);
491 }
492 EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);
493
494 void rt2x00lib_txdone(struct queue_entry *entry,
495                       struct txdone_entry_desc *txdesc)
496 {
497         struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
498         struct skb_frame_desc *skbdesc;
499         struct ieee80211_tx_status tx_status;
500         int success = !!(txdesc->status == TX_SUCCESS ||
501                          txdesc->status == TX_SUCCESS_RETRY);
502         int fail = !!(txdesc->status == TX_FAIL_RETRY ||
503                       txdesc->status == TX_FAIL_INVALID ||
504                       txdesc->status == TX_FAIL_OTHER);
505
506         /*
507          * Update TX statistics.
508          */
509         rt2x00dev->link.qual.tx_success += success;
510         rt2x00dev->link.qual.tx_failed += fail;
511
512         /*
513          * Initialize TX status
514          */
515         tx_status.flags = 0;
516         tx_status.ack_signal = 0;
517         tx_status.excessive_retries = (txdesc->status == TX_FAIL_RETRY);
518         tx_status.retry_count = txdesc->retry;
519         memcpy(&tx_status.control, txdesc->control, sizeof(*txdesc->control));
520
521         if (!(tx_status.control.flags & IEEE80211_TXCTL_NO_ACK)) {
522                 if (success)
523                         tx_status.flags |= IEEE80211_TX_STATUS_ACK;
524                 else
525                         rt2x00dev->low_level_stats.dot11ACKFailureCount++;
526         }
527
528         tx_status.queue_length = entry->queue->limit;
529         tx_status.queue_number = tx_status.control.queue;
530
531         if (tx_status.control.flags & IEEE80211_TXCTL_USE_RTS_CTS) {
532                 if (success)
533                         rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
534                 else
535                         rt2x00dev->low_level_stats.dot11RTSFailureCount++;
536         }
537
538         /*
539          * Send the tx_status to debugfs. Only send the status report
540          * to mac80211 when the frame originated from there. If this was
541          * a extra frame coming through a mac80211 library call (RTS/CTS)
542          * then we should not send the status report back.
543          * If send to mac80211, mac80211 will clean up the skb structure,
544          * otherwise we have to do it ourself.
545          */
546         skbdesc = get_skb_frame_desc(entry->skb);
547         skbdesc->frame_type = DUMP_FRAME_TXDONE;
548
549         rt2x00debug_dump_frame(rt2x00dev, entry->skb);
550
551         if (!(skbdesc->flags & FRAME_DESC_DRIVER_GENERATED))
552                 ieee80211_tx_status_irqsafe(rt2x00dev->hw,
553                                             entry->skb, &tx_status);
554         else
555                 dev_kfree_skb(entry->skb);
556         entry->skb = NULL;
557 }
558 EXPORT_SYMBOL_GPL(rt2x00lib_txdone);
559
560 void rt2x00lib_rxdone(struct queue_entry *entry,
561                       struct rxdone_entry_desc *rxdesc)
562 {
563         struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
564         struct ieee80211_rx_status *rx_status = &rt2x00dev->rx_status;
565         struct ieee80211_supported_band *sband;
566         struct ieee80211_hdr *hdr;
567         const struct rt2x00_rate *rate;
568         unsigned int i;
569         int idx = -1;
570         u16 fc;
571
572         /*
573          * Update RX statistics.
574          */
575         sband = &rt2x00dev->bands[rt2x00dev->curr_band];
576         for (i = 0; i < sband->n_bitrates; i++) {
577                 rate = rt2x00_get_rate(sband->bitrates[i].hw_value);
578
579                 if (((rxdesc->dev_flags & RXDONE_SIGNAL_PLCP) &&
580                      (rate->plcp == rxdesc->signal)) ||
581                     (!(rxdesc->dev_flags & RXDONE_SIGNAL_PLCP) &&
582                       (rate->bitrate == rxdesc->signal))) {
583                         idx = i;
584                         break;
585                 }
586         }
587
588         if (idx < 0) {
589                 WARNING(rt2x00dev, "Frame received with unrecognized signal,"
590                         "signal=0x%.2x, plcp=%d.\n", rxdesc->signal,
591                         !!(rxdesc->dev_flags & RXDONE_SIGNAL_PLCP));
592                 idx = 0;
593         }
594
595         /*
596          * Only update link status if this is a beacon frame carrying our bssid.
597          */
598         hdr = (struct ieee80211_hdr *)entry->skb->data;
599         fc = le16_to_cpu(hdr->frame_control);
600         if (is_beacon(fc) && (rxdesc->dev_flags & RXDONE_MY_BSS))
601                 rt2x00lib_update_link_stats(&rt2x00dev->link, rxdesc->rssi);
602
603         rt2x00dev->link.qual.rx_success++;
604
605         rx_status->rate_idx = idx;
606         rx_status->signal =
607             rt2x00lib_calculate_link_signal(rt2x00dev, rxdesc->rssi);
608         rx_status->ssi = rxdesc->rssi;
609         rx_status->flag = rxdesc->flags;
610         rx_status->antenna = rt2x00dev->link.ant.active.rx;
611
612         /*
613          * Send frame to mac80211 & debugfs.
614          * mac80211 will clean up the skb structure.
615          */
616         get_skb_frame_desc(entry->skb)->frame_type = DUMP_FRAME_RXDONE;
617         rt2x00debug_dump_frame(rt2x00dev, entry->skb);
618         ieee80211_rx_irqsafe(rt2x00dev->hw, entry->skb, rx_status);
619         entry->skb = NULL;
620 }
621 EXPORT_SYMBOL_GPL(rt2x00lib_rxdone);
622
623 /*
624  * TX descriptor initializer
625  */
626 void rt2x00lib_write_tx_desc(struct rt2x00_dev *rt2x00dev,
627                              struct sk_buff *skb,
628                              struct ieee80211_tx_control *control)
629 {
630         struct txentry_desc txdesc;
631         struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb);
632         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skbdesc->data;
633         const struct rt2x00_rate *rate;
634         int tx_rate;
635         int length;
636         int duration;
637         int residual;
638         u16 frame_control;
639         u16 seq_ctrl;
640
641         memset(&txdesc, 0, sizeof(txdesc));
642
643         txdesc.queue = skbdesc->entry->queue->qid;
644         txdesc.cw_min = skbdesc->entry->queue->cw_min;
645         txdesc.cw_max = skbdesc->entry->queue->cw_max;
646         txdesc.aifs = skbdesc->entry->queue->aifs;
647
648         /*
649          * Read required fields from ieee80211 header.
650          */
651         frame_control = le16_to_cpu(hdr->frame_control);
652         seq_ctrl = le16_to_cpu(hdr->seq_ctrl);
653
654         tx_rate = control->tx_rate->hw_value;
655
656         /*
657          * Check whether this frame is to be acked
658          */
659         if (!(control->flags & IEEE80211_TXCTL_NO_ACK))
660                 __set_bit(ENTRY_TXD_ACK, &txdesc.flags);
661
662         /*
663          * Check if this is a RTS/CTS frame
664          */
665         if (is_rts_frame(frame_control) || is_cts_frame(frame_control)) {
666                 __set_bit(ENTRY_TXD_BURST, &txdesc.flags);
667                 if (is_rts_frame(frame_control)) {
668                         __set_bit(ENTRY_TXD_RTS_FRAME, &txdesc.flags);
669                         __set_bit(ENTRY_TXD_ACK, &txdesc.flags);
670                 } else
671                         __clear_bit(ENTRY_TXD_ACK, &txdesc.flags);
672                 if (control->rts_cts_rate)
673                         tx_rate = control->rts_cts_rate->hw_value;
674         }
675
676         rate = rt2x00_get_rate(tx_rate);
677
678         /*
679          * Check if more fragments are pending
680          */
681         if (ieee80211_get_morefrag(hdr)) {
682                 __set_bit(ENTRY_TXD_BURST, &txdesc.flags);
683                 __set_bit(ENTRY_TXD_MORE_FRAG, &txdesc.flags);
684         }
685
686         /*
687          * Beacons and probe responses require the tsf timestamp
688          * to be inserted into the frame.
689          */
690         if (control->queue == RT2X00_BCN_QUEUE_BEACON ||
691             is_probe_resp(frame_control))
692                 __set_bit(ENTRY_TXD_REQ_TIMESTAMP, &txdesc.flags);
693
694         /*
695          * Determine with what IFS priority this frame should be send.
696          * Set ifs to IFS_SIFS when the this is not the first fragment,
697          * or this fragment came after RTS/CTS.
698          */
699         if ((seq_ctrl & IEEE80211_SCTL_FRAG) > 0 ||
700             test_bit(ENTRY_TXD_RTS_FRAME, &txdesc.flags))
701                 txdesc.ifs = IFS_SIFS;
702         else
703                 txdesc.ifs = IFS_BACKOFF;
704
705         /*
706          * PLCP setup
707          * Length calculation depends on OFDM/CCK rate.
708          */
709         txdesc.signal = rate->plcp;
710         txdesc.service = 0x04;
711
712         length = skbdesc->data_len + FCS_LEN;
713         if (rate->flags & DEV_RATE_OFDM) {
714                 __set_bit(ENTRY_TXD_OFDM_RATE, &txdesc.flags);
715
716                 txdesc.length_high = (length >> 6) & 0x3f;
717                 txdesc.length_low = length & 0x3f;
718         } else {
719                 /*
720                  * Convert length to microseconds.
721                  */
722                 residual = get_duration_res(length, rate->bitrate);
723                 duration = get_duration(length, rate->bitrate);
724
725                 if (residual != 0) {
726                         duration++;
727
728                         /*
729                          * Check if we need to set the Length Extension
730                          */
731                         if (rate->bitrate == 110 && residual <= 30)
732                                 txdesc.service |= 0x80;
733                 }
734
735                 txdesc.length_high = (duration >> 8) & 0xff;
736                 txdesc.length_low = duration & 0xff;
737
738                 /*
739                  * When preamble is enabled we should set the
740                  * preamble bit for the signal.
741                  */
742                 if (rt2x00_get_rate_preamble(tx_rate))
743                         txdesc.signal |= 0x08;
744         }
745
746         rt2x00dev->ops->lib->write_tx_desc(rt2x00dev, skb, &txdesc, control);
747
748         /*
749          * Update queue entry.
750          */
751         skbdesc->entry->skb = skb;
752
753         /*
754          * The frame has been completely initialized and ready
755          * for sending to the device. The caller will push the
756          * frame to the device, but we are going to push the
757          * frame to debugfs here.
758          */
759         skbdesc->frame_type = DUMP_FRAME_TX;
760         rt2x00debug_dump_frame(rt2x00dev, skb);
761 }
762 EXPORT_SYMBOL_GPL(rt2x00lib_write_tx_desc);
763
764 /*
765  * Driver initialization handlers.
766  */
767 const struct rt2x00_rate rt2x00_supported_rates[12] = {
768         {
769                 .flags = DEV_RATE_CCK | DEV_RATE_BASIC,
770                 .bitrate = 10,
771                 .ratemask = BIT(0),
772                 .plcp = 0x00,
773         },
774         {
775                 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
776                 .bitrate = 20,
777                 .ratemask = BIT(1),
778                 .plcp = 0x01,
779         },
780         {
781                 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
782                 .bitrate = 55,
783                 .ratemask = BIT(2),
784                 .plcp = 0x02,
785         },
786         {
787                 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
788                 .bitrate = 110,
789                 .ratemask = BIT(3),
790                 .plcp = 0x03,
791         },
792         {
793                 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
794                 .bitrate = 60,
795                 .ratemask = BIT(4),
796                 .plcp = 0x0b,
797         },
798         {
799                 .flags = DEV_RATE_OFDM,
800                 .bitrate = 90,
801                 .ratemask = BIT(5),
802                 .plcp = 0x0f,
803         },
804         {
805                 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
806                 .bitrate = 120,
807                 .ratemask = BIT(6),
808                 .plcp = 0x0a,
809         },
810         {
811                 .flags = DEV_RATE_OFDM,
812                 .bitrate = 180,
813                 .ratemask = BIT(7),
814                 .plcp = 0x0e,
815         },
816         {
817                 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
818                 .bitrate = 240,
819                 .ratemask = BIT(8),
820                 .plcp = 0x09,
821         },
822         {
823                 .flags = DEV_RATE_OFDM,
824                 .bitrate = 360,
825                 .ratemask = BIT(9),
826                 .plcp = 0x0d,
827         },
828         {
829                 .flags = DEV_RATE_OFDM,
830                 .bitrate = 480,
831                 .ratemask = BIT(10),
832                 .plcp = 0x08,
833         },
834         {
835                 .flags = DEV_RATE_OFDM,
836                 .bitrate = 540,
837                 .ratemask = BIT(11),
838                 .plcp = 0x0c,
839         },
840 };
841
842 static void rt2x00lib_channel(struct ieee80211_channel *entry,
843                               const int channel, const int tx_power,
844                               const int value)
845 {
846         entry->center_freq = ieee80211_channel_to_frequency(channel);
847         entry->hw_value = value;
848         entry->max_power = tx_power;
849         entry->max_antenna_gain = 0xff;
850 }
851
852 static void rt2x00lib_rate(struct ieee80211_rate *entry,
853                            const u16 index, const struct rt2x00_rate *rate)
854 {
855         entry->flags = 0;
856         entry->bitrate = rate->bitrate;
857         entry->hw_value = rt2x00_create_rate_hw_value(index, 0);
858         entry->hw_value_short = entry->hw_value;
859
860         if (rate->flags & DEV_RATE_SHORT_PREAMBLE) {
861                 entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
862                 entry->hw_value_short |= rt2x00_create_rate_hw_value(index, 1);
863         }
864 }
865
866 static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
867                                     struct hw_mode_spec *spec)
868 {
869         struct ieee80211_hw *hw = rt2x00dev->hw;
870         struct ieee80211_channel *channels;
871         struct ieee80211_rate *rates;
872         unsigned int num_rates;
873         unsigned int i;
874         unsigned char tx_power;
875
876         num_rates = 0;
877         if (spec->supported_rates & SUPPORT_RATE_CCK)
878                 num_rates += 4;
879         if (spec->supported_rates & SUPPORT_RATE_OFDM)
880                 num_rates += 8;
881
882         channels = kzalloc(sizeof(*channels) * spec->num_channels, GFP_KERNEL);
883         if (!channels)
884                 return -ENOMEM;
885
886         rates = kzalloc(sizeof(*rates) * num_rates, GFP_KERNEL);
887         if (!rates)
888                 goto exit_free_channels;
889
890         /*
891          * Initialize Rate list.
892          */
893         for (i = 0; i < num_rates; i++)
894                 rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i));
895
896         /*
897          * Initialize Channel list.
898          */
899         for (i = 0; i < spec->num_channels; i++) {
900                 if (spec->channels[i].channel <= 14) {
901                         if (spec->tx_power_bg)
902                                 tx_power = spec->tx_power_bg[i];
903                         else
904                                 tx_power = spec->tx_power_default;
905                 } else {
906                         if (spec->tx_power_a)
907                                 tx_power = spec->tx_power_a[i];
908                         else
909                                 tx_power = spec->tx_power_default;
910                 }
911
912                 rt2x00lib_channel(&channels[i],
913                                   spec->channels[i].channel, tx_power, i);
914         }
915
916         /*
917          * Intitialize 802.11b, 802.11g
918          * Rates: CCK, OFDM.
919          * Channels: 2.4 GHz
920          */
921         if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
922                 rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_channels = 14;
923                 rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_bitrates = num_rates;
924                 rt2x00dev->bands[IEEE80211_BAND_2GHZ].channels = channels;
925                 rt2x00dev->bands[IEEE80211_BAND_2GHZ].bitrates = rates;
926                 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
927                     &rt2x00dev->bands[IEEE80211_BAND_2GHZ];
928         }
929
930         /*
931          * Intitialize 802.11a
932          * Rates: OFDM.
933          * Channels: OFDM, UNII, HiperLAN2.
934          */
935         if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
936                 rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_channels =
937                     spec->num_channels - 14;
938                 rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_bitrates =
939                     num_rates - 4;
940                 rt2x00dev->bands[IEEE80211_BAND_5GHZ].channels = &channels[14];
941                 rt2x00dev->bands[IEEE80211_BAND_5GHZ].bitrates = &rates[4];
942                 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
943                     &rt2x00dev->bands[IEEE80211_BAND_5GHZ];
944         }
945
946         return 0;
947
948  exit_free_channels:
949         kfree(channels);
950         ERROR(rt2x00dev, "Allocation ieee80211 modes failed.\n");
951         return -ENOMEM;
952 }
953
954 static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
955 {
956         if (test_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags))
957                 ieee80211_unregister_hw(rt2x00dev->hw);
958
959         if (likely(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ])) {
960                 kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
961                 kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->bitrates);
962                 rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
963                 rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
964         }
965 }
966
967 static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
968 {
969         struct hw_mode_spec *spec = &rt2x00dev->spec;
970         int status;
971
972         /*
973          * Initialize HW modes.
974          */
975         status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
976         if (status)
977                 return status;
978
979         /*
980          * Register HW.
981          */
982         status = ieee80211_register_hw(rt2x00dev->hw);
983         if (status) {
984                 rt2x00lib_remove_hw(rt2x00dev);
985                 return status;
986         }
987
988         __set_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags);
989
990         return 0;
991 }
992
993 /*
994  * Initialization/uninitialization handlers.
995  */
996 static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
997 {
998         if (!__test_and_clear_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
999                 return;
1000
1001         /*
1002          * Unregister extra components.
1003          */
1004         rt2x00rfkill_unregister(rt2x00dev);
1005
1006         /*
1007          * Allow the HW to uninitialize.
1008          */
1009         rt2x00dev->ops->lib->uninitialize(rt2x00dev);
1010
1011         /*
1012          * Free allocated queue entries.
1013          */
1014         rt2x00queue_uninitialize(rt2x00dev);
1015 }
1016
1017 static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
1018 {
1019         int status;
1020
1021         if (test_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
1022                 return 0;
1023
1024         /*
1025          * Allocate all queue entries.
1026          */
1027         status = rt2x00queue_initialize(rt2x00dev);
1028         if (status)
1029                 return status;
1030
1031         /*
1032          * Initialize the device.
1033          */
1034         status = rt2x00dev->ops->lib->initialize(rt2x00dev);
1035         if (status) {
1036                 rt2x00queue_uninitialize(rt2x00dev);
1037                 return status;
1038         }
1039
1040         __set_bit(DEVICE_INITIALIZED, &rt2x00dev->flags);
1041
1042         /*
1043          * Register the extra components.
1044          */
1045         rt2x00rfkill_register(rt2x00dev);
1046
1047         return 0;
1048 }
1049
1050 int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
1051 {
1052         int retval;
1053
1054         if (test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1055                 return 0;
1056
1057         /*
1058          * If this is the first interface which is added,
1059          * we should load the firmware now.
1060          */
1061         retval = rt2x00lib_load_firmware(rt2x00dev);
1062         if (retval)
1063                 return retval;
1064
1065         /*
1066          * Initialize the device.
1067          */
1068         retval = rt2x00lib_initialize(rt2x00dev);
1069         if (retval)
1070                 return retval;
1071
1072         /*
1073          * Enable radio.
1074          */
1075         retval = rt2x00lib_enable_radio(rt2x00dev);
1076         if (retval) {
1077                 rt2x00lib_uninitialize(rt2x00dev);
1078                 return retval;
1079         }
1080
1081         rt2x00dev->intf_ap_count = 0;
1082         rt2x00dev->intf_sta_count = 0;
1083         rt2x00dev->intf_associated = 0;
1084
1085         __set_bit(DEVICE_STARTED, &rt2x00dev->flags);
1086
1087         return 0;
1088 }
1089
1090 void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
1091 {
1092         if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1093                 return;
1094
1095         /*
1096          * Perhaps we can add something smarter here,
1097          * but for now just disabling the radio should do.
1098          */
1099         rt2x00lib_disable_radio(rt2x00dev);
1100
1101         rt2x00dev->intf_ap_count = 0;
1102         rt2x00dev->intf_sta_count = 0;
1103         rt2x00dev->intf_associated = 0;
1104
1105         __clear_bit(DEVICE_STARTED, &rt2x00dev->flags);
1106 }
1107
1108 /*
1109  * driver allocation handlers.
1110  */
1111 int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
1112 {
1113         int retval = -ENOMEM;
1114
1115         /*
1116          * Make room for rt2x00_intf inside the per-interface
1117          * structure ieee80211_vif.
1118          */
1119         rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf);
1120
1121         /*
1122          * Let the driver probe the device to detect the capabilities.
1123          */
1124         retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
1125         if (retval) {
1126                 ERROR(rt2x00dev, "Failed to allocate device.\n");
1127                 goto exit;
1128         }
1129
1130         /*
1131          * Initialize configuration work.
1132          */
1133         INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
1134         INIT_WORK(&rt2x00dev->filter_work, rt2x00lib_packetfilter_scheduled);
1135         INIT_DELAYED_WORK(&rt2x00dev->link.work, rt2x00lib_link_tuner);
1136
1137         /*
1138          * Allocate queue array.
1139          */
1140         retval = rt2x00queue_allocate(rt2x00dev);
1141         if (retval)
1142                 goto exit;
1143
1144         /*
1145          * Initialize ieee80211 structure.
1146          */
1147         retval = rt2x00lib_probe_hw(rt2x00dev);
1148         if (retval) {
1149                 ERROR(rt2x00dev, "Failed to initialize hw.\n");
1150                 goto exit;
1151         }
1152
1153         /*
1154          * Register extra components.
1155          */
1156         rt2x00leds_register(rt2x00dev);
1157         rt2x00rfkill_allocate(rt2x00dev);
1158         rt2x00debug_register(rt2x00dev);
1159
1160         __set_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1161
1162         return 0;
1163
1164 exit:
1165         rt2x00lib_remove_dev(rt2x00dev);
1166
1167         return retval;
1168 }
1169 EXPORT_SYMBOL_GPL(rt2x00lib_probe_dev);
1170
1171 void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
1172 {
1173         __clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1174
1175         /*
1176          * Disable radio.
1177          */
1178         rt2x00lib_disable_radio(rt2x00dev);
1179
1180         /*
1181          * Uninitialize device.
1182          */
1183         rt2x00lib_uninitialize(rt2x00dev);
1184
1185         /*
1186          * Free extra components
1187          */
1188         rt2x00debug_deregister(rt2x00dev);
1189         rt2x00rfkill_free(rt2x00dev);
1190         rt2x00leds_unregister(rt2x00dev);
1191
1192         /*
1193          * Free ieee80211_hw memory.
1194          */
1195         rt2x00lib_remove_hw(rt2x00dev);
1196
1197         /*
1198          * Free firmware image.
1199          */
1200         rt2x00lib_free_firmware(rt2x00dev);
1201
1202         /*
1203          * Free queue structures.
1204          */
1205         rt2x00queue_free(rt2x00dev);
1206 }
1207 EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev);
1208
1209 /*
1210  * Device state handlers
1211  */
1212 #ifdef CONFIG_PM
1213 int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state)
1214 {
1215         int retval;
1216
1217         NOTICE(rt2x00dev, "Going to sleep.\n");
1218         __clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1219
1220         /*
1221          * Only continue if mac80211 has open interfaces.
1222          */
1223         if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1224                 goto exit;
1225         __set_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags);
1226
1227         /*
1228          * Disable radio.
1229          */
1230         rt2x00lib_stop(rt2x00dev);
1231         rt2x00lib_uninitialize(rt2x00dev);
1232
1233         /*
1234          * Suspend/disable extra components.
1235          */
1236         rt2x00leds_suspend(rt2x00dev);
1237         rt2x00rfkill_suspend(rt2x00dev);
1238         rt2x00debug_deregister(rt2x00dev);
1239
1240 exit:
1241         /*
1242          * Set device mode to sleep for power management,
1243          * on some hardware this call seems to consistently fail.
1244          * From the specifications it is hard to tell why it fails,
1245          * and if this is a "bad thing".
1246          * Overall it is safe to just ignore the failure and
1247          * continue suspending. The only downside is that the
1248          * device will not be in optimal power save mode, but with
1249          * the radio and the other components already disabled the
1250          * device is as good as disabled.
1251          */
1252         retval = rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP);
1253         if (retval)
1254                 WARNING(rt2x00dev, "Device failed to enter sleep state, "
1255                         "continue suspending.\n");
1256
1257         return 0;
1258 }
1259 EXPORT_SYMBOL_GPL(rt2x00lib_suspend);
1260
1261 static void rt2x00lib_resume_intf(void *data, u8 *mac,
1262                                   struct ieee80211_vif *vif)
1263 {
1264         struct rt2x00_dev *rt2x00dev = data;
1265         struct rt2x00_intf *intf = vif_to_intf(vif);
1266
1267         spin_lock(&intf->lock);
1268
1269         rt2x00lib_config_intf(rt2x00dev, intf,
1270                               vif->type, intf->mac, intf->bssid);
1271
1272
1273         /*
1274          * Master or Ad-hoc mode require a new beacon update.
1275          */
1276         if (vif->type == IEEE80211_IF_TYPE_AP ||
1277             vif->type == IEEE80211_IF_TYPE_IBSS)
1278                 intf->delayed_flags |= DELAYED_UPDATE_BEACON;
1279
1280         spin_unlock(&intf->lock);
1281 }
1282
1283 int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
1284 {
1285         int retval;
1286
1287         NOTICE(rt2x00dev, "Waking up.\n");
1288
1289         /*
1290          * Restore/enable extra components.
1291          */
1292         rt2x00debug_register(rt2x00dev);
1293         rt2x00rfkill_resume(rt2x00dev);
1294         rt2x00leds_resume(rt2x00dev);
1295
1296         /*
1297          * Only continue if mac80211 had open interfaces.
1298          */
1299         if (!__test_and_clear_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags))
1300                 return 0;
1301
1302         /*
1303          * Reinitialize device and all active interfaces.
1304          */
1305         retval = rt2x00lib_start(rt2x00dev);
1306         if (retval)
1307                 goto exit;
1308
1309         /*
1310          * Reconfigure device.
1311          */
1312         rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf, 1);
1313         if (!rt2x00dev->hw->conf.radio_enabled)
1314                 rt2x00lib_disable_radio(rt2x00dev);
1315
1316         /*
1317          * Iterator over each active interface to
1318          * reconfigure the hardware.
1319          */
1320         ieee80211_iterate_active_interfaces(rt2x00dev->hw,
1321                                             rt2x00lib_resume_intf, rt2x00dev);
1322
1323         /*
1324          * We are ready again to receive requests from mac80211.
1325          */
1326         __set_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1327
1328         /*
1329          * It is possible that during that mac80211 has attempted
1330          * to send frames while we were suspending or resuming.
1331          * In that case we have disabled the TX queue and should
1332          * now enable it again
1333          */
1334         ieee80211_start_queues(rt2x00dev->hw);
1335
1336         /*
1337          * During interface iteration we might have changed the
1338          * delayed_flags, time to handles the event by calling
1339          * the work handler directly.
1340          */
1341         rt2x00lib_intf_scheduled(&rt2x00dev->intf_work);
1342
1343         return 0;
1344
1345 exit:
1346         rt2x00lib_disable_radio(rt2x00dev);
1347         rt2x00lib_uninitialize(rt2x00dev);
1348         rt2x00debug_deregister(rt2x00dev);
1349
1350         return retval;
1351 }
1352 EXPORT_SYMBOL_GPL(rt2x00lib_resume);
1353 #endif /* CONFIG_PM */
1354
1355 /*
1356  * rt2x00lib module information.
1357  */
1358 MODULE_AUTHOR(DRV_PROJECT);
1359 MODULE_VERSION(DRV_VERSION);
1360 MODULE_DESCRIPTION("rt2x00 library");
1361 MODULE_LICENSE("GPL");