blob: f52e92512f9079a970c7493e71e333c0041c6fd3 [file] [log] [blame]
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001/*
Ivo van Doorn811aa9c2008-02-03 15:42:53 +01002 Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
Ivo van Doorn95ea3622007-09-25 17:57:13 -07003 <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
Ivo van Doorn95ea3622007-09-25 17:57:13 -070026#include <linux/kernel.h>
27#include <linux/module.h>
28
29#include "rt2x00.h"
30#include "rt2x00lib.h"
Ivo van Doorn4d8dd662007-11-27 21:49:29 +010031#include "rt2x00dump.h"
Ivo van Doorn95ea3622007-09-25 17:57:13 -070032
33/*
Ivo van Doorn95ea3622007-09-25 17:57:13 -070034 * Link tuning handlers
35 */
Ivo van Doorn53b3f8e2008-02-25 23:15:13 +010036void rt2x00lib_reset_link_tuner(struct rt2x00_dev *rt2x00dev)
Ivo van Doorn95ea3622007-09-25 17:57:13 -070037{
Ivo van Doorn53b3f8e2008-02-25 23:15:13 +010038 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 */
Ivo van Doorn8de8c512007-10-13 16:26:32 +020049 rt2x00dev->link.count = 0;
50 rt2x00dev->link.vgc_level = 0;
51
Ivo van Doorn53b3f8e2008-02-25 23:15:13 +010052 /*
53 * Reset the link tuner.
54 */
55 rt2x00dev->ops->lib->reset_tuner(rt2x00dev);
56}
57
58static void rt2x00lib_start_link_tuner(struct rt2x00_dev *rt2x00dev)
59{
60 /*
61 * Clear all (possibly) pre-existing quality statistics.
62 */
Ivo van Doorn8de8c512007-10-13 16:26:32 +020063 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;
Ivo van Doorn95ea3622007-09-25 17:57:13 -070075
Ivo van Doorn53b3f8e2008-02-25 23:15:13 +010076 rt2x00lib_reset_link_tuner(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -070077
78 queue_delayed_work(rt2x00dev->hw->workqueue,
79 &rt2x00dev->link.work, LINK_TUNE_INTERVAL);
80}
81
82static void rt2x00lib_stop_link_tuner(struct rt2x00_dev *rt2x00dev)
83{
Ivo van Doorn3e309682007-09-25 20:56:36 +020084 cancel_delayed_work_sync(&rt2x00dev->link.work);
Ivo van Doorn95ea3622007-09-25 17:57:13 -070085}
86
Ivo van Doorn95ea3622007-09-25 17:57:13 -070087/*
88 * Radio control handlers.
89 */
90int 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) ||
Ivo van Doorn81873e92007-10-06 14:14:06 +020099 test_bit(DEVICE_DISABLED_RADIO_HW, &rt2x00dev->flags))
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700100 return 0;
101
102 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500103 * Initialize all data queues.
Ivo van Doorn837e7f22008-01-06 23:41:45 +0100104 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500105 rt2x00queue_init_rx(rt2x00dev);
106 rt2x00queue_init_tx(rt2x00dev);
Ivo van Doorn837e7f22008-01-06 23:41:45 +0100107
108 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700109 * Enable radio.
110 */
111 status = rt2x00dev->ops->lib->set_device_state(rt2x00dev,
112 STATE_RADIO_ON);
113 if (status)
114 return status;
115
116 __set_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags);
117
118 /*
119 * Enable RX.
120 */
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200121 rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_ON);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700122
123 /*
124 * Start the TX queues.
125 */
126 ieee80211_start_queues(rt2x00dev->hw);
127
128 return 0;
129}
130
131void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
132{
133 if (!__test_and_clear_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
134 return;
135
136 /*
Johannes Berg4150c572007-09-17 01:29:23 -0400137 * Stop all scheduled work.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700138 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100139 if (work_pending(&rt2x00dev->intf_work))
140 cancel_work_sync(&rt2x00dev->intf_work);
Johannes Berg4150c572007-09-17 01:29:23 -0400141 if (work_pending(&rt2x00dev->filter_work))
142 cancel_work_sync(&rt2x00dev->filter_work);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700143
144 /*
145 * Stop the TX queues.
146 */
147 ieee80211_stop_queues(rt2x00dev->hw);
148
149 /*
150 * Disable RX.
151 */
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200152 rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_OFF);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700153
154 /*
155 * Disable radio.
156 */
157 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF);
158}
159
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200160void rt2x00lib_toggle_rx(struct rt2x00_dev *rt2x00dev, enum dev_state state)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700161{
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700162 /*
163 * When we are disabling the RX, we should also stop the link tuner.
164 */
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200165 if (state == STATE_RADIO_RX_OFF)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700166 rt2x00lib_stop_link_tuner(rt2x00dev);
167
168 rt2x00dev->ops->lib->set_device_state(rt2x00dev, state);
169
170 /*
171 * When we are enabling the RX, we should also start the link tuner.
172 */
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200173 if (state == STATE_RADIO_RX_ON &&
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100174 (rt2x00dev->intf_ap_count || rt2x00dev->intf_sta_count))
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700175 rt2x00lib_start_link_tuner(rt2x00dev);
176}
177
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200178static void rt2x00lib_evaluate_antenna_sample(struct rt2x00_dev *rt2x00dev)
179{
180 enum antenna rx = rt2x00dev->link.ant.active.rx;
181 enum antenna tx = rt2x00dev->link.ant.active.tx;
182 int sample_a =
183 rt2x00_get_link_ant_rssi_history(&rt2x00dev->link, ANTENNA_A);
184 int sample_b =
185 rt2x00_get_link_ant_rssi_history(&rt2x00dev->link, ANTENNA_B);
186
187 /*
188 * We are done sampling. Now we should evaluate the results.
189 */
190 rt2x00dev->link.ant.flags &= ~ANTENNA_MODE_SAMPLE;
191
192 /*
193 * During the last period we have sampled the RSSI
194 * from both antenna's. It now is time to determine
195 * which antenna demonstrated the best performance.
196 * When we are already on the antenna with the best
197 * performance, then there really is nothing for us
198 * left to do.
199 */
200 if (sample_a == sample_b)
201 return;
202
Ivo van Doorn05253c92008-02-25 23:15:08 +0100203 if (rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY)
204 rx = (sample_a > sample_b) ? ANTENNA_A : ANTENNA_B;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200205
Ivo van Doorn05253c92008-02-25 23:15:08 +0100206 if (rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)
207 tx = (sample_a > sample_b) ? ANTENNA_A : ANTENNA_B;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200208
209 rt2x00lib_config_antenna(rt2x00dev, rx, tx);
210}
211
212static void rt2x00lib_evaluate_antenna_eval(struct rt2x00_dev *rt2x00dev)
213{
214 enum antenna rx = rt2x00dev->link.ant.active.rx;
215 enum antenna tx = rt2x00dev->link.ant.active.tx;
216 int rssi_curr = rt2x00_get_link_ant_rssi(&rt2x00dev->link);
217 int rssi_old = rt2x00_update_ant_rssi(&rt2x00dev->link, rssi_curr);
218
219 /*
220 * Legacy driver indicates that we should swap antenna's
221 * when the difference in RSSI is greater that 5. This
222 * also should be done when the RSSI was actually better
223 * then the previous sample.
224 * When the difference exceeds the threshold we should
225 * sample the rssi from the other antenna to make a valid
226 * comparison between the 2 antennas.
227 */
Ivo van Doornb290d432008-02-25 23:15:01 +0100228 if (abs(rssi_curr - rssi_old) < 5)
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200229 return;
230
231 rt2x00dev->link.ant.flags |= ANTENNA_MODE_SAMPLE;
232
233 if (rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY)
234 rx = (rx == ANTENNA_A) ? ANTENNA_B : ANTENNA_A;
235
236 if (rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)
237 tx = (tx == ANTENNA_A) ? ANTENNA_B : ANTENNA_A;
238
239 rt2x00lib_config_antenna(rt2x00dev, rx, tx);
240}
241
242static void rt2x00lib_evaluate_antenna(struct rt2x00_dev *rt2x00dev)
243{
244 /*
245 * Determine if software diversity is enabled for
246 * either the TX or RX antenna (or both).
247 * Always perform this check since within the link
248 * tuner interval the configuration might have changed.
249 */
250 rt2x00dev->link.ant.flags &= ~ANTENNA_RX_DIVERSITY;
251 rt2x00dev->link.ant.flags &= ~ANTENNA_TX_DIVERSITY;
252
253 if (rt2x00dev->hw->conf.antenna_sel_rx == 0 &&
Ivo van Doornb290d432008-02-25 23:15:01 +0100254 rt2x00dev->default_ant.rx == ANTENNA_SW_DIVERSITY)
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200255 rt2x00dev->link.ant.flags |= ANTENNA_RX_DIVERSITY;
256 if (rt2x00dev->hw->conf.antenna_sel_tx == 0 &&
Ivo van Doornb290d432008-02-25 23:15:01 +0100257 rt2x00dev->default_ant.tx == ANTENNA_SW_DIVERSITY)
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200258 rt2x00dev->link.ant.flags |= ANTENNA_TX_DIVERSITY;
259
260 if (!(rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY) &&
261 !(rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)) {
Ivo van Doorn05253c92008-02-25 23:15:08 +0100262 rt2x00dev->link.ant.flags = 0;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200263 return;
264 }
265
266 /*
267 * If we have only sampled the data over the last period
268 * we should now harvest the data. Otherwise just evaluate
269 * the data. The latter should only be performed once
270 * every 2 seconds.
271 */
272 if (rt2x00dev->link.ant.flags & ANTENNA_MODE_SAMPLE)
273 rt2x00lib_evaluate_antenna_sample(rt2x00dev);
274 else if (rt2x00dev->link.count & 1)
275 rt2x00lib_evaluate_antenna_eval(rt2x00dev);
276}
277
278static void rt2x00lib_update_link_stats(struct link *link, int rssi)
279{
280 int avg_rssi = rssi;
281
282 /*
283 * Update global RSSI
284 */
285 if (link->qual.avg_rssi)
286 avg_rssi = MOVING_AVERAGE(link->qual.avg_rssi, rssi, 8);
287 link->qual.avg_rssi = avg_rssi;
288
289 /*
290 * Update antenna RSSI
291 */
292 if (link->ant.rssi_ant)
293 rssi = MOVING_AVERAGE(link->ant.rssi_ant, rssi, 8);
294 link->ant.rssi_ant = rssi;
295}
296
Ivo van Doornebcf26da2007-10-13 16:26:12 +0200297static void rt2x00lib_precalculate_link_signal(struct link_qual *qual)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700298{
Ivo van Doornebcf26da2007-10-13 16:26:12 +0200299 if (qual->rx_failed || qual->rx_success)
300 qual->rx_percentage =
301 (qual->rx_success * 100) /
302 (qual->rx_failed + qual->rx_success);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700303 else
Ivo van Doornebcf26da2007-10-13 16:26:12 +0200304 qual->rx_percentage = 50;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700305
Ivo van Doornebcf26da2007-10-13 16:26:12 +0200306 if (qual->tx_failed || qual->tx_success)
307 qual->tx_percentage =
308 (qual->tx_success * 100) /
309 (qual->tx_failed + qual->tx_success);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700310 else
Ivo van Doornebcf26da2007-10-13 16:26:12 +0200311 qual->tx_percentage = 50;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700312
Ivo van Doornebcf26da2007-10-13 16:26:12 +0200313 qual->rx_success = 0;
314 qual->rx_failed = 0;
315 qual->tx_success = 0;
316 qual->tx_failed = 0;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700317}
318
319static int rt2x00lib_calculate_link_signal(struct rt2x00_dev *rt2x00dev,
320 int rssi)
321{
322 int rssi_percentage = 0;
323 int signal;
324
325 /*
326 * We need a positive value for the RSSI.
327 */
328 if (rssi < 0)
329 rssi += rt2x00dev->rssi_offset;
330
331 /*
332 * Calculate the different percentages,
333 * which will be used for the signal.
334 */
335 if (rt2x00dev->rssi_offset)
336 rssi_percentage = (rssi * 100) / rt2x00dev->rssi_offset;
337
338 /*
339 * Add the individual percentages and use the WEIGHT
340 * defines to calculate the current link signal.
341 */
342 signal = ((WEIGHT_RSSI * rssi_percentage) +
Ivo van Doornebcf26da2007-10-13 16:26:12 +0200343 (WEIGHT_TX * rt2x00dev->link.qual.tx_percentage) +
344 (WEIGHT_RX * rt2x00dev->link.qual.rx_percentage)) / 100;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700345
346 return (signal > 100) ? 100 : signal;
347}
348
349static void rt2x00lib_link_tuner(struct work_struct *work)
350{
351 struct rt2x00_dev *rt2x00dev =
352 container_of(work, struct rt2x00_dev, link.work.work);
353
354 /*
Ivo van Doorn25ab0022007-09-25 20:57:04 +0200355 * When the radio is shutting down we should
356 * immediately cease all link tuning.
357 */
358 if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
359 return;
360
361 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700362 * Update statistics.
363 */
Ivo van Doornebcf26da2007-10-13 16:26:12 +0200364 rt2x00dev->ops->lib->link_stats(rt2x00dev, &rt2x00dev->link.qual);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700365 rt2x00dev->low_level_stats.dot11FCSErrorCount +=
Ivo van Doornebcf26da2007-10-13 16:26:12 +0200366 rt2x00dev->link.qual.rx_failed;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700367
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700368 /*
369 * Only perform the link tuning when Link tuning
370 * has been enabled (This could have been disabled from the EEPROM).
371 */
372 if (!test_bit(CONFIG_DISABLE_LINK_TUNING, &rt2x00dev->flags))
373 rt2x00dev->ops->lib->link_tuner(rt2x00dev);
374
375 /*
Ivo van Doorn725d99d2007-09-25 20:53:20 +0200376 * Precalculate a portion of the link signal which is
377 * in based on the tx/rx success/failure counters.
378 */
Ivo van Doornebcf26da2007-10-13 16:26:12 +0200379 rt2x00lib_precalculate_link_signal(&rt2x00dev->link.qual);
Ivo van Doorn725d99d2007-09-25 20:53:20 +0200380
381 /*
Ivo van Doorna9450b72008-02-03 15:53:40 +0100382 * Send a signal to the led to update the led signal strength.
383 */
384 rt2x00leds_led_quality(rt2x00dev, rt2x00dev->link.qual.avg_rssi);
385
386 /*
Ivo van Doorn53b3f8e2008-02-25 23:15:13 +0100387 * Evaluate antenna setup, make this the last step since this could
388 * possibly reset some statistics.
389 */
390 rt2x00lib_evaluate_antenna(rt2x00dev);
391
392 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700393 * Increase tuner counter, and reschedule the next link tuner run.
394 */
395 rt2x00dev->link.count++;
396 queue_delayed_work(rt2x00dev->hw->workqueue, &rt2x00dev->link.work,
397 LINK_TUNE_INTERVAL);
398}
399
Johannes Berg4150c572007-09-17 01:29:23 -0400400static void rt2x00lib_packetfilter_scheduled(struct work_struct *work)
401{
402 struct rt2x00_dev *rt2x00dev =
403 container_of(work, struct rt2x00_dev, filter_work);
Ivo van Doorn3c4f2082008-01-06 23:40:49 +0100404 unsigned int filter = rt2x00dev->packet_filter;
Ivo van Doorn5886d0d2007-10-06 14:13:38 +0200405
406 /*
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100407 * Since we had stored the filter inside rt2x00dev->packet_filter,
Ivo van Doorn5886d0d2007-10-06 14:13:38 +0200408 * we should now clear that field. Otherwise the driver will
409 * assume nothing has changed (*total_flags will be compared
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100410 * to rt2x00dev->packet_filter to determine if any action is required).
Ivo van Doorn5886d0d2007-10-06 14:13:38 +0200411 */
Ivo van Doorn3c4f2082008-01-06 23:40:49 +0100412 rt2x00dev->packet_filter = 0;
Johannes Berg4150c572007-09-17 01:29:23 -0400413
414 rt2x00dev->ops->hw->configure_filter(rt2x00dev->hw,
Ivo van Doorn5886d0d2007-10-06 14:13:38 +0200415 filter, &filter, 0, NULL);
Johannes Berg4150c572007-09-17 01:29:23 -0400416}
417
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100418static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
419 struct ieee80211_vif *vif)
Ivo van Doorn5c58ee52007-10-06 13:34:52 +0200420{
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100421 struct rt2x00_dev *rt2x00dev = data;
422 struct rt2x00_intf *intf = vif_to_intf(vif);
423 struct sk_buff *skb;
424 struct ieee80211_tx_control control;
425 struct ieee80211_bss_conf conf;
426 int delayed_flags;
Johannes Berg471b3ef2007-12-28 14:32:58 +0100427
428 /*
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100429 * Copy all data we need during this action under the protection
430 * of a spinlock. Otherwise race conditions might occur which results
431 * into an invalid configuration.
Johannes Berg471b3ef2007-12-28 14:32:58 +0100432 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100433 spin_lock(&intf->lock);
434
435 memcpy(&conf, &intf->conf, sizeof(conf));
436 delayed_flags = intf->delayed_flags;
437 intf->delayed_flags = 0;
438
439 spin_unlock(&intf->lock);
440
441 if (delayed_flags & DELAYED_UPDATE_BEACON) {
442 skb = ieee80211_beacon_get(rt2x00dev->hw, vif, &control);
443 if (skb) {
444 rt2x00dev->ops->hw->beacon_update(rt2x00dev->hw, skb,
445 &control);
446 dev_kfree_skb(skb);
447 }
448 }
449
Ivo van Doorn72810372008-03-09 22:46:18 +0100450 if (delayed_flags & DELAYED_CONFIG_ERP)
451 rt2x00lib_config_erp(rt2x00dev, intf, &intf->conf);
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100452}
453
454static void rt2x00lib_intf_scheduled(struct work_struct *work)
455{
456 struct rt2x00_dev *rt2x00dev =
457 container_of(work, struct rt2x00_dev, intf_work);
458
459 /*
460 * Iterate over each interface and perform the
461 * requested configurations.
462 */
463 ieee80211_iterate_active_interfaces(rt2x00dev->hw,
464 rt2x00lib_intf_scheduled_iter,
465 rt2x00dev);
Ivo van Doorn5c58ee52007-10-06 13:34:52 +0200466}
467
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700468/*
469 * Interrupt context handlers.
470 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100471static void rt2x00lib_beacondone_iter(void *data, u8 *mac,
472 struct ieee80211_vif *vif)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700473{
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100474 struct rt2x00_intf *intf = vif_to_intf(vif);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700475
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100476 if (vif->type != IEEE80211_IF_TYPE_AP &&
477 vif->type != IEEE80211_IF_TYPE_IBSS)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700478 return;
479
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100480 spin_lock(&intf->lock);
481 intf->delayed_flags |= DELAYED_UPDATE_BEACON;
482 spin_unlock(&intf->lock);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700483}
484
485void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
486{
487 if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
488 return;
489
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100490 ieee80211_iterate_active_interfaces(rt2x00dev->hw,
491 rt2x00lib_beacondone_iter,
492 rt2x00dev);
493
494 queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->intf_work);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700495}
496EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);
497
Ivo van Doorn181d6902008-02-05 16:42:23 -0500498void rt2x00lib_txdone(struct queue_entry *entry,
499 struct txdone_entry_desc *txdesc)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700500{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500501 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
Ivo van Doornbaf26a72008-02-17 17:32:08 +0100502 struct skb_frame_desc *skbdesc;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500503 struct ieee80211_tx_status tx_status;
504 int success = !!(txdesc->status == TX_SUCCESS ||
505 txdesc->status == TX_SUCCESS_RETRY);
506 int fail = !!(txdesc->status == TX_FAIL_RETRY ||
507 txdesc->status == TX_FAIL_INVALID ||
508 txdesc->status == TX_FAIL_OTHER);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700509
510 /*
511 * Update TX statistics.
512 */
Ivo van Doornebcf26da2007-10-13 16:26:12 +0200513 rt2x00dev->link.qual.tx_success += success;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500514 rt2x00dev->link.qual.tx_failed += txdesc->retry + fail;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700515
Ivo van Doorn181d6902008-02-05 16:42:23 -0500516 /*
517 * Initialize TX status
518 */
519 tx_status.flags = 0;
520 tx_status.ack_signal = 0;
521 tx_status.excessive_retries = (txdesc->status == TX_FAIL_RETRY);
522 tx_status.retry_count = txdesc->retry;
Mattias Nissler95db4d42008-03-09 22:39:32 +0100523 memcpy(&tx_status.control, txdesc->control, sizeof(*txdesc->control));
Ivo van Doorn181d6902008-02-05 16:42:23 -0500524
525 if (!(tx_status.control.flags & IEEE80211_TXCTL_NO_ACK)) {
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700526 if (success)
Ivo van Doorn181d6902008-02-05 16:42:23 -0500527 tx_status.flags |= IEEE80211_TX_STATUS_ACK;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700528 else
Ivo van Doorn181d6902008-02-05 16:42:23 -0500529 rt2x00dev->low_level_stats.dot11ACKFailureCount++;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700530 }
531
Ivo van Doorn181d6902008-02-05 16:42:23 -0500532 tx_status.queue_length = entry->queue->limit;
533 tx_status.queue_number = tx_status.control.queue;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700534
Ivo van Doorn181d6902008-02-05 16:42:23 -0500535 if (tx_status.control.flags & IEEE80211_TXCTL_USE_RTS_CTS) {
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700536 if (success)
Ivo van Doorn181d6902008-02-05 16:42:23 -0500537 rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700538 else
Ivo van Doorn181d6902008-02-05 16:42:23 -0500539 rt2x00dev->low_level_stats.dot11RTSFailureCount++;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700540 }
541
542 /*
Ivo van Doornbaf26a72008-02-17 17:32:08 +0100543 * Send the tx_status to debugfs. Only send the status report
544 * to mac80211 when the frame originated from there. If this was
545 * a extra frame coming through a mac80211 library call (RTS/CTS)
546 * then we should not send the status report back.
547 * If send to mac80211, mac80211 will clean up the skb structure,
548 * otherwise we have to do it ourself.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700549 */
Ivo van Doornbaf26a72008-02-17 17:32:08 +0100550 skbdesc = get_skb_frame_desc(entry->skb);
551 skbdesc->frame_type = DUMP_FRAME_TXDONE;
552
Ivo van Doorn4d8dd662007-11-27 21:49:29 +0100553 rt2x00debug_dump_frame(rt2x00dev, entry->skb);
Ivo van Doornbaf26a72008-02-17 17:32:08 +0100554
555 if (!(skbdesc->flags & FRAME_DESC_DRIVER_GENERATED))
556 ieee80211_tx_status_irqsafe(rt2x00dev->hw,
557 entry->skb, &tx_status);
558 else
559 dev_kfree_skb(entry->skb);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700560 entry->skb = NULL;
561}
562EXPORT_SYMBOL_GPL(rt2x00lib_txdone);
563
Ivo van Doorn181d6902008-02-05 16:42:23 -0500564void rt2x00lib_rxdone(struct queue_entry *entry,
565 struct rxdone_entry_desc *rxdesc)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700566{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500567 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700568 struct ieee80211_rx_status *rx_status = &rt2x00dev->rx_status;
Johannes Berg8318d782008-01-24 19:38:38 +0100569 struct ieee80211_supported_band *sband;
Mattias Nissler61af43c2007-11-27 21:50:26 +0100570 struct ieee80211_hdr *hdr;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100571 const struct rt2x00_rate *rate;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700572 unsigned int i;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100573 int idx = -1;
Mattias Nissler61af43c2007-11-27 21:50:26 +0100574 u16 fc;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700575
576 /*
577 * Update RX statistics.
578 */
Johannes Berg8318d782008-01-24 19:38:38 +0100579 sband = &rt2x00dev->bands[rt2x00dev->curr_band];
580 for (i = 0; i < sband->n_bitrates; i++) {
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100581 rate = rt2x00_get_rate(sband->bitrates[i].hw_value);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700582
Ivo van Doorn19d30e02008-03-15 21:38:07 +0100583 if (((rxdesc->dev_flags & RXDONE_SIGNAL_PLCP) &&
584 (rate->plcp == rxdesc->signal)) ||
585 (!(rxdesc->dev_flags & RXDONE_SIGNAL_PLCP) &&
586 (rate->bitrate == rxdesc->signal))) {
Johannes Berg8318d782008-01-24 19:38:38 +0100587 idx = i;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700588 break;
589 }
590 }
591
Ivo van Doorn866a0502008-03-25 14:12:45 +0100592 if (idx < 0) {
593 WARNING(rt2x00dev, "Frame received with unrecognized signal,"
594 "signal=0x%.2x, plcp=%d.\n", rxdesc->signal,
595 !!(rxdesc->dev_flags & RXDONE_SIGNAL_PLCP));
596 idx = 0;
597 }
598
Mattias Nissler61af43c2007-11-27 21:50:26 +0100599 /*
Ivo van Doorn7e56d382008-01-06 23:41:28 +0100600 * Only update link status if this is a beacon frame carrying our bssid.
Mattias Nissler61af43c2007-11-27 21:50:26 +0100601 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100602 hdr = (struct ieee80211_hdr *)entry->skb->data;
Ivo van Doorn7e56d382008-01-06 23:41:28 +0100603 fc = le16_to_cpu(hdr->frame_control);
Ivo van Doorn19d30e02008-03-15 21:38:07 +0100604 if (is_beacon(fc) && (rxdesc->dev_flags & RXDONE_MY_BSS))
Ivo van Doorn181d6902008-02-05 16:42:23 -0500605 rt2x00lib_update_link_stats(&rt2x00dev->link, rxdesc->rssi);
Mattias Nissler61af43c2007-11-27 21:50:26 +0100606
Ivo van Doornebcf26da2007-10-13 16:26:12 +0200607 rt2x00dev->link.qual.rx_success++;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200608
Johannes Berg8318d782008-01-24 19:38:38 +0100609 rx_status->rate_idx = idx;
Johannes Berg4150c572007-09-17 01:29:23 -0400610 rx_status->signal =
Ivo van Doorn181d6902008-02-05 16:42:23 -0500611 rt2x00lib_calculate_link_signal(rt2x00dev, rxdesc->rssi);
612 rx_status->ssi = rxdesc->rssi;
613 rx_status->flag = rxdesc->flags;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200614 rx_status->antenna = rt2x00dev->link.ant.active.rx;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700615
616 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500617 * Send frame to mac80211 & debugfs.
618 * mac80211 will clean up the skb structure.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700619 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500620 get_skb_frame_desc(entry->skb)->frame_type = DUMP_FRAME_RXDONE;
621 rt2x00debug_dump_frame(rt2x00dev, entry->skb);
622 ieee80211_rx_irqsafe(rt2x00dev->hw, entry->skb, rx_status);
623 entry->skb = NULL;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700624}
625EXPORT_SYMBOL_GPL(rt2x00lib_rxdone);
626
627/*
628 * TX descriptor initializer
629 */
630void rt2x00lib_write_tx_desc(struct rt2x00_dev *rt2x00dev,
Ivo van Doorn08992f72008-01-24 01:56:25 -0800631 struct sk_buff *skb,
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700632 struct ieee80211_tx_control *control)
633{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500634 struct txentry_desc txdesc;
635 struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb);
Ivo van Doorn3976ae62008-03-09 22:41:53 +0100636 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skbdesc->data;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100637 const struct rt2x00_rate *rate;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700638 int tx_rate;
Ivo van Doorn08992f72008-01-24 01:56:25 -0800639 int length;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700640 int duration;
641 int residual;
642 u16 frame_control;
643 u16 seq_ctrl;
644
Ivo van Doorn181d6902008-02-05 16:42:23 -0500645 memset(&txdesc, 0, sizeof(txdesc));
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700646
Ivo van Doorn091ed312008-02-03 15:52:21 +0100647 txdesc.queue = skbdesc->entry->queue->qid;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500648 txdesc.cw_min = skbdesc->entry->queue->cw_min;
649 txdesc.cw_max = skbdesc->entry->queue->cw_max;
650 txdesc.aifs = skbdesc->entry->queue->aifs;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700651
652 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700653 * Read required fields from ieee80211 header.
654 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100655 frame_control = le16_to_cpu(hdr->frame_control);
656 seq_ctrl = le16_to_cpu(hdr->seq_ctrl);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700657
Johannes Berg8318d782008-01-24 19:38:38 +0100658 tx_rate = control->tx_rate->hw_value;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700659
660 /*
Mattias Nissler2700f8b2007-10-27 13:43:49 +0200661 * Check whether this frame is to be acked
662 */
663 if (!(control->flags & IEEE80211_TXCTL_NO_ACK))
Ivo van Doorn181d6902008-02-05 16:42:23 -0500664 __set_bit(ENTRY_TXD_ACK, &txdesc.flags);
Mattias Nissler2700f8b2007-10-27 13:43:49 +0200665
666 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700667 * Check if this is a RTS/CTS frame
668 */
669 if (is_rts_frame(frame_control) || is_cts_frame(frame_control)) {
Ivo van Doorn181d6902008-02-05 16:42:23 -0500670 __set_bit(ENTRY_TXD_BURST, &txdesc.flags);
Mattias Nissler2700f8b2007-10-27 13:43:49 +0200671 if (is_rts_frame(frame_control)) {
Ivo van Doorn181d6902008-02-05 16:42:23 -0500672 __set_bit(ENTRY_TXD_RTS_FRAME, &txdesc.flags);
673 __set_bit(ENTRY_TXD_ACK, &txdesc.flags);
Mattias Nissler2700f8b2007-10-27 13:43:49 +0200674 } else
Ivo van Doorn181d6902008-02-05 16:42:23 -0500675 __clear_bit(ENTRY_TXD_ACK, &txdesc.flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700676 if (control->rts_cts_rate)
Johannes Berg8318d782008-01-24 19:38:38 +0100677 tx_rate = control->rts_cts_rate->hw_value;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700678 }
679
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100680 rate = rt2x00_get_rate(tx_rate);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700681
682 /*
683 * Check if more fragments are pending
684 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100685 if (ieee80211_get_morefrag(hdr)) {
Ivo van Doorn181d6902008-02-05 16:42:23 -0500686 __set_bit(ENTRY_TXD_BURST, &txdesc.flags);
687 __set_bit(ENTRY_TXD_MORE_FRAG, &txdesc.flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700688 }
689
690 /*
691 * Beacons and probe responses require the tsf timestamp
692 * to be inserted into the frame.
693 */
Ivo van Doorn5957da42008-02-03 15:54:57 +0100694 if (control->queue == RT2X00_BCN_QUEUE_BEACON ||
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700695 is_probe_resp(frame_control))
Ivo van Doorn181d6902008-02-05 16:42:23 -0500696 __set_bit(ENTRY_TXD_REQ_TIMESTAMP, &txdesc.flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700697
698 /*
699 * Determine with what IFS priority this frame should be send.
700 * Set ifs to IFS_SIFS when the this is not the first fragment,
701 * or this fragment came after RTS/CTS.
702 */
703 if ((seq_ctrl & IEEE80211_SCTL_FRAG) > 0 ||
Ivo van Doorn181d6902008-02-05 16:42:23 -0500704 test_bit(ENTRY_TXD_RTS_FRAME, &txdesc.flags))
705 txdesc.ifs = IFS_SIFS;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700706 else
Ivo van Doorn181d6902008-02-05 16:42:23 -0500707 txdesc.ifs = IFS_BACKOFF;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700708
709 /*
710 * PLCP setup
711 * Length calculation depends on OFDM/CCK rate.
712 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100713 txdesc.signal = rate->plcp;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500714 txdesc.service = 0x04;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700715
Ivo van Doorn3976ae62008-03-09 22:41:53 +0100716 length = skbdesc->data_len + FCS_LEN;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100717 if (rate->flags & DEV_RATE_OFDM) {
718 __set_bit(ENTRY_TXD_OFDM_RATE, &txdesc.flags);
719
Ivo van Doorn181d6902008-02-05 16:42:23 -0500720 txdesc.length_high = (length >> 6) & 0x3f;
721 txdesc.length_low = length & 0x3f;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700722 } else {
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700723 /*
724 * Convert length to microseconds.
725 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100726 residual = get_duration_res(length, rate->bitrate);
727 duration = get_duration(length, rate->bitrate);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700728
729 if (residual != 0) {
730 duration++;
731
732 /*
733 * Check if we need to set the Length Extension
734 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100735 if (rate->bitrate == 110 && residual <= 30)
Ivo van Doorn181d6902008-02-05 16:42:23 -0500736 txdesc.service |= 0x80;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700737 }
738
Ivo van Doorn181d6902008-02-05 16:42:23 -0500739 txdesc.length_high = (duration >> 8) & 0xff;
740 txdesc.length_low = duration & 0xff;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700741
742 /*
743 * When preamble is enabled we should set the
744 * preamble bit for the signal.
745 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100746 if (rt2x00_get_rate_preamble(tx_rate))
Ivo van Doorn181d6902008-02-05 16:42:23 -0500747 txdesc.signal |= 0x08;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700748 }
749
Ivo van Doorn181d6902008-02-05 16:42:23 -0500750 rt2x00dev->ops->lib->write_tx_desc(rt2x00dev, skb, &txdesc, control);
Ivo van Doorn08992f72008-01-24 01:56:25 -0800751
752 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500753 * Update queue entry.
Ivo van Doorn08992f72008-01-24 01:56:25 -0800754 */
755 skbdesc->entry->skb = skb;
Ivo van Doorn4d8dd662007-11-27 21:49:29 +0100756
757 /*
758 * The frame has been completely initialized and ready
759 * for sending to the device. The caller will push the
760 * frame to the device, but we are going to push the
761 * frame to debugfs here.
762 */
763 skbdesc->frame_type = DUMP_FRAME_TX;
764 rt2x00debug_dump_frame(rt2x00dev, skb);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700765}
766EXPORT_SYMBOL_GPL(rt2x00lib_write_tx_desc);
767
768/*
769 * Driver initialization handlers.
770 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100771const struct rt2x00_rate rt2x00_supported_rates[12] = {
772 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100773 .flags = DEV_RATE_CCK | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100774 .bitrate = 10,
Ivo van Doornaa776722008-03-09 22:48:08 +0100775 .ratemask = BIT(0),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100776 .plcp = 0x00,
777 },
778 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100779 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100780 .bitrate = 20,
Ivo van Doornaa776722008-03-09 22:48:08 +0100781 .ratemask = BIT(1),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100782 .plcp = 0x01,
783 },
784 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100785 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100786 .bitrate = 55,
Ivo van Doornaa776722008-03-09 22:48:08 +0100787 .ratemask = BIT(2),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100788 .plcp = 0x02,
789 },
790 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100791 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100792 .bitrate = 110,
Ivo van Doornaa776722008-03-09 22:48:08 +0100793 .ratemask = BIT(3),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100794 .plcp = 0x03,
795 },
796 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100797 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100798 .bitrate = 60,
Ivo van Doornaa776722008-03-09 22:48:08 +0100799 .ratemask = BIT(4),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100800 .plcp = 0x0b,
801 },
802 {
803 .flags = DEV_RATE_OFDM,
804 .bitrate = 90,
Ivo van Doornaa776722008-03-09 22:48:08 +0100805 .ratemask = BIT(5),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100806 .plcp = 0x0f,
807 },
808 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100809 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100810 .bitrate = 120,
Ivo van Doornaa776722008-03-09 22:48:08 +0100811 .ratemask = BIT(6),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100812 .plcp = 0x0a,
813 },
814 {
815 .flags = DEV_RATE_OFDM,
816 .bitrate = 180,
Ivo van Doornaa776722008-03-09 22:48:08 +0100817 .ratemask = BIT(7),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100818 .plcp = 0x0e,
819 },
820 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100821 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100822 .bitrate = 240,
Ivo van Doornaa776722008-03-09 22:48:08 +0100823 .ratemask = BIT(8),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100824 .plcp = 0x09,
825 },
826 {
827 .flags = DEV_RATE_OFDM,
828 .bitrate = 360,
Ivo van Doornaa776722008-03-09 22:48:08 +0100829 .ratemask = BIT(9),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100830 .plcp = 0x0d,
831 },
832 {
833 .flags = DEV_RATE_OFDM,
834 .bitrate = 480,
Ivo van Doornaa776722008-03-09 22:48:08 +0100835 .ratemask = BIT(10),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100836 .plcp = 0x08,
837 },
838 {
839 .flags = DEV_RATE_OFDM,
840 .bitrate = 540,
Ivo van Doornaa776722008-03-09 22:48:08 +0100841 .ratemask = BIT(11),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100842 .plcp = 0x0c,
843 },
844};
845
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700846static void rt2x00lib_channel(struct ieee80211_channel *entry,
847 const int channel, const int tx_power,
848 const int value)
849{
Ivo van Doornf2a3c7f2008-02-03 15:52:45 +0100850 entry->center_freq = ieee80211_channel_to_frequency(channel);
Johannes Berg8318d782008-01-24 19:38:38 +0100851 entry->hw_value = value;
852 entry->max_power = tx_power;
853 entry->max_antenna_gain = 0xff;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700854}
855
856static void rt2x00lib_rate(struct ieee80211_rate *entry,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100857 const u16 index, const struct rt2x00_rate *rate)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700858{
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100859 entry->flags = 0;
860 entry->bitrate = rate->bitrate;
861 entry->hw_value = rt2x00_create_rate_hw_value(index, 0);
Johannes Berg8318d782008-01-24 19:38:38 +0100862 entry->hw_value_short = entry->hw_value;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100863
864 if (rate->flags & DEV_RATE_SHORT_PREAMBLE) {
865 entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
866 entry->hw_value_short |= rt2x00_create_rate_hw_value(index, 1);
867 }
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700868}
869
870static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
871 struct hw_mode_spec *spec)
872{
873 struct ieee80211_hw *hw = rt2x00dev->hw;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700874 struct ieee80211_channel *channels;
875 struct ieee80211_rate *rates;
Ivo van Doorn31562e82008-02-17 17:35:05 +0100876 unsigned int num_rates;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700877 unsigned int i;
878 unsigned char tx_power;
879
Ivo van Doorn31562e82008-02-17 17:35:05 +0100880 num_rates = 0;
881 if (spec->supported_rates & SUPPORT_RATE_CCK)
882 num_rates += 4;
883 if (spec->supported_rates & SUPPORT_RATE_OFDM)
884 num_rates += 8;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700885
886 channels = kzalloc(sizeof(*channels) * spec->num_channels, GFP_KERNEL);
887 if (!channels)
Johannes Berg8318d782008-01-24 19:38:38 +0100888 return -ENOMEM;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700889
Ivo van Doorn31562e82008-02-17 17:35:05 +0100890 rates = kzalloc(sizeof(*rates) * num_rates, GFP_KERNEL);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700891 if (!rates)
892 goto exit_free_channels;
893
894 /*
895 * Initialize Rate list.
896 */
Ivo van Doorn31562e82008-02-17 17:35:05 +0100897 for (i = 0; i < num_rates; i++)
Ivo van Doorn8f5fa7f2008-02-03 15:54:34 +0100898 rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i));
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700899
900 /*
901 * Initialize Channel list.
902 */
903 for (i = 0; i < spec->num_channels; i++) {
Ivo van Doorn31562e82008-02-17 17:35:05 +0100904 if (spec->channels[i].channel <= 14) {
905 if (spec->tx_power_bg)
906 tx_power = spec->tx_power_bg[i];
907 else
908 tx_power = spec->tx_power_default;
909 } else {
910 if (spec->tx_power_a)
911 tx_power = spec->tx_power_a[i];
912 else
913 tx_power = spec->tx_power_default;
914 }
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700915
916 rt2x00lib_channel(&channels[i],
917 spec->channels[i].channel, tx_power, i);
918 }
919
920 /*
Ivo van Doorn31562e82008-02-17 17:35:05 +0100921 * Intitialize 802.11b, 802.11g
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700922 * Rates: CCK, OFDM.
Johannes Berg8318d782008-01-24 19:38:38 +0100923 * Channels: 2.4 GHz
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700924 */
Gertjan van Wingerde47ac2682008-02-17 17:35:55 +0100925 if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
Ivo van Doorn31562e82008-02-17 17:35:05 +0100926 rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_channels = 14;
927 rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_bitrates = num_rates;
928 rt2x00dev->bands[IEEE80211_BAND_2GHZ].channels = channels;
929 rt2x00dev->bands[IEEE80211_BAND_2GHZ].bitrates = rates;
930 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
931 &rt2x00dev->bands[IEEE80211_BAND_2GHZ];
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700932 }
933
934 /*
935 * Intitialize 802.11a
936 * Rates: OFDM.
937 * Channels: OFDM, UNII, HiperLAN2.
938 */
Gertjan van Wingerde47ac2682008-02-17 17:35:55 +0100939 if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
Ivo van Doorn31562e82008-02-17 17:35:05 +0100940 rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_channels =
941 spec->num_channels - 14;
942 rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_bitrates =
943 num_rates - 4;
944 rt2x00dev->bands[IEEE80211_BAND_5GHZ].channels = &channels[14];
945 rt2x00dev->bands[IEEE80211_BAND_5GHZ].bitrates = &rates[4];
946 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
947 &rt2x00dev->bands[IEEE80211_BAND_5GHZ];
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700948 }
949
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700950 return 0;
951
Johannes Berg8318d782008-01-24 19:38:38 +0100952 exit_free_channels:
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700953 kfree(channels);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700954 ERROR(rt2x00dev, "Allocation ieee80211 modes failed.\n");
955 return -ENOMEM;
956}
957
958static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
959{
Ivo van Doorn066cb632007-09-25 20:55:39 +0200960 if (test_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags))
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700961 ieee80211_unregister_hw(rt2x00dev->hw);
962
Johannes Berg8318d782008-01-24 19:38:38 +0100963 if (likely(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ])) {
964 kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
965 kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->bitrates);
966 rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
967 rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700968 }
969}
970
971static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
972{
973 struct hw_mode_spec *spec = &rt2x00dev->spec;
974 int status;
975
976 /*
977 * Initialize HW modes.
978 */
979 status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
980 if (status)
981 return status;
982
983 /*
984 * Register HW.
985 */
986 status = ieee80211_register_hw(rt2x00dev->hw);
987 if (status) {
988 rt2x00lib_remove_hw(rt2x00dev);
989 return status;
990 }
991
Ivo van Doorn066cb632007-09-25 20:55:39 +0200992 __set_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700993
994 return 0;
995}
996
997/*
998 * Initialization/uninitialization handlers.
999 */
Ivo van Doorne37ea212008-01-06 23:40:07 +01001000static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001001{
1002 if (!__test_and_clear_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
1003 return;
1004
1005 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001006 * Unregister extra components.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001007 */
1008 rt2x00rfkill_unregister(rt2x00dev);
1009
1010 /*
1011 * Allow the HW to uninitialize.
1012 */
1013 rt2x00dev->ops->lib->uninitialize(rt2x00dev);
1014
1015 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001016 * Free allocated queue entries.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001017 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001018 rt2x00queue_uninitialize(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001019}
1020
Ivo van Doorne37ea212008-01-06 23:40:07 +01001021static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001022{
1023 int status;
1024
1025 if (test_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
1026 return 0;
1027
1028 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001029 * Allocate all queue entries.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001030 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001031 status = rt2x00queue_initialize(rt2x00dev);
1032 if (status)
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001033 return status;
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001034
1035 /*
1036 * Initialize the device.
1037 */
1038 status = rt2x00dev->ops->lib->initialize(rt2x00dev);
1039 if (status)
1040 goto exit;
1041
1042 __set_bit(DEVICE_INITIALIZED, &rt2x00dev->flags);
1043
1044 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001045 * Register the extra components.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001046 */
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001047 rt2x00rfkill_register(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001048
1049 return 0;
1050
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001051exit:
Ivo van Doorn181d6902008-02-05 16:42:23 -05001052 rt2x00lib_uninitialize(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001053
1054 return status;
1055}
1056
Ivo van Doorne37ea212008-01-06 23:40:07 +01001057int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
1058{
1059 int retval;
1060
1061 if (test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1062 return 0;
1063
1064 /*
1065 * If this is the first interface which is added,
1066 * we should load the firmware now.
1067 */
Ivo van Doorn9404ef32008-02-03 15:48:38 +01001068 retval = rt2x00lib_load_firmware(rt2x00dev);
1069 if (retval)
1070 return retval;
Ivo van Doorne37ea212008-01-06 23:40:07 +01001071
1072 /*
1073 * Initialize the device.
1074 */
1075 retval = rt2x00lib_initialize(rt2x00dev);
1076 if (retval)
1077 return retval;
1078
1079 /*
1080 * Enable radio.
1081 */
1082 retval = rt2x00lib_enable_radio(rt2x00dev);
1083 if (retval) {
1084 rt2x00lib_uninitialize(rt2x00dev);
1085 return retval;
1086 }
1087
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001088 rt2x00dev->intf_ap_count = 0;
1089 rt2x00dev->intf_sta_count = 0;
1090 rt2x00dev->intf_associated = 0;
1091
Ivo van Doorne37ea212008-01-06 23:40:07 +01001092 __set_bit(DEVICE_STARTED, &rt2x00dev->flags);
1093
1094 return 0;
1095}
1096
1097void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
1098{
1099 if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1100 return;
1101
1102 /*
1103 * Perhaps we can add something smarter here,
1104 * but for now just disabling the radio should do.
1105 */
1106 rt2x00lib_disable_radio(rt2x00dev);
1107
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001108 rt2x00dev->intf_ap_count = 0;
1109 rt2x00dev->intf_sta_count = 0;
1110 rt2x00dev->intf_associated = 0;
1111
Ivo van Doorne37ea212008-01-06 23:40:07 +01001112 __clear_bit(DEVICE_STARTED, &rt2x00dev->flags);
1113}
1114
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001115/*
1116 * driver allocation handlers.
1117 */
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001118int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
1119{
1120 int retval = -ENOMEM;
1121
1122 /*
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001123 * Make room for rt2x00_intf inside the per-interface
1124 * structure ieee80211_vif.
1125 */
1126 rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf);
1127
1128 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001129 * Let the driver probe the device to detect the capabilities.
1130 */
1131 retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
1132 if (retval) {
1133 ERROR(rt2x00dev, "Failed to allocate device.\n");
1134 goto exit;
1135 }
1136
1137 /*
1138 * Initialize configuration work.
1139 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001140 INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
Johannes Berg4150c572007-09-17 01:29:23 -04001141 INIT_WORK(&rt2x00dev->filter_work, rt2x00lib_packetfilter_scheduled);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001142 INIT_DELAYED_WORK(&rt2x00dev->link.work, rt2x00lib_link_tuner);
1143
1144 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001145 * Allocate queue array.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001146 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001147 retval = rt2x00queue_allocate(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001148 if (retval)
1149 goto exit;
1150
1151 /*
1152 * Initialize ieee80211 structure.
1153 */
1154 retval = rt2x00lib_probe_hw(rt2x00dev);
1155 if (retval) {
1156 ERROR(rt2x00dev, "Failed to initialize hw.\n");
1157 goto exit;
1158 }
1159
1160 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001161 * Register extra components.
Ivo van Doorna9450b72008-02-03 15:53:40 +01001162 */
1163 rt2x00leds_register(rt2x00dev);
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001164 rt2x00rfkill_allocate(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001165 rt2x00debug_register(rt2x00dev);
1166
Ivo van Doorn066cb632007-09-25 20:55:39 +02001167 __set_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1168
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001169 return 0;
1170
1171exit:
1172 rt2x00lib_remove_dev(rt2x00dev);
1173
1174 return retval;
1175}
1176EXPORT_SYMBOL_GPL(rt2x00lib_probe_dev);
1177
1178void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
1179{
Ivo van Doorn066cb632007-09-25 20:55:39 +02001180 __clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1181
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001182 /*
1183 * Disable radio.
1184 */
1185 rt2x00lib_disable_radio(rt2x00dev);
1186
1187 /*
1188 * Uninitialize device.
1189 */
1190 rt2x00lib_uninitialize(rt2x00dev);
1191
1192 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001193 * Free extra components
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001194 */
1195 rt2x00debug_deregister(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001196 rt2x00rfkill_free(rt2x00dev);
1197
1198 /*
Ivo van Doorna9450b72008-02-03 15:53:40 +01001199 * Free LED.
1200 */
1201 rt2x00leds_unregister(rt2x00dev);
1202
1203 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001204 * Free ieee80211_hw memory.
1205 */
1206 rt2x00lib_remove_hw(rt2x00dev);
1207
1208 /*
1209 * Free firmware image.
1210 */
1211 rt2x00lib_free_firmware(rt2x00dev);
1212
1213 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001214 * Free queue structures.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001215 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001216 rt2x00queue_free(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001217}
1218EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev);
1219
1220/*
1221 * Device state handlers
1222 */
1223#ifdef CONFIG_PM
1224int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state)
1225{
1226 int retval;
1227
1228 NOTICE(rt2x00dev, "Going to sleep.\n");
Ivo van Doorn066cb632007-09-25 20:55:39 +02001229 __clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1230
1231 /*
1232 * Only continue if mac80211 has open interfaces.
1233 */
1234 if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1235 goto exit;
Ivo van Doorn6d7f9872007-10-06 14:12:42 +02001236 __set_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001237
1238 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001239 * Disable radio.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001240 */
Ivo van Doorne37ea212008-01-06 23:40:07 +01001241 rt2x00lib_stop(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001242 rt2x00lib_uninitialize(rt2x00dev);
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001243
1244 /*
1245 * Suspend/disable extra components.
1246 */
Ivo van Doorna9450b72008-02-03 15:53:40 +01001247 rt2x00leds_suspend(rt2x00dev);
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001248 rt2x00rfkill_suspend(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001249 rt2x00debug_deregister(rt2x00dev);
1250
Ivo van Doorn066cb632007-09-25 20:55:39 +02001251exit:
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001252 /*
1253 * Set device mode to sleep for power management.
1254 */
1255 retval = rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP);
1256 if (retval)
1257 return retval;
1258
1259 return 0;
1260}
1261EXPORT_SYMBOL_GPL(rt2x00lib_suspend);
1262
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001263static void rt2x00lib_resume_intf(void *data, u8 *mac,
1264 struct ieee80211_vif *vif)
1265{
1266 struct rt2x00_dev *rt2x00dev = data;
1267 struct rt2x00_intf *intf = vif_to_intf(vif);
1268
1269 spin_lock(&intf->lock);
1270
1271 rt2x00lib_config_intf(rt2x00dev, intf,
1272 vif->type, intf->mac, intf->bssid);
1273
1274
1275 /*
1276 * Master or Ad-hoc mode require a new beacon update.
1277 */
1278 if (vif->type == IEEE80211_IF_TYPE_AP ||
1279 vif->type == IEEE80211_IF_TYPE_IBSS)
1280 intf->delayed_flags |= DELAYED_UPDATE_BEACON;
1281
1282 spin_unlock(&intf->lock);
1283}
1284
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001285int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
1286{
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001287 int retval;
1288
1289 NOTICE(rt2x00dev, "Waking up.\n");
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001290
1291 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001292 * Restore/enable extra components.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001293 */
1294 rt2x00debug_register(rt2x00dev);
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001295 rt2x00rfkill_resume(rt2x00dev);
Ivo van Doorna9450b72008-02-03 15:53:40 +01001296 rt2x00leds_resume(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001297
1298 /*
Ivo van Doorn6d7f9872007-10-06 14:12:42 +02001299 * Only continue if mac80211 had open interfaces.
Ivo van Doorn066cb632007-09-25 20:55:39 +02001300 */
Ivo van Doorn6d7f9872007-10-06 14:12:42 +02001301 if (!__test_and_clear_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags))
Ivo van Doorn066cb632007-09-25 20:55:39 +02001302 return 0;
1303
1304 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001305 * Reinitialize device and all active interfaces.
1306 */
Ivo van Doorne37ea212008-01-06 23:40:07 +01001307 retval = rt2x00lib_start(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001308 if (retval)
1309 goto exit;
1310
1311 /*
1312 * Reconfigure device.
1313 */
Ivo van Doorn066cb632007-09-25 20:55:39 +02001314 rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf, 1);
1315 if (!rt2x00dev->hw->conf.radio_enabled)
1316 rt2x00lib_disable_radio(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001317
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001318 /*
1319 * Iterator over each active interface to
1320 * reconfigure the hardware.
1321 */
1322 ieee80211_iterate_active_interfaces(rt2x00dev->hw,
1323 rt2x00lib_resume_intf, rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001324
1325 /*
Ivo van Doorne37ea212008-01-06 23:40:07 +01001326 * We are ready again to receive requests from mac80211.
1327 */
1328 __set_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1329
1330 /*
Ivo van Doorn066cb632007-09-25 20:55:39 +02001331 * It is possible that during that mac80211 has attempted
1332 * to send frames while we were suspending or resuming.
1333 * In that case we have disabled the TX queue and should
1334 * now enable it again
1335 */
1336 ieee80211_start_queues(rt2x00dev->hw);
1337
1338 /*
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001339 * During interface iteration we might have changed the
1340 * delayed_flags, time to handles the event by calling
1341 * the work handler directly.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001342 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001343 rt2x00lib_intf_scheduled(&rt2x00dev->intf_work);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001344
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001345 return 0;
1346
1347exit:
1348 rt2x00lib_disable_radio(rt2x00dev);
1349 rt2x00lib_uninitialize(rt2x00dev);
1350 rt2x00debug_deregister(rt2x00dev);
1351
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001352 return retval;
1353}
1354EXPORT_SYMBOL_GPL(rt2x00lib_resume);
1355#endif /* CONFIG_PM */
1356
1357/*
1358 * rt2x00lib module information.
1359 */
1360MODULE_AUTHOR(DRV_PROJECT);
1361MODULE_VERSION(DRV_VERSION);
1362MODULE_DESCRIPTION("rt2x00 library");
1363MODULE_LICENSE("GPL");