blob: 2673d568bcac286dc9f3cbdb8da9d3c5051ff7cc [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 */
Ivo van Doorna2e1d522008-03-31 15:53:44 +0200111 status =
112 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_ON);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700113 if (status)
114 return status;
115
Ivo van Doorna2e1d522008-03-31 15:53:44 +0200116 rt2x00leds_led_radio(rt2x00dev, true);
Ivo van Doorn61c2b682008-04-21 19:01:09 +0200117 rt2x00led_led_activity(rt2x00dev, true);
Ivo van Doorna2e1d522008-03-31 15:53:44 +0200118
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700119 __set_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags);
120
121 /*
122 * Enable RX.
123 */
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200124 rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_ON);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700125
126 /*
127 * Start the TX queues.
128 */
129 ieee80211_start_queues(rt2x00dev->hw);
130
131 return 0;
132}
133
134void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
135{
136 if (!__test_and_clear_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
137 return;
138
139 /*
Johannes Berg4150c572007-09-17 01:29:23 -0400140 * Stop all scheduled work.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700141 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100142 if (work_pending(&rt2x00dev->intf_work))
143 cancel_work_sync(&rt2x00dev->intf_work);
Johannes Berg4150c572007-09-17 01:29:23 -0400144 if (work_pending(&rt2x00dev->filter_work))
145 cancel_work_sync(&rt2x00dev->filter_work);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700146
147 /*
148 * Stop the TX queues.
149 */
150 ieee80211_stop_queues(rt2x00dev->hw);
151
152 /*
153 * Disable RX.
154 */
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200155 rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_OFF);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700156
157 /*
158 * Disable radio.
159 */
160 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF);
Ivo van Doorn61c2b682008-04-21 19:01:09 +0200161 rt2x00led_led_activity(rt2x00dev, false);
Ivo van Doorna2e1d522008-03-31 15:53:44 +0200162 rt2x00leds_led_radio(rt2x00dev, false);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700163}
164
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200165void rt2x00lib_toggle_rx(struct rt2x00_dev *rt2x00dev, enum dev_state state)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700166{
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700167 /*
168 * When we are disabling the RX, we should also stop the link tuner.
169 */
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200170 if (state == STATE_RADIO_RX_OFF)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700171 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 */
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200178 if (state == STATE_RADIO_RX_ON &&
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100179 (rt2x00dev->intf_ap_count || rt2x00dev->intf_sta_count))
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700180 rt2x00lib_start_link_tuner(rt2x00dev);
181}
182
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200183static 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
Ivo van Doorn05253c92008-02-25 23:15:08 +0100208 if (rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY)
209 rx = (sample_a > sample_b) ? ANTENNA_A : ANTENNA_B;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200210
Ivo van Doorn05253c92008-02-25 23:15:08 +0100211 if (rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)
212 tx = (sample_a > sample_b) ? ANTENNA_A : ANTENNA_B;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200213
214 rt2x00lib_config_antenna(rt2x00dev, rx, tx);
215}
216
217static 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 */
Ivo van Doornb290d432008-02-25 23:15:01 +0100233 if (abs(rssi_curr - rssi_old) < 5)
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200234 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
247static 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 &&
Ivo van Doornb290d432008-02-25 23:15:01 +0100259 rt2x00dev->default_ant.rx == ANTENNA_SW_DIVERSITY)
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200260 rt2x00dev->link.ant.flags |= ANTENNA_RX_DIVERSITY;
261 if (rt2x00dev->hw->conf.antenna_sel_tx == 0 &&
Ivo van Doornb290d432008-02-25 23:15:01 +0100262 rt2x00dev->default_ant.tx == ANTENNA_SW_DIVERSITY)
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200263 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)) {
Ivo van Doorn05253c92008-02-25 23:15:08 +0100267 rt2x00dev->link.ant.flags = 0;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200268 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
283static 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
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200302static void rt2x00lib_precalculate_link_signal(struct link_qual *qual)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700303{
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200304 if (qual->rx_failed || qual->rx_success)
305 qual->rx_percentage =
306 (qual->rx_success * 100) /
307 (qual->rx_failed + qual->rx_success);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700308 else
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200309 qual->rx_percentage = 50;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700310
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200311 if (qual->tx_failed || qual->tx_success)
312 qual->tx_percentage =
313 (qual->tx_success * 100) /
314 (qual->tx_failed + qual->tx_success);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700315 else
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200316 qual->tx_percentage = 50;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700317
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200318 qual->rx_success = 0;
319 qual->rx_failed = 0;
320 qual->tx_success = 0;
321 qual->tx_failed = 0;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700322}
323
324static 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) +
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200348 (WEIGHT_TX * rt2x00dev->link.qual.tx_percentage) +
349 (WEIGHT_RX * rt2x00dev->link.qual.rx_percentage)) / 100;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700350
351 return (signal > 100) ? 100 : signal;
352}
353
354static 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 /*
Ivo van Doorn25ab0022007-09-25 20:57:04 +0200360 * 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 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700367 * Update statistics.
368 */
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200369 rt2x00dev->ops->lib->link_stats(rt2x00dev, &rt2x00dev->link.qual);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700370 rt2x00dev->low_level_stats.dot11FCSErrorCount +=
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200371 rt2x00dev->link.qual.rx_failed;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700372
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700373 /*
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 /*
Ivo van Doorn725d99d2007-09-25 20:53:20 +0200381 * Precalculate a portion of the link signal which is
382 * in based on the tx/rx success/failure counters.
383 */
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200384 rt2x00lib_precalculate_link_signal(&rt2x00dev->link.qual);
Ivo van Doorn725d99d2007-09-25 20:53:20 +0200385
386 /*
Ivo van Doorna9450b72008-02-03 15:53:40 +0100387 * 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 /*
Ivo van Doorn53b3f8e2008-02-25 23:15:13 +0100392 * Evaluate antenna setup, make this the last step since this could
393 * possibly reset some statistics.
394 */
395 rt2x00lib_evaluate_antenna(rt2x00dev);
396
397 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700398 * 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
Johannes Berg4150c572007-09-17 01:29:23 -0400405static void rt2x00lib_packetfilter_scheduled(struct work_struct *work)
406{
407 struct rt2x00_dev *rt2x00dev =
408 container_of(work, struct rt2x00_dev, filter_work);
Ivo van Doorn5886d0d2007-10-06 14:13:38 +0200409
Ivo van Doorn133adf02008-04-04 00:01:43 +0200410 rt2x00dev->ops->lib->config_filter(rt2x00dev, rt2x00dev->packet_filter);
Johannes Berg4150c572007-09-17 01:29:23 -0400411}
412
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100413static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
414 struct ieee80211_vif *vif)
Ivo van Doorn5c58ee52007-10-06 13:34:52 +0200415{
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100416 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;
Johannes Berg471b3ef2007-12-28 14:32:58 +0100422
423 /*
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100424 * 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.
Johannes Berg471b3ef2007-12-28 14:32:58 +0100427 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100428 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);
Ivo van Doorn171afcd2008-04-09 20:46:27 +0200438 if (skb && rt2x00dev->ops->hw->beacon_update(rt2x00dev->hw,
439 skb, &control))
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100440 dev_kfree_skb(skb);
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100441 }
442
Ivo van Doorn72810372008-03-09 22:46:18 +0100443 if (delayed_flags & DELAYED_CONFIG_ERP)
444 rt2x00lib_config_erp(rt2x00dev, intf, &intf->conf);
Ivo van Doorna2e1d522008-03-31 15:53:44 +0200445
446 if (delayed_flags & DELAYED_LED_ASSOC)
447 rt2x00leds_led_assoc(rt2x00dev, !!rt2x00dev->intf_associated);
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100448}
449
450static 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);
Ivo van Doorn5c58ee52007-10-06 13:34:52 +0200462}
463
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700464/*
465 * Interrupt context handlers.
466 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100467static void rt2x00lib_beacondone_iter(void *data, u8 *mac,
468 struct ieee80211_vif *vif)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700469{
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100470 struct rt2x00_intf *intf = vif_to_intf(vif);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700471
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100472 if (vif->type != IEEE80211_IF_TYPE_AP &&
473 vif->type != IEEE80211_IF_TYPE_IBSS)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700474 return;
475
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100476 spin_lock(&intf->lock);
477 intf->delayed_flags |= DELAYED_UPDATE_BEACON;
478 spin_unlock(&intf->lock);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700479}
480
481void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
482{
483 if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
484 return;
485
Ivo van Doorn633257d2008-05-23 18:14:02 +0200486 ieee80211_iterate_active_interfaces_atomic(rt2x00dev->hw,
487 rt2x00lib_beacondone_iter,
488 rt2x00dev);
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100489
490 queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->intf_work);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700491}
492EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);
493
Ivo van Doorn181d6902008-02-05 16:42:23 -0500494void rt2x00lib_txdone(struct queue_entry *entry,
495 struct txdone_entry_desc *txdesc)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700496{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500497 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
Ivo van Doornbaf26a72008-02-17 17:32:08 +0100498 struct skb_frame_desc *skbdesc;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500499 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);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700505
506 /*
507 * Update TX statistics.
508 */
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200509 rt2x00dev->link.qual.tx_success += success;
Ivo van Doorn2088d412008-05-23 18:13:49 +0200510 rt2x00dev->link.qual.tx_failed += fail;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700511
Ivo van Doorn181d6902008-02-05 16:42:23 -0500512 /*
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;
Mattias Nissler95db4d42008-03-09 22:39:32 +0100519 memcpy(&tx_status.control, txdesc->control, sizeof(*txdesc->control));
Ivo van Doorn181d6902008-02-05 16:42:23 -0500520
521 if (!(tx_status.control.flags & IEEE80211_TXCTL_NO_ACK)) {
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700522 if (success)
Ivo van Doorn181d6902008-02-05 16:42:23 -0500523 tx_status.flags |= IEEE80211_TX_STATUS_ACK;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700524 else
Ivo van Doorn181d6902008-02-05 16:42:23 -0500525 rt2x00dev->low_level_stats.dot11ACKFailureCount++;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700526 }
527
Ivo van Doorn181d6902008-02-05 16:42:23 -0500528 tx_status.queue_length = entry->queue->limit;
529 tx_status.queue_number = tx_status.control.queue;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700530
Ivo van Doorn181d6902008-02-05 16:42:23 -0500531 if (tx_status.control.flags & IEEE80211_TXCTL_USE_RTS_CTS) {
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700532 if (success)
Ivo van Doorn181d6902008-02-05 16:42:23 -0500533 rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700534 else
Ivo van Doorn181d6902008-02-05 16:42:23 -0500535 rt2x00dev->low_level_stats.dot11RTSFailureCount++;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700536 }
537
538 /*
Ivo van Doornbaf26a72008-02-17 17:32:08 +0100539 * Send the tx_status to debugfs. Only send the status report
540 * to mac80211 when the frame originated from there. If this was
541 * a extra frame coming through a mac80211 library call (RTS/CTS)
542 * then we should not send the status report back.
543 * If send to mac80211, mac80211 will clean up the skb structure,
544 * otherwise we have to do it ourself.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700545 */
Ivo van Doornbaf26a72008-02-17 17:32:08 +0100546 skbdesc = get_skb_frame_desc(entry->skb);
547 skbdesc->frame_type = DUMP_FRAME_TXDONE;
548
Ivo van Doorn4d8dd662007-11-27 21:49:29 +0100549 rt2x00debug_dump_frame(rt2x00dev, entry->skb);
Ivo van Doornbaf26a72008-02-17 17:32:08 +0100550
551 if (!(skbdesc->flags & FRAME_DESC_DRIVER_GENERATED))
552 ieee80211_tx_status_irqsafe(rt2x00dev->hw,
553 entry->skb, &tx_status);
554 else
555 dev_kfree_skb(entry->skb);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700556 entry->skb = NULL;
557}
558EXPORT_SYMBOL_GPL(rt2x00lib_txdone);
559
Ivo van Doorn181d6902008-02-05 16:42:23 -0500560void rt2x00lib_rxdone(struct queue_entry *entry,
561 struct rxdone_entry_desc *rxdesc)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700562{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500563 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700564 struct ieee80211_rx_status *rx_status = &rt2x00dev->rx_status;
Johannes Berg8318d782008-01-24 19:38:38 +0100565 struct ieee80211_supported_band *sband;
Mattias Nissler61af43c2007-11-27 21:50:26 +0100566 struct ieee80211_hdr *hdr;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100567 const struct rt2x00_rate *rate;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700568 unsigned int i;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100569 int idx = -1;
Mattias Nissler61af43c2007-11-27 21:50:26 +0100570 u16 fc;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700571
572 /*
573 * Update RX statistics.
574 */
Johannes Berg8318d782008-01-24 19:38:38 +0100575 sband = &rt2x00dev->bands[rt2x00dev->curr_band];
576 for (i = 0; i < sband->n_bitrates; i++) {
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100577 rate = rt2x00_get_rate(sband->bitrates[i].hw_value);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700578
Ivo van Doorn19d30e02008-03-15 21:38:07 +0100579 if (((rxdesc->dev_flags & RXDONE_SIGNAL_PLCP) &&
580 (rate->plcp == rxdesc->signal)) ||
581 (!(rxdesc->dev_flags & RXDONE_SIGNAL_PLCP) &&
582 (rate->bitrate == rxdesc->signal))) {
Johannes Berg8318d782008-01-24 19:38:38 +0100583 idx = i;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700584 break;
585 }
586 }
587
Ivo van Doorn866a0502008-03-25 14:12:45 +0100588 if (idx < 0) {
589 WARNING(rt2x00dev, "Frame received with unrecognized signal,"
590 "signal=0x%.2x, plcp=%d.\n", rxdesc->signal,
591 !!(rxdesc->dev_flags & RXDONE_SIGNAL_PLCP));
592 idx = 0;
593 }
594
Mattias Nissler61af43c2007-11-27 21:50:26 +0100595 /*
Ivo van Doorn7e56d382008-01-06 23:41:28 +0100596 * Only update link status if this is a beacon frame carrying our bssid.
Mattias Nissler61af43c2007-11-27 21:50:26 +0100597 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100598 hdr = (struct ieee80211_hdr *)entry->skb->data;
Ivo van Doorn7e56d382008-01-06 23:41:28 +0100599 fc = le16_to_cpu(hdr->frame_control);
Ivo van Doorn19d30e02008-03-15 21:38:07 +0100600 if (is_beacon(fc) && (rxdesc->dev_flags & RXDONE_MY_BSS))
Ivo van Doorn181d6902008-02-05 16:42:23 -0500601 rt2x00lib_update_link_stats(&rt2x00dev->link, rxdesc->rssi);
Mattias Nissler61af43c2007-11-27 21:50:26 +0100602
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200603 rt2x00dev->link.qual.rx_success++;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200604
Johannes Berg8318d782008-01-24 19:38:38 +0100605 rx_status->rate_idx = idx;
Johannes Berg4150c572007-09-17 01:29:23 -0400606 rx_status->signal =
Ivo van Doorn181d6902008-02-05 16:42:23 -0500607 rt2x00lib_calculate_link_signal(rt2x00dev, rxdesc->rssi);
608 rx_status->ssi = rxdesc->rssi;
609 rx_status->flag = rxdesc->flags;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200610 rx_status->antenna = rt2x00dev->link.ant.active.rx;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700611
612 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500613 * Send frame to mac80211 & debugfs.
614 * mac80211 will clean up the skb structure.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700615 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500616 get_skb_frame_desc(entry->skb)->frame_type = DUMP_FRAME_RXDONE;
617 rt2x00debug_dump_frame(rt2x00dev, entry->skb);
618 ieee80211_rx_irqsafe(rt2x00dev->hw, entry->skb, rx_status);
619 entry->skb = NULL;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700620}
621EXPORT_SYMBOL_GPL(rt2x00lib_rxdone);
622
623/*
624 * TX descriptor initializer
625 */
626void rt2x00lib_write_tx_desc(struct rt2x00_dev *rt2x00dev,
Ivo van Doorn08992f72008-01-24 01:56:25 -0800627 struct sk_buff *skb,
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700628 struct ieee80211_tx_control *control)
629{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500630 struct txentry_desc txdesc;
631 struct skb_frame_desc *skbdesc = get_skb_frame_desc(skb);
Ivo van Doorn3976ae62008-03-09 22:41:53 +0100632 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skbdesc->data;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100633 const struct rt2x00_rate *rate;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700634 int tx_rate;
Ivo van Doorn08992f72008-01-24 01:56:25 -0800635 int length;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700636 int duration;
637 int residual;
638 u16 frame_control;
639 u16 seq_ctrl;
640
Ivo van Doorn181d6902008-02-05 16:42:23 -0500641 memset(&txdesc, 0, sizeof(txdesc));
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700642
Ivo van Doorn091ed312008-02-03 15:52:21 +0100643 txdesc.queue = skbdesc->entry->queue->qid;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500644 txdesc.cw_min = skbdesc->entry->queue->cw_min;
645 txdesc.cw_max = skbdesc->entry->queue->cw_max;
646 txdesc.aifs = skbdesc->entry->queue->aifs;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700647
648 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700649 * Read required fields from ieee80211 header.
650 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100651 frame_control = le16_to_cpu(hdr->frame_control);
652 seq_ctrl = le16_to_cpu(hdr->seq_ctrl);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700653
Johannes Berg8318d782008-01-24 19:38:38 +0100654 tx_rate = control->tx_rate->hw_value;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700655
656 /*
Mattias Nissler2700f8b2007-10-27 13:43:49 +0200657 * Check whether this frame is to be acked
658 */
659 if (!(control->flags & IEEE80211_TXCTL_NO_ACK))
Ivo van Doorn181d6902008-02-05 16:42:23 -0500660 __set_bit(ENTRY_TXD_ACK, &txdesc.flags);
Mattias Nissler2700f8b2007-10-27 13:43:49 +0200661
662 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700663 * Check if this is a RTS/CTS frame
664 */
665 if (is_rts_frame(frame_control) || is_cts_frame(frame_control)) {
Ivo van Doorn181d6902008-02-05 16:42:23 -0500666 __set_bit(ENTRY_TXD_BURST, &txdesc.flags);
Mattias Nissler2700f8b2007-10-27 13:43:49 +0200667 if (is_rts_frame(frame_control)) {
Ivo van Doorn181d6902008-02-05 16:42:23 -0500668 __set_bit(ENTRY_TXD_RTS_FRAME, &txdesc.flags);
669 __set_bit(ENTRY_TXD_ACK, &txdesc.flags);
Mattias Nissler2700f8b2007-10-27 13:43:49 +0200670 } else
Ivo van Doorn181d6902008-02-05 16:42:23 -0500671 __clear_bit(ENTRY_TXD_ACK, &txdesc.flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700672 if (control->rts_cts_rate)
Johannes Berg8318d782008-01-24 19:38:38 +0100673 tx_rate = control->rts_cts_rate->hw_value;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700674 }
675
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100676 rate = rt2x00_get_rate(tx_rate);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700677
678 /*
679 * Check if more fragments are pending
680 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100681 if (ieee80211_get_morefrag(hdr)) {
Ivo van Doorn181d6902008-02-05 16:42:23 -0500682 __set_bit(ENTRY_TXD_BURST, &txdesc.flags);
683 __set_bit(ENTRY_TXD_MORE_FRAG, &txdesc.flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700684 }
685
686 /*
687 * Beacons and probe responses require the tsf timestamp
688 * to be inserted into the frame.
689 */
Ivo van Doorn5957da42008-02-03 15:54:57 +0100690 if (control->queue == RT2X00_BCN_QUEUE_BEACON ||
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700691 is_probe_resp(frame_control))
Ivo van Doorn181d6902008-02-05 16:42:23 -0500692 __set_bit(ENTRY_TXD_REQ_TIMESTAMP, &txdesc.flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700693
694 /*
695 * Determine with what IFS priority this frame should be send.
696 * Set ifs to IFS_SIFS when the this is not the first fragment,
697 * or this fragment came after RTS/CTS.
698 */
699 if ((seq_ctrl & IEEE80211_SCTL_FRAG) > 0 ||
Ivo van Doorn181d6902008-02-05 16:42:23 -0500700 test_bit(ENTRY_TXD_RTS_FRAME, &txdesc.flags))
701 txdesc.ifs = IFS_SIFS;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700702 else
Ivo van Doorn181d6902008-02-05 16:42:23 -0500703 txdesc.ifs = IFS_BACKOFF;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700704
705 /*
706 * PLCP setup
707 * Length calculation depends on OFDM/CCK rate.
708 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100709 txdesc.signal = rate->plcp;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500710 txdesc.service = 0x04;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700711
Ivo van Doorn3976ae62008-03-09 22:41:53 +0100712 length = skbdesc->data_len + FCS_LEN;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100713 if (rate->flags & DEV_RATE_OFDM) {
714 __set_bit(ENTRY_TXD_OFDM_RATE, &txdesc.flags);
715
Ivo van Doorn181d6902008-02-05 16:42:23 -0500716 txdesc.length_high = (length >> 6) & 0x3f;
717 txdesc.length_low = length & 0x3f;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700718 } else {
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700719 /*
720 * Convert length to microseconds.
721 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100722 residual = get_duration_res(length, rate->bitrate);
723 duration = get_duration(length, rate->bitrate);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700724
725 if (residual != 0) {
726 duration++;
727
728 /*
729 * Check if we need to set the Length Extension
730 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100731 if (rate->bitrate == 110 && residual <= 30)
Ivo van Doorn181d6902008-02-05 16:42:23 -0500732 txdesc.service |= 0x80;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700733 }
734
Ivo van Doorn181d6902008-02-05 16:42:23 -0500735 txdesc.length_high = (duration >> 8) & 0xff;
736 txdesc.length_low = duration & 0xff;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700737
738 /*
739 * When preamble is enabled we should set the
740 * preamble bit for the signal.
741 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100742 if (rt2x00_get_rate_preamble(tx_rate))
Ivo van Doorn181d6902008-02-05 16:42:23 -0500743 txdesc.signal |= 0x08;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700744 }
745
Ivo van Doorn181d6902008-02-05 16:42:23 -0500746 rt2x00dev->ops->lib->write_tx_desc(rt2x00dev, skb, &txdesc, control);
Ivo van Doorn08992f72008-01-24 01:56:25 -0800747
748 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500749 * Update queue entry.
Ivo van Doorn08992f72008-01-24 01:56:25 -0800750 */
751 skbdesc->entry->skb = skb;
Ivo van Doorn4d8dd662007-11-27 21:49:29 +0100752
753 /*
754 * The frame has been completely initialized and ready
755 * for sending to the device. The caller will push the
756 * frame to the device, but we are going to push the
757 * frame to debugfs here.
758 */
759 skbdesc->frame_type = DUMP_FRAME_TX;
760 rt2x00debug_dump_frame(rt2x00dev, skb);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700761}
762EXPORT_SYMBOL_GPL(rt2x00lib_write_tx_desc);
763
764/*
765 * Driver initialization handlers.
766 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100767const struct rt2x00_rate rt2x00_supported_rates[12] = {
768 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100769 .flags = DEV_RATE_CCK | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100770 .bitrate = 10,
Ivo van Doornaa776722008-03-09 22:48:08 +0100771 .ratemask = BIT(0),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100772 .plcp = 0x00,
773 },
774 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100775 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100776 .bitrate = 20,
Ivo van Doornaa776722008-03-09 22:48:08 +0100777 .ratemask = BIT(1),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100778 .plcp = 0x01,
779 },
780 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100781 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100782 .bitrate = 55,
Ivo van Doornaa776722008-03-09 22:48:08 +0100783 .ratemask = BIT(2),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100784 .plcp = 0x02,
785 },
786 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100787 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100788 .bitrate = 110,
Ivo van Doornaa776722008-03-09 22:48:08 +0100789 .ratemask = BIT(3),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100790 .plcp = 0x03,
791 },
792 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100793 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100794 .bitrate = 60,
Ivo van Doornaa776722008-03-09 22:48:08 +0100795 .ratemask = BIT(4),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100796 .plcp = 0x0b,
797 },
798 {
799 .flags = DEV_RATE_OFDM,
800 .bitrate = 90,
Ivo van Doornaa776722008-03-09 22:48:08 +0100801 .ratemask = BIT(5),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100802 .plcp = 0x0f,
803 },
804 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100805 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100806 .bitrate = 120,
Ivo van Doornaa776722008-03-09 22:48:08 +0100807 .ratemask = BIT(6),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100808 .plcp = 0x0a,
809 },
810 {
811 .flags = DEV_RATE_OFDM,
812 .bitrate = 180,
Ivo van Doornaa776722008-03-09 22:48:08 +0100813 .ratemask = BIT(7),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100814 .plcp = 0x0e,
815 },
816 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100817 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100818 .bitrate = 240,
Ivo van Doornaa776722008-03-09 22:48:08 +0100819 .ratemask = BIT(8),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100820 .plcp = 0x09,
821 },
822 {
823 .flags = DEV_RATE_OFDM,
824 .bitrate = 360,
Ivo van Doornaa776722008-03-09 22:48:08 +0100825 .ratemask = BIT(9),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100826 .plcp = 0x0d,
827 },
828 {
829 .flags = DEV_RATE_OFDM,
830 .bitrate = 480,
Ivo van Doornaa776722008-03-09 22:48:08 +0100831 .ratemask = BIT(10),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100832 .plcp = 0x08,
833 },
834 {
835 .flags = DEV_RATE_OFDM,
836 .bitrate = 540,
Ivo van Doornaa776722008-03-09 22:48:08 +0100837 .ratemask = BIT(11),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100838 .plcp = 0x0c,
839 },
840};
841
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700842static void rt2x00lib_channel(struct ieee80211_channel *entry,
843 const int channel, const int tx_power,
844 const int value)
845{
Ivo van Doornf2a3c7f2008-02-03 15:52:45 +0100846 entry->center_freq = ieee80211_channel_to_frequency(channel);
Johannes Berg8318d782008-01-24 19:38:38 +0100847 entry->hw_value = value;
848 entry->max_power = tx_power;
849 entry->max_antenna_gain = 0xff;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700850}
851
852static void rt2x00lib_rate(struct ieee80211_rate *entry,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100853 const u16 index, const struct rt2x00_rate *rate)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700854{
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100855 entry->flags = 0;
856 entry->bitrate = rate->bitrate;
857 entry->hw_value = rt2x00_create_rate_hw_value(index, 0);
Johannes Berg8318d782008-01-24 19:38:38 +0100858 entry->hw_value_short = entry->hw_value;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100859
860 if (rate->flags & DEV_RATE_SHORT_PREAMBLE) {
861 entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
862 entry->hw_value_short |= rt2x00_create_rate_hw_value(index, 1);
863 }
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700864}
865
866static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
867 struct hw_mode_spec *spec)
868{
869 struct ieee80211_hw *hw = rt2x00dev->hw;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700870 struct ieee80211_channel *channels;
871 struct ieee80211_rate *rates;
Ivo van Doorn31562e82008-02-17 17:35:05 +0100872 unsigned int num_rates;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700873 unsigned int i;
874 unsigned char tx_power;
875
Ivo van Doorn31562e82008-02-17 17:35:05 +0100876 num_rates = 0;
877 if (spec->supported_rates & SUPPORT_RATE_CCK)
878 num_rates += 4;
879 if (spec->supported_rates & SUPPORT_RATE_OFDM)
880 num_rates += 8;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700881
882 channels = kzalloc(sizeof(*channels) * spec->num_channels, GFP_KERNEL);
883 if (!channels)
Johannes Berg8318d782008-01-24 19:38:38 +0100884 return -ENOMEM;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700885
Ivo van Doorn31562e82008-02-17 17:35:05 +0100886 rates = kzalloc(sizeof(*rates) * num_rates, GFP_KERNEL);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700887 if (!rates)
888 goto exit_free_channels;
889
890 /*
891 * Initialize Rate list.
892 */
Ivo van Doorn31562e82008-02-17 17:35:05 +0100893 for (i = 0; i < num_rates; i++)
Ivo van Doorn8f5fa7f2008-02-03 15:54:34 +0100894 rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i));
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700895
896 /*
897 * Initialize Channel list.
898 */
899 for (i = 0; i < spec->num_channels; i++) {
Ivo van Doorn31562e82008-02-17 17:35:05 +0100900 if (spec->channels[i].channel <= 14) {
901 if (spec->tx_power_bg)
902 tx_power = spec->tx_power_bg[i];
903 else
904 tx_power = spec->tx_power_default;
905 } else {
906 if (spec->tx_power_a)
907 tx_power = spec->tx_power_a[i];
908 else
909 tx_power = spec->tx_power_default;
910 }
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700911
912 rt2x00lib_channel(&channels[i],
913 spec->channels[i].channel, tx_power, i);
914 }
915
916 /*
Ivo van Doorn31562e82008-02-17 17:35:05 +0100917 * Intitialize 802.11b, 802.11g
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700918 * Rates: CCK, OFDM.
Johannes Berg8318d782008-01-24 19:38:38 +0100919 * Channels: 2.4 GHz
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700920 */
Gertjan van Wingerde47ac2682008-02-17 17:35:55 +0100921 if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
Ivo van Doorn31562e82008-02-17 17:35:05 +0100922 rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_channels = 14;
923 rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_bitrates = num_rates;
924 rt2x00dev->bands[IEEE80211_BAND_2GHZ].channels = channels;
925 rt2x00dev->bands[IEEE80211_BAND_2GHZ].bitrates = rates;
926 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
927 &rt2x00dev->bands[IEEE80211_BAND_2GHZ];
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700928 }
929
930 /*
931 * Intitialize 802.11a
932 * Rates: OFDM.
933 * Channels: OFDM, UNII, HiperLAN2.
934 */
Gertjan van Wingerde47ac2682008-02-17 17:35:55 +0100935 if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
Ivo van Doorn31562e82008-02-17 17:35:05 +0100936 rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_channels =
937 spec->num_channels - 14;
938 rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_bitrates =
939 num_rates - 4;
940 rt2x00dev->bands[IEEE80211_BAND_5GHZ].channels = &channels[14];
941 rt2x00dev->bands[IEEE80211_BAND_5GHZ].bitrates = &rates[4];
942 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
943 &rt2x00dev->bands[IEEE80211_BAND_5GHZ];
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700944 }
945
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700946 return 0;
947
Johannes Berg8318d782008-01-24 19:38:38 +0100948 exit_free_channels:
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700949 kfree(channels);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700950 ERROR(rt2x00dev, "Allocation ieee80211 modes failed.\n");
951 return -ENOMEM;
952}
953
954static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
955{
Ivo van Doorn066cb632007-09-25 20:55:39 +0200956 if (test_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags))
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700957 ieee80211_unregister_hw(rt2x00dev->hw);
958
Johannes Berg8318d782008-01-24 19:38:38 +0100959 if (likely(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ])) {
960 kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
961 kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->bitrates);
962 rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
963 rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700964 }
965}
966
967static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
968{
969 struct hw_mode_spec *spec = &rt2x00dev->spec;
970 int status;
971
972 /*
973 * Initialize HW modes.
974 */
975 status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
976 if (status)
977 return status;
978
979 /*
980 * Register HW.
981 */
982 status = ieee80211_register_hw(rt2x00dev->hw);
983 if (status) {
984 rt2x00lib_remove_hw(rt2x00dev);
985 return status;
986 }
987
Ivo van Doorn066cb632007-09-25 20:55:39 +0200988 __set_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700989
990 return 0;
991}
992
993/*
994 * Initialization/uninitialization handlers.
995 */
Ivo van Doorne37ea212008-01-06 23:40:07 +0100996static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700997{
998 if (!__test_and_clear_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
999 return;
1000
1001 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001002 * Unregister extra components.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001003 */
1004 rt2x00rfkill_unregister(rt2x00dev);
1005
1006 /*
1007 * Allow the HW to uninitialize.
1008 */
1009 rt2x00dev->ops->lib->uninitialize(rt2x00dev);
1010
1011 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001012 * Free allocated queue entries.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001013 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001014 rt2x00queue_uninitialize(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001015}
1016
Ivo van Doorne37ea212008-01-06 23:40:07 +01001017static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001018{
1019 int status;
1020
1021 if (test_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
1022 return 0;
1023
1024 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001025 * Allocate all queue entries.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001026 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001027 status = rt2x00queue_initialize(rt2x00dev);
1028 if (status)
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001029 return status;
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001030
1031 /*
1032 * Initialize the device.
1033 */
1034 status = rt2x00dev->ops->lib->initialize(rt2x00dev);
Ivo van Doorned499982008-05-05 17:23:47 +02001035 if (status) {
1036 rt2x00queue_uninitialize(rt2x00dev);
1037 return status;
1038 }
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001039
1040 __set_bit(DEVICE_INITIALIZED, &rt2x00dev->flags);
1041
1042 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001043 * Register the extra components.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001044 */
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001045 rt2x00rfkill_register(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001046
1047 return 0;
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001048}
1049
Ivo van Doorne37ea212008-01-06 23:40:07 +01001050int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
1051{
1052 int retval;
1053
1054 if (test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1055 return 0;
1056
1057 /*
1058 * If this is the first interface which is added,
1059 * we should load the firmware now.
1060 */
Ivo van Doorn9404ef32008-02-03 15:48:38 +01001061 retval = rt2x00lib_load_firmware(rt2x00dev);
1062 if (retval)
1063 return retval;
Ivo van Doorne37ea212008-01-06 23:40:07 +01001064
1065 /*
1066 * Initialize the device.
1067 */
1068 retval = rt2x00lib_initialize(rt2x00dev);
1069 if (retval)
1070 return retval;
1071
1072 /*
1073 * Enable radio.
1074 */
1075 retval = rt2x00lib_enable_radio(rt2x00dev);
1076 if (retval) {
1077 rt2x00lib_uninitialize(rt2x00dev);
1078 return retval;
1079 }
1080
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001081 rt2x00dev->intf_ap_count = 0;
1082 rt2x00dev->intf_sta_count = 0;
1083 rt2x00dev->intf_associated = 0;
1084
Ivo van Doorne37ea212008-01-06 23:40:07 +01001085 __set_bit(DEVICE_STARTED, &rt2x00dev->flags);
1086
1087 return 0;
1088}
1089
1090void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
1091{
1092 if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1093 return;
1094
1095 /*
1096 * Perhaps we can add something smarter here,
1097 * but for now just disabling the radio should do.
1098 */
1099 rt2x00lib_disable_radio(rt2x00dev);
1100
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001101 rt2x00dev->intf_ap_count = 0;
1102 rt2x00dev->intf_sta_count = 0;
1103 rt2x00dev->intf_associated = 0;
1104
Ivo van Doorne37ea212008-01-06 23:40:07 +01001105 __clear_bit(DEVICE_STARTED, &rt2x00dev->flags);
1106}
1107
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001108/*
1109 * driver allocation handlers.
1110 */
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001111int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
1112{
1113 int retval = -ENOMEM;
1114
1115 /*
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001116 * Make room for rt2x00_intf inside the per-interface
1117 * structure ieee80211_vif.
1118 */
1119 rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf);
1120
1121 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001122 * Let the driver probe the device to detect the capabilities.
1123 */
1124 retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
1125 if (retval) {
1126 ERROR(rt2x00dev, "Failed to allocate device.\n");
1127 goto exit;
1128 }
1129
1130 /*
1131 * Initialize configuration work.
1132 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001133 INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
Johannes Berg4150c572007-09-17 01:29:23 -04001134 INIT_WORK(&rt2x00dev->filter_work, rt2x00lib_packetfilter_scheduled);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001135 INIT_DELAYED_WORK(&rt2x00dev->link.work, rt2x00lib_link_tuner);
1136
1137 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001138 * Allocate queue array.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001139 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001140 retval = rt2x00queue_allocate(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001141 if (retval)
1142 goto exit;
1143
1144 /*
1145 * Initialize ieee80211 structure.
1146 */
1147 retval = rt2x00lib_probe_hw(rt2x00dev);
1148 if (retval) {
1149 ERROR(rt2x00dev, "Failed to initialize hw.\n");
1150 goto exit;
1151 }
1152
1153 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001154 * Register extra components.
Ivo van Doorna9450b72008-02-03 15:53:40 +01001155 */
1156 rt2x00leds_register(rt2x00dev);
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001157 rt2x00rfkill_allocate(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001158 rt2x00debug_register(rt2x00dev);
1159
Ivo van Doorn066cb632007-09-25 20:55:39 +02001160 __set_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1161
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001162 return 0;
1163
1164exit:
1165 rt2x00lib_remove_dev(rt2x00dev);
1166
1167 return retval;
1168}
1169EXPORT_SYMBOL_GPL(rt2x00lib_probe_dev);
1170
1171void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
1172{
Ivo van Doorn066cb632007-09-25 20:55:39 +02001173 __clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1174
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001175 /*
1176 * Disable radio.
1177 */
1178 rt2x00lib_disable_radio(rt2x00dev);
1179
1180 /*
1181 * Uninitialize device.
1182 */
1183 rt2x00lib_uninitialize(rt2x00dev);
1184
1185 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001186 * Free extra components
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001187 */
1188 rt2x00debug_deregister(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001189 rt2x00rfkill_free(rt2x00dev);
Ivo van Doorna9450b72008-02-03 15:53:40 +01001190 rt2x00leds_unregister(rt2x00dev);
1191
1192 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001193 * Free ieee80211_hw memory.
1194 */
1195 rt2x00lib_remove_hw(rt2x00dev);
1196
1197 /*
1198 * Free firmware image.
1199 */
1200 rt2x00lib_free_firmware(rt2x00dev);
1201
1202 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001203 * Free queue structures.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001204 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001205 rt2x00queue_free(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001206}
1207EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev);
1208
1209/*
1210 * Device state handlers
1211 */
1212#ifdef CONFIG_PM
1213int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state)
1214{
1215 int retval;
1216
1217 NOTICE(rt2x00dev, "Going to sleep.\n");
Ivo van Doorn066cb632007-09-25 20:55:39 +02001218 __clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1219
1220 /*
1221 * Only continue if mac80211 has open interfaces.
1222 */
1223 if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1224 goto exit;
Ivo van Doorn6d7f9872007-10-06 14:12:42 +02001225 __set_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001226
1227 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001228 * Disable radio.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001229 */
Ivo van Doorne37ea212008-01-06 23:40:07 +01001230 rt2x00lib_stop(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001231 rt2x00lib_uninitialize(rt2x00dev);
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001232
1233 /*
1234 * Suspend/disable extra components.
1235 */
Ivo van Doorna9450b72008-02-03 15:53:40 +01001236 rt2x00leds_suspend(rt2x00dev);
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001237 rt2x00rfkill_suspend(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001238 rt2x00debug_deregister(rt2x00dev);
1239
Ivo van Doorn066cb632007-09-25 20:55:39 +02001240exit:
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001241 /*
Ivo van Doorn98963222008-03-27 17:15:24 +01001242 * Set device mode to sleep for power management,
1243 * on some hardware this call seems to consistently fail.
1244 * From the specifications it is hard to tell why it fails,
1245 * and if this is a "bad thing".
1246 * Overall it is safe to just ignore the failure and
1247 * continue suspending. The only downside is that the
1248 * device will not be in optimal power save mode, but with
1249 * the radio and the other components already disabled the
1250 * device is as good as disabled.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001251 */
1252 retval = rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP);
1253 if (retval)
Ivo van Doorn98963222008-03-27 17:15:24 +01001254 WARNING(rt2x00dev, "Device failed to enter sleep state, "
1255 "continue suspending.\n");
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001256
1257 return 0;
1258}
1259EXPORT_SYMBOL_GPL(rt2x00lib_suspend);
1260
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001261static void rt2x00lib_resume_intf(void *data, u8 *mac,
1262 struct ieee80211_vif *vif)
1263{
1264 struct rt2x00_dev *rt2x00dev = data;
1265 struct rt2x00_intf *intf = vif_to_intf(vif);
1266
1267 spin_lock(&intf->lock);
1268
1269 rt2x00lib_config_intf(rt2x00dev, intf,
1270 vif->type, intf->mac, intf->bssid);
1271
1272
1273 /*
1274 * Master or Ad-hoc mode require a new beacon update.
1275 */
1276 if (vif->type == IEEE80211_IF_TYPE_AP ||
1277 vif->type == IEEE80211_IF_TYPE_IBSS)
1278 intf->delayed_flags |= DELAYED_UPDATE_BEACON;
1279
1280 spin_unlock(&intf->lock);
1281}
1282
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001283int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
1284{
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001285 int retval;
1286
1287 NOTICE(rt2x00dev, "Waking up.\n");
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001288
1289 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001290 * Restore/enable extra components.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001291 */
1292 rt2x00debug_register(rt2x00dev);
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001293 rt2x00rfkill_resume(rt2x00dev);
Ivo van Doorna9450b72008-02-03 15:53:40 +01001294 rt2x00leds_resume(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001295
1296 /*
Ivo van Doorn6d7f9872007-10-06 14:12:42 +02001297 * Only continue if mac80211 had open interfaces.
Ivo van Doorn066cb632007-09-25 20:55:39 +02001298 */
Ivo van Doorn6d7f9872007-10-06 14:12:42 +02001299 if (!__test_and_clear_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags))
Ivo van Doorn066cb632007-09-25 20:55:39 +02001300 return 0;
1301
1302 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001303 * Reinitialize device and all active interfaces.
1304 */
Ivo van Doorne37ea212008-01-06 23:40:07 +01001305 retval = rt2x00lib_start(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001306 if (retval)
1307 goto exit;
1308
1309 /*
1310 * Reconfigure device.
1311 */
Ivo van Doorn066cb632007-09-25 20:55:39 +02001312 rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf, 1);
1313 if (!rt2x00dev->hw->conf.radio_enabled)
1314 rt2x00lib_disable_radio(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001315
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001316 /*
1317 * Iterator over each active interface to
1318 * reconfigure the hardware.
1319 */
1320 ieee80211_iterate_active_interfaces(rt2x00dev->hw,
1321 rt2x00lib_resume_intf, rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001322
1323 /*
Ivo van Doorne37ea212008-01-06 23:40:07 +01001324 * We are ready again to receive requests from mac80211.
1325 */
1326 __set_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1327
1328 /*
Ivo van Doorn066cb632007-09-25 20:55:39 +02001329 * It is possible that during that mac80211 has attempted
1330 * to send frames while we were suspending or resuming.
1331 * In that case we have disabled the TX queue and should
1332 * now enable it again
1333 */
1334 ieee80211_start_queues(rt2x00dev->hw);
1335
1336 /*
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001337 * During interface iteration we might have changed the
1338 * delayed_flags, time to handles the event by calling
1339 * the work handler directly.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001340 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001341 rt2x00lib_intf_scheduled(&rt2x00dev->intf_work);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001342
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001343 return 0;
1344
1345exit:
1346 rt2x00lib_disable_radio(rt2x00dev);
1347 rt2x00lib_uninitialize(rt2x00dev);
1348 rt2x00debug_deregister(rt2x00dev);
1349
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001350 return retval;
1351}
1352EXPORT_SYMBOL_GPL(rt2x00lib_resume);
1353#endif /* CONFIG_PM */
1354
1355/*
1356 * rt2x00lib module information.
1357 */
1358MODULE_AUTHOR(DRV_PROJECT);
1359MODULE_VERSION(DRV_VERSION);
1360MODULE_DESCRIPTION("rt2x00 library");
1361MODULE_LICENSE("GPL");