Merge branch 'upstream-next' of master.kernel.org:/pub/scm/linux/kernel/git/jgarzik...
[linux-2.6.git] / 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(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 += txdesc->retry + 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         if (tx_status.control.flags & IEEE80211_TXCTL_USE_RTS_CTS) {
529                 if (success)
530                         rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
531                 else
532                         rt2x00dev->low_level_stats.dot11RTSFailureCount++;
533         }
534
535         /*
536          * Send the tx_status to debugfs. Only send the status report
537          * to mac80211 when the frame originated from there. If this was
538          * a extra frame coming through a mac80211 library call (RTS/CTS)
539          * then we should not send the status report back.
540          * If send to mac80211, mac80211 will clean up the skb structure,
541          * otherwise we have to do it ourself.
542          */
543         skbdesc = get_skb_frame_desc(entry->skb);
544         skbdesc->frame_type = DUMP_FRAME_TXDONE;
545
546         rt2x00debug_dump_frame(rt2x00dev, entry->skb);
547
548         if (!(skbdesc->flags & FRAME_DESC_DRIVER_GENERATED))
549                 ieee80211_tx_status_irqsafe(rt2x00dev->hw,
550                                             entry->skb, &tx_status);
551         else
552                 dev_kfree_skb(entry->skb);
553         entry->skb = NULL;
554 }
555 EXPORT_SYMBOL_GPL(rt2x00lib_txdone);
556
557 void rt2x00lib_rxdone(struct queue_entry *entry,
558                       struct rxdone_entry_desc *rxdesc)
559 {
560         struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
561         struct ieee80211_rx_status *rx_status = &rt2x00dev->rx_status;
562         struct ieee80211_supported_band *sband;
563         struct ieee80211_hdr *hdr;
564         const struct rt2x00_rate *rate;
565         unsigned int i;
566         int idx = -1;
567         u16 fc;
568
569         /*
570          * Update RX statistics.
571          */
572         sband = &rt2x00dev->bands[rt2x00dev->curr_band];
573         for (i = 0; i < sband->n_bitrates; i++) {
574                 rate = rt2x00_get_rate(sband->bitrates[i].hw_value);
575
576                 if (((rxdesc->dev_flags & RXDONE_SIGNAL_PLCP) &&
577                      (rate->plcp == rxdesc->signal)) ||
578                     (!(rxdesc->dev_flags & RXDONE_SIGNAL_PLCP) &&
579                       (rate->bitrate == rxdesc->signal))) {
580                         idx = i;
581                         break;
582                 }
583         }
584
585         if (idx < 0) {
586                 WARNING(rt2x00dev, "Frame received with unrecognized signal,"
587                         "signal=0x%.2x, plcp=%d.\n", rxdesc->signal,
588                         !!(rxdesc->dev_flags & RXDONE_SIGNAL_PLCP));
589                 idx = 0;
590         }
591
592         /*
593          * Only update link status if this is a beacon frame carrying our bssid.
594          */
595         hdr = (struct ieee80211_hdr *)entry->skb->data;
596         fc = le16_to_cpu(hdr->frame_control);
597         if (is_beacon(fc) && (rxdesc->dev_flags & RXDONE_MY_BSS))
598                 rt2x00lib_update_link_stats(&rt2x00dev->link, rxdesc->rssi);
599
600         rt2x00dev->link.qual.rx_success++;
601
602         rx_status->rate_idx = idx;
603         rx_status->signal =
604             rt2x00lib_calculate_link_signal(rt2x00dev, rxdesc->rssi);
605         rx_status->ssi = rxdesc->rssi;
606         rx_status->flag = rxdesc->flags;
607         rx_status->antenna = rt2x00dev->link.ant.active.rx;
608
609         /*
610          * Send frame to mac80211 & debugfs.
611          * mac80211 will clean up the skb structure.
612          */
613         get_skb_frame_desc(entry->skb)->frame_type = DUMP_FRAME_RXDONE;
614         rt2x00debug_dump_frame(rt2x00dev, entry->skb);
615         ieee80211_rx_irqsafe(rt2x00dev->hw, entry->skb, rx_status);
616         entry->skb = NULL;
617 }
618 EXPORT_SYMBOL_GPL(rt2x00lib_rxdone);
619
620 /*
621  * TX descriptor initializer
622  */
623 void rt2x00lib_write_tx_desc(struct rt2x00_dev *rt2x00dev,
624                              struct sk_buff *skb,
625                              struct ieee80211_tx_control *control)
626 {
627         struct txentry_desc txdesc;
628         struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb);
629         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skbdesc->data;
630         const struct rt2x00_rate *rate;
631         int tx_rate;
632         int length;
633         int duration;
634         int residual;
635         u16 frame_control;
636         u16 seq_ctrl;
637
638         memset(&txdesc, 0, sizeof(txdesc));
639
640         txdesc.queue = skbdesc->entry->queue->qid;
641         txdesc.cw_min = skbdesc->entry->queue->cw_min;
642         txdesc.cw_max = skbdesc->entry->queue->cw_max;
643         txdesc.aifs = skbdesc->entry->queue->aifs;
644
645         /*
646          * Read required fields from ieee80211 header.
647          */
648         frame_control = le16_to_cpu(hdr->frame_control);
649         seq_ctrl = le16_to_cpu(hdr->seq_ctrl);
650
651         tx_rate = control->tx_rate->hw_value;
652
653         /*
654          * Check whether this frame is to be acked
655          */
656         if (!(control->flags & IEEE80211_TXCTL_NO_ACK))
657                 __set_bit(ENTRY_TXD_ACK, &txdesc.flags);
658
659         /*
660          * Check if this is a RTS/CTS frame
661          */
662         if (is_rts_frame(frame_control) || is_cts_frame(frame_control)) {
663                 __set_bit(ENTRY_TXD_BURST, &txdesc.flags);
664                 if (is_rts_frame(frame_control)) {
665                         __set_bit(ENTRY_TXD_RTS_FRAME, &txdesc.flags);
666                         __set_bit(ENTRY_TXD_ACK, &txdesc.flags);
667                 } else
668                         __clear_bit(ENTRY_TXD_ACK, &txdesc.flags);
669                 if (control->rts_cts_rate)
670                         tx_rate = control->rts_cts_rate->hw_value;
671         }
672
673         rate = rt2x00_get_rate(tx_rate);
674
675         /*
676          * Check if more fragments are pending
677          */
678         if (ieee80211_get_morefrag(hdr)) {
679                 __set_bit(ENTRY_TXD_BURST, &txdesc.flags);
680                 __set_bit(ENTRY_TXD_MORE_FRAG, &txdesc.flags);
681         }
682
683         /*
684          * Beacons and probe responses require the tsf timestamp
685          * to be inserted into the frame.
686          */
687         if (txdesc.queue == QID_BEACON || is_probe_resp(frame_control))
688                 __set_bit(ENTRY_TXD_REQ_TIMESTAMP, &txdesc.flags);
689
690         /*
691          * Determine with what IFS priority this frame should be send.
692          * Set ifs to IFS_SIFS when the this is not the first fragment,
693          * or this fragment came after RTS/CTS.
694          */
695         if ((seq_ctrl & IEEE80211_SCTL_FRAG) > 0 ||
696             test_bit(ENTRY_TXD_RTS_FRAME, &txdesc.flags))
697                 txdesc.ifs = IFS_SIFS;
698         else
699                 txdesc.ifs = IFS_BACKOFF;
700
701         /*
702          * PLCP setup
703          * Length calculation depends on OFDM/CCK rate.
704          */
705         txdesc.signal = rate->plcp;
706         txdesc.service = 0x04;
707
708         length = skbdesc->data_len + FCS_LEN;
709         if (rate->flags & DEV_RATE_OFDM) {
710                 __set_bit(ENTRY_TXD_OFDM_RATE, &txdesc.flags);
711
712                 txdesc.length_high = (length >> 6) & 0x3f;
713                 txdesc.length_low = length & 0x3f;
714         } else {
715                 /*
716                  * Convert length to microseconds.
717                  */
718                 residual = get_duration_res(length, rate->bitrate);
719                 duration = get_duration(length, rate->bitrate);
720
721                 if (residual != 0) {
722                         duration++;
723
724                         /*
725                          * Check if we need to set the Length Extension
726                          */
727                         if (rate->bitrate == 110 && residual <= 30)
728                                 txdesc.service |= 0x80;
729                 }
730
731                 txdesc.length_high = (duration >> 8) & 0xff;
732                 txdesc.length_low = duration & 0xff;
733
734                 /*
735                  * When preamble is enabled we should set the
736                  * preamble bit for the signal.
737                  */
738                 if (rt2x00_get_rate_preamble(tx_rate))
739                         txdesc.signal |= 0x08;
740         }
741
742         rt2x00dev->ops->lib->write_tx_desc(rt2x00dev, skb, &txdesc, control);
743
744         /*
745          * Update queue entry.
746          */
747         skbdesc->entry->skb = skb;
748
749         /*
750          * The frame has been completely initialized and ready
751          * for sending to the device. The caller will push the
752          * frame to the device, but we are going to push the
753          * frame to debugfs here.
754          */
755         skbdesc->frame_type = DUMP_FRAME_TX;
756         rt2x00debug_dump_frame(rt2x00dev, skb);
757 }
758 EXPORT_SYMBOL_GPL(rt2x00lib_write_tx_desc);
759
760 /*
761  * Driver initialization handlers.
762  */
763 const struct rt2x00_rate rt2x00_supported_rates[12] = {
764         {
765                 .flags = DEV_RATE_CCK | DEV_RATE_BASIC,
766                 .bitrate = 10,
767                 .ratemask = BIT(0),
768                 .plcp = 0x00,
769         },
770         {
771                 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
772                 .bitrate = 20,
773                 .ratemask = BIT(1),
774                 .plcp = 0x01,
775         },
776         {
777                 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
778                 .bitrate = 55,
779                 .ratemask = BIT(2),
780                 .plcp = 0x02,
781         },
782         {
783                 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
784                 .bitrate = 110,
785                 .ratemask = BIT(3),
786                 .plcp = 0x03,
787         },
788         {
789                 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
790                 .bitrate = 60,
791                 .ratemask = BIT(4),
792                 .plcp = 0x0b,
793         },
794         {
795                 .flags = DEV_RATE_OFDM,
796                 .bitrate = 90,
797                 .ratemask = BIT(5),
798                 .plcp = 0x0f,
799         },
800         {
801                 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
802                 .bitrate = 120,
803                 .ratemask = BIT(6),
804                 .plcp = 0x0a,
805         },
806         {
807                 .flags = DEV_RATE_OFDM,
808                 .bitrate = 180,
809                 .ratemask = BIT(7),
810                 .plcp = 0x0e,
811         },
812         {
813                 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
814                 .bitrate = 240,
815                 .ratemask = BIT(8),
816                 .plcp = 0x09,
817         },
818         {
819                 .flags = DEV_RATE_OFDM,
820                 .bitrate = 360,
821                 .ratemask = BIT(9),
822                 .plcp = 0x0d,
823         },
824         {
825                 .flags = DEV_RATE_OFDM,
826                 .bitrate = 480,
827                 .ratemask = BIT(10),
828                 .plcp = 0x08,
829         },
830         {
831                 .flags = DEV_RATE_OFDM,
832                 .bitrate = 540,
833                 .ratemask = BIT(11),
834                 .plcp = 0x0c,
835         },
836 };
837
838 static void rt2x00lib_channel(struct ieee80211_channel *entry,
839                               const int channel, const int tx_power,
840                               const int value)
841 {
842         entry->center_freq = ieee80211_channel_to_frequency(channel);
843         entry->hw_value = value;
844         entry->max_power = tx_power;
845         entry->max_antenna_gain = 0xff;
846 }
847
848 static void rt2x00lib_rate(struct ieee80211_rate *entry,
849                            const u16 index, const struct rt2x00_rate *rate)
850 {
851         entry->flags = 0;
852         entry->bitrate = rate->bitrate;
853         entry->hw_value = rt2x00_create_rate_hw_value(index, 0);
854         entry->hw_value_short = entry->hw_value;
855
856         if (rate->flags & DEV_RATE_SHORT_PREAMBLE) {
857                 entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
858                 entry->hw_value_short |= rt2x00_create_rate_hw_value(index, 1);
859         }
860 }
861
862 static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
863                                     struct hw_mode_spec *spec)
864 {
865         struct ieee80211_hw *hw = rt2x00dev->hw;
866         struct ieee80211_channel *channels;
867         struct ieee80211_rate *rates;
868         unsigned int num_rates;
869         unsigned int i;
870         unsigned char tx_power;
871
872         num_rates = 0;
873         if (spec->supported_rates & SUPPORT_RATE_CCK)
874                 num_rates += 4;
875         if (spec->supported_rates & SUPPORT_RATE_OFDM)
876                 num_rates += 8;
877
878         channels = kzalloc(sizeof(*channels) * spec->num_channels, GFP_KERNEL);
879         if (!channels)
880                 return -ENOMEM;
881
882         rates = kzalloc(sizeof(*rates) * num_rates, GFP_KERNEL);
883         if (!rates)
884                 goto exit_free_channels;
885
886         /*
887          * Initialize Rate list.
888          */
889         for (i = 0; i < num_rates; i++)
890                 rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i));
891
892         /*
893          * Initialize Channel list.
894          */
895         for (i = 0; i < spec->num_channels; i++) {
896                 if (spec->channels[i].channel <= 14) {
897                         if (spec->tx_power_bg)
898                                 tx_power = spec->tx_power_bg[i];
899                         else
900                                 tx_power = spec->tx_power_default;
901                 } else {
902                         if (spec->tx_power_a)
903                                 tx_power = spec->tx_power_a[i];
904                         else
905                                 tx_power = spec->tx_power_default;
906                 }
907
908                 rt2x00lib_channel(&channels[i],
909                                   spec->channels[i].channel, tx_power, i);
910         }
911
912         /*
913          * Intitialize 802.11b, 802.11g
914          * Rates: CCK, OFDM.
915          * Channels: 2.4 GHz
916          */
917         if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
918                 rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_channels = 14;
919                 rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_bitrates = num_rates;
920                 rt2x00dev->bands[IEEE80211_BAND_2GHZ].channels = channels;
921                 rt2x00dev->bands[IEEE80211_BAND_2GHZ].bitrates = rates;
922                 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
923                     &rt2x00dev->bands[IEEE80211_BAND_2GHZ];
924         }
925
926         /*
927          * Intitialize 802.11a
928          * Rates: OFDM.
929          * Channels: OFDM, UNII, HiperLAN2.
930          */
931         if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
932                 rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_channels =
933                     spec->num_channels - 14;
934                 rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_bitrates =
935                     num_rates - 4;
936                 rt2x00dev->bands[IEEE80211_BAND_5GHZ].channels = &channels[14];
937                 rt2x00dev->bands[IEEE80211_BAND_5GHZ].bitrates = &rates[4];
938                 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
939                     &rt2x00dev->bands[IEEE80211_BAND_5GHZ];
940         }
941
942         return 0;
943
944  exit_free_channels:
945         kfree(channels);
946         ERROR(rt2x00dev, "Allocation ieee80211 modes failed.\n");
947         return -ENOMEM;
948 }
949
950 static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
951 {
952         if (test_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags))
953                 ieee80211_unregister_hw(rt2x00dev->hw);
954
955         if (likely(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ])) {
956                 kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
957                 kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->bitrates);
958                 rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
959                 rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
960         }
961 }
962
963 static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
964 {
965         struct hw_mode_spec *spec = &rt2x00dev->spec;
966         int status;
967
968         /*
969          * Initialize HW modes.
970          */
971         status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
972         if (status)
973                 return status;
974
975         /*
976          * Register HW.
977          */
978         status = ieee80211_register_hw(rt2x00dev->hw);
979         if (status) {
980                 rt2x00lib_remove_hw(rt2x00dev);
981                 return status;
982         }
983
984         __set_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags);
985
986         return 0;
987 }
988
989 /*
990  * Initialization/uninitialization handlers.
991  */
992 static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
993 {
994         if (!__test_and_clear_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
995                 return;
996
997         /*
998          * Unregister extra components.
999          */
1000         rt2x00rfkill_unregister(rt2x00dev);
1001
1002         /*
1003          * Allow the HW to uninitialize.
1004          */
1005         rt2x00dev->ops->lib->uninitialize(rt2x00dev);
1006
1007         /*
1008          * Free allocated queue entries.
1009          */
1010         rt2x00queue_uninitialize(rt2x00dev);
1011 }
1012
1013 static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
1014 {
1015         int status;
1016
1017         if (test_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
1018                 return 0;
1019
1020         /*
1021          * Allocate all queue entries.
1022          */
1023         status = rt2x00queue_initialize(rt2x00dev);
1024         if (status)
1025                 return status;
1026
1027         /*
1028          * Initialize the device.
1029          */
1030         status = rt2x00dev->ops->lib->initialize(rt2x00dev);
1031         if (status)
1032                 goto exit;
1033
1034         __set_bit(DEVICE_INITIALIZED, &rt2x00dev->flags);
1035
1036         /*
1037          * Register the extra components.
1038          */
1039         rt2x00rfkill_register(rt2x00dev);
1040
1041         return 0;
1042
1043 exit:
1044         rt2x00lib_uninitialize(rt2x00dev);
1045
1046         return status;
1047 }
1048
1049 int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
1050 {
1051         int retval;
1052
1053         if (test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1054                 return 0;
1055
1056         /*
1057          * If this is the first interface which is added,
1058          * we should load the firmware now.
1059          */
1060         retval = rt2x00lib_load_firmware(rt2x00dev);
1061         if (retval)
1062                 return retval;
1063
1064         /*
1065          * Initialize the device.
1066          */
1067         retval = rt2x00lib_initialize(rt2x00dev);
1068         if (retval)
1069                 return retval;
1070
1071         /*
1072          * Enable radio.
1073          */
1074         retval = rt2x00lib_enable_radio(rt2x00dev);
1075         if (retval) {
1076                 rt2x00lib_uninitialize(rt2x00dev);
1077                 return retval;
1078         }
1079
1080         rt2x00dev->intf_ap_count = 0;
1081         rt2x00dev->intf_sta_count = 0;
1082         rt2x00dev->intf_associated = 0;
1083
1084         __set_bit(DEVICE_STARTED, &rt2x00dev->flags);
1085
1086         return 0;
1087 }
1088
1089 void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
1090 {
1091         if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1092                 return;
1093
1094         /*
1095          * Perhaps we can add something smarter here,
1096          * but for now just disabling the radio should do.
1097          */
1098         rt2x00lib_disable_radio(rt2x00dev);
1099
1100         rt2x00dev->intf_ap_count = 0;
1101         rt2x00dev->intf_sta_count = 0;
1102         rt2x00dev->intf_associated = 0;
1103
1104         __clear_bit(DEVICE_STARTED, &rt2x00dev->flags);
1105 }
1106
1107 /*
1108  * driver allocation handlers.
1109  */
1110 int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
1111 {
1112         int retval = -ENOMEM;
1113
1114         /*
1115          * Make room for rt2x00_intf inside the per-interface
1116          * structure ieee80211_vif.
1117          */
1118         rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf);
1119
1120         /*
1121          * Let the driver probe the device to detect the capabilities.
1122          */
1123         retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
1124         if (retval) {
1125                 ERROR(rt2x00dev, "Failed to allocate device.\n");
1126                 goto exit;
1127         }
1128
1129         /*
1130          * Initialize configuration work.
1131          */
1132         INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
1133         INIT_WORK(&rt2x00dev->filter_work, rt2x00lib_packetfilter_scheduled);
1134         INIT_DELAYED_WORK(&rt2x00dev->link.work, rt2x00lib_link_tuner);
1135
1136         /*
1137          * Allocate queue array.
1138          */
1139         retval = rt2x00queue_allocate(rt2x00dev);
1140         if (retval)
1141                 goto exit;
1142
1143         /*
1144          * Initialize ieee80211 structure.
1145          */
1146         retval = rt2x00lib_probe_hw(rt2x00dev);
1147         if (retval) {
1148                 ERROR(rt2x00dev, "Failed to initialize hw.\n");
1149                 goto exit;
1150         }
1151
1152         /*
1153          * Register extra components.
1154          */
1155         rt2x00leds_register(rt2x00dev);
1156         rt2x00rfkill_allocate(rt2x00dev);
1157         rt2x00debug_register(rt2x00dev);
1158
1159         __set_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1160
1161         return 0;
1162
1163 exit:
1164         rt2x00lib_remove_dev(rt2x00dev);
1165
1166         return retval;
1167 }
1168 EXPORT_SYMBOL_GPL(rt2x00lib_probe_dev);
1169
1170 void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
1171 {
1172         __clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1173
1174         /*
1175          * Disable radio.
1176          */
1177         rt2x00lib_disable_radio(rt2x00dev);
1178
1179         /*
1180          * Uninitialize device.
1181          */
1182         rt2x00lib_uninitialize(rt2x00dev);
1183
1184         /*
1185          * Free extra components
1186          */
1187         rt2x00debug_deregister(rt2x00dev);
1188         rt2x00rfkill_free(rt2x00dev);
1189         rt2x00leds_unregister(rt2x00dev);
1190
1191         /*
1192          * Free ieee80211_hw memory.
1193          */
1194         rt2x00lib_remove_hw(rt2x00dev);
1195
1196         /*
1197          * Free firmware image.
1198          */
1199         rt2x00lib_free_firmware(rt2x00dev);
1200
1201         /*
1202          * Free queue structures.
1203          */
1204         rt2x00queue_free(rt2x00dev);
1205 }
1206 EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev);
1207
1208 /*
1209  * Device state handlers
1210  */
1211 #ifdef CONFIG_PM
1212 int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state)
1213 {
1214         int retval;
1215
1216         NOTICE(rt2x00dev, "Going to sleep.\n");
1217         __clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1218
1219         /*
1220          * Only continue if mac80211 has open interfaces.
1221          */
1222         if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1223                 goto exit;
1224         __set_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags);
1225
1226         /*
1227          * Disable radio.
1228          */
1229         rt2x00lib_stop(rt2x00dev);
1230         rt2x00lib_uninitialize(rt2x00dev);
1231
1232         /*
1233          * Suspend/disable extra components.
1234          */
1235         rt2x00leds_suspend(rt2x00dev);
1236         rt2x00rfkill_suspend(rt2x00dev);
1237         rt2x00debug_deregister(rt2x00dev);
1238
1239 exit:
1240         /*
1241          * Set device mode to sleep for power management,
1242          * on some hardware this call seems to consistently fail.
1243          * From the specifications it is hard to tell why it fails,
1244          * and if this is a "bad thing".
1245          * Overall it is safe to just ignore the failure and
1246          * continue suspending. The only downside is that the
1247          * device will not be in optimal power save mode, but with
1248          * the radio and the other components already disabled the
1249          * device is as good as disabled.
1250          */
1251         retval = rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP);
1252         if (retval)
1253                 WARNING(rt2x00dev, "Device failed to enter sleep state, "
1254                         "continue suspending.\n");
1255
1256         return 0;
1257 }
1258 EXPORT_SYMBOL_GPL(rt2x00lib_suspend);
1259
1260 static void rt2x00lib_resume_intf(void *data, u8 *mac,
1261                                   struct ieee80211_vif *vif)
1262 {
1263         struct rt2x00_dev *rt2x00dev = data;
1264         struct rt2x00_intf *intf = vif_to_intf(vif);
1265
1266         spin_lock(&intf->lock);
1267
1268         rt2x00lib_config_intf(rt2x00dev, intf,
1269                               vif->type, intf->mac, intf->bssid);
1270
1271
1272         /*
1273          * Master or Ad-hoc mode require a new beacon update.
1274          */
1275         if (vif->type == IEEE80211_IF_TYPE_AP ||
1276             vif->type == IEEE80211_IF_TYPE_IBSS)
1277                 intf->delayed_flags |= DELAYED_UPDATE_BEACON;
1278
1279         spin_unlock(&intf->lock);
1280 }
1281
1282 int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
1283 {
1284         int retval;
1285
1286         NOTICE(rt2x00dev, "Waking up.\n");
1287
1288         /*
1289          * Restore/enable extra components.
1290          */
1291         rt2x00debug_register(rt2x00dev);
1292         rt2x00rfkill_resume(rt2x00dev);
1293         rt2x00leds_resume(rt2x00dev);
1294
1295         /*
1296          * Only continue if mac80211 had open interfaces.
1297          */
1298         if (!__test_and_clear_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags))
1299                 return 0;
1300
1301         /*
1302          * Reinitialize device and all active interfaces.
1303          */
1304         retval = rt2x00lib_start(rt2x00dev);
1305         if (retval)
1306                 goto exit;
1307
1308         /*
1309          * Reconfigure device.
1310          */
1311         rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf, 1);
1312         if (!rt2x00dev->hw->conf.radio_enabled)
1313                 rt2x00lib_disable_radio(rt2x00dev);
1314
1315         /*
1316          * Iterator over each active interface to
1317          * reconfigure the hardware.
1318          */
1319         ieee80211_iterate_active_interfaces(rt2x00dev->hw,
1320                                             rt2x00lib_resume_intf, rt2x00dev);
1321
1322         /*
1323          * We are ready again to receive requests from mac80211.
1324          */
1325         __set_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1326
1327         /*
1328          * It is possible that during that mac80211 has attempted
1329          * to send frames while we were suspending or resuming.
1330          * In that case we have disabled the TX queue and should
1331          * now enable it again
1332          */
1333         ieee80211_start_queues(rt2x00dev->hw);
1334
1335         /*
1336          * During interface iteration we might have changed the
1337          * delayed_flags, time to handles the event by calling
1338          * the work handler directly.
1339          */
1340         rt2x00lib_intf_scheduled(&rt2x00dev->intf_work);
1341
1342         return 0;
1343
1344 exit:
1345         rt2x00lib_disable_radio(rt2x00dev);
1346         rt2x00lib_uninitialize(rt2x00dev);
1347         rt2x00debug_deregister(rt2x00dev);
1348
1349         return retval;
1350 }
1351 EXPORT_SYMBOL_GPL(rt2x00lib_resume);
1352 #endif /* CONFIG_PM */
1353
1354 /*
1355  * rt2x00lib module information.
1356  */
1357 MODULE_AUTHOR(DRV_PROJECT);
1358 MODULE_VERSION(DRV_VERSION);
1359 MODULE_DESCRIPTION("rt2x00 library");
1360 MODULE_LICENSE("GPL");