blob: ce1f7bbd3d7a4644bee999d361f0a2e844887075 [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"
31
32/*
Ivo van Doorn95ea3622007-09-25 17:57:13 -070033 * Link tuning handlers
34 */
Ivo van Doorn53b3f8e2008-02-25 23:15:13 +010035void rt2x00lib_reset_link_tuner(struct rt2x00_dev *rt2x00dev)
Ivo van Doorn95ea3622007-09-25 17:57:13 -070036{
Ivo van Doorn53b3f8e2008-02-25 23:15:13 +010037 if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
38 return;
39
40 /*
41 * Reset link information.
42 * Both the currently active vgc level as well as
43 * the link tuner counter should be reset. Resetting
44 * the counter is important for devices where the
45 * device should only perform link tuning during the
46 * first minute after being enabled.
47 */
Ivo van Doorn8de8c512007-10-13 16:26:32 +020048 rt2x00dev->link.count = 0;
49 rt2x00dev->link.vgc_level = 0;
50
Ivo van Doorn53b3f8e2008-02-25 23:15:13 +010051 /*
52 * Reset the link tuner.
53 */
54 rt2x00dev->ops->lib->reset_tuner(rt2x00dev);
55}
56
57static void rt2x00lib_start_link_tuner(struct rt2x00_dev *rt2x00dev)
58{
59 /*
60 * Clear all (possibly) pre-existing quality statistics.
61 */
Ivo van Doorn8de8c512007-10-13 16:26:32 +020062 memset(&rt2x00dev->link.qual, 0, sizeof(rt2x00dev->link.qual));
63
64 /*
65 * The RX and TX percentage should start at 50%
66 * this will assure we will get at least get some
67 * decent value when the link tuner starts.
68 * The value will be dropped and overwritten with
69 * the correct (measured )value anyway during the
70 * first run of the link tuner.
71 */
72 rt2x00dev->link.qual.rx_percentage = 50;
73 rt2x00dev->link.qual.tx_percentage = 50;
Ivo van Doorn95ea3622007-09-25 17:57:13 -070074
Ivo van Doorn53b3f8e2008-02-25 23:15:13 +010075 rt2x00lib_reset_link_tuner(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -070076
77 queue_delayed_work(rt2x00dev->hw->workqueue,
78 &rt2x00dev->link.work, LINK_TUNE_INTERVAL);
79}
80
81static void rt2x00lib_stop_link_tuner(struct rt2x00_dev *rt2x00dev)
82{
Ivo van Doorn3e309682007-09-25 20:56:36 +020083 cancel_delayed_work_sync(&rt2x00dev->link.work);
Ivo van Doorn95ea3622007-09-25 17:57:13 -070084}
85
Ivo van Doorn95ea3622007-09-25 17:57:13 -070086/*
87 * Radio control handlers.
88 */
89int rt2x00lib_enable_radio(struct rt2x00_dev *rt2x00dev)
90{
91 int status;
92
93 /*
94 * Don't enable the radio twice.
95 * And check if the hardware button has been disabled.
96 */
97 if (test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) ||
Ivo van Doorn81873e92007-10-06 14:14:06 +020098 test_bit(DEVICE_DISABLED_RADIO_HW, &rt2x00dev->flags))
Ivo van Doorn95ea3622007-09-25 17:57:13 -070099 return 0;
100
101 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500102 * Initialize all data queues.
Ivo van Doorn837e7f22008-01-06 23:41:45 +0100103 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500104 rt2x00queue_init_rx(rt2x00dev);
105 rt2x00queue_init_tx(rt2x00dev);
Ivo van Doorn837e7f22008-01-06 23:41:45 +0100106
107 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700108 * Enable radio.
109 */
Ivo van Doorna2e1d522008-03-31 15:53:44 +0200110 status =
111 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_ON);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700112 if (status)
113 return status;
114
Ivo van Doorn2b08da32008-06-03 18:58:56 +0200115 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_ON);
116
Ivo van Doorna2e1d522008-03-31 15:53:44 +0200117 rt2x00leds_led_radio(rt2x00dev, true);
Ivo van Doorn61c2b682008-04-21 19:01:09 +0200118 rt2x00led_led_activity(rt2x00dev, true);
Ivo van Doorna2e1d522008-03-31 15:53:44 +0200119
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700120 __set_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags);
121
122 /*
123 * Enable RX.
124 */
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200125 rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_ON);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700126
127 /*
128 * Start the TX queues.
129 */
Johannes Berg36d68252008-05-15 12:55:26 +0200130 ieee80211_wake_queues(rt2x00dev->hw);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700131
132 return 0;
133}
134
135void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
136{
137 if (!__test_and_clear_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
138 return;
139
140 /*
Johannes Berg4150c572007-09-17 01:29:23 -0400141 * Stop all scheduled work.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700142 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100143 if (work_pending(&rt2x00dev->intf_work))
144 cancel_work_sync(&rt2x00dev->intf_work);
Johannes Berg4150c572007-09-17 01:29:23 -0400145 if (work_pending(&rt2x00dev->filter_work))
146 cancel_work_sync(&rt2x00dev->filter_work);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700147
148 /*
149 * Stop the TX queues.
150 */
151 ieee80211_stop_queues(rt2x00dev->hw);
152
153 /*
154 * Disable RX.
155 */
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200156 rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_OFF);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700157
158 /*
159 * Disable radio.
160 */
161 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF);
Ivo van Doorn2b08da32008-06-03 18:58:56 +0200162 rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_OFF);
Ivo van Doorn61c2b682008-04-21 19:01:09 +0200163 rt2x00led_led_activity(rt2x00dev, false);
Ivo van Doorna2e1d522008-03-31 15:53:44 +0200164 rt2x00leds_led_radio(rt2x00dev, false);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700165}
166
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200167void rt2x00lib_toggle_rx(struct rt2x00_dev *rt2x00dev, enum dev_state state)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700168{
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700169 /*
170 * When we are disabling the RX, we should also stop the link tuner.
171 */
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200172 if (state == STATE_RADIO_RX_OFF)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700173 rt2x00lib_stop_link_tuner(rt2x00dev);
174
175 rt2x00dev->ops->lib->set_device_state(rt2x00dev, state);
176
177 /*
178 * When we are enabling the RX, we should also start the link tuner.
179 */
Ivo van Doorn5cbf8302007-10-06 14:16:09 +0200180 if (state == STATE_RADIO_RX_ON &&
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100181 (rt2x00dev->intf_ap_count || rt2x00dev->intf_sta_count))
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700182 rt2x00lib_start_link_tuner(rt2x00dev);
183}
184
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200185static void rt2x00lib_evaluate_antenna_sample(struct rt2x00_dev *rt2x00dev)
186{
187 enum antenna rx = rt2x00dev->link.ant.active.rx;
188 enum antenna tx = rt2x00dev->link.ant.active.tx;
189 int sample_a =
190 rt2x00_get_link_ant_rssi_history(&rt2x00dev->link, ANTENNA_A);
191 int sample_b =
192 rt2x00_get_link_ant_rssi_history(&rt2x00dev->link, ANTENNA_B);
193
194 /*
195 * We are done sampling. Now we should evaluate the results.
196 */
197 rt2x00dev->link.ant.flags &= ~ANTENNA_MODE_SAMPLE;
198
199 /*
200 * During the last period we have sampled the RSSI
201 * from both antenna's. It now is time to determine
202 * which antenna demonstrated the best performance.
203 * When we are already on the antenna with the best
204 * performance, then there really is nothing for us
205 * left to do.
206 */
207 if (sample_a == sample_b)
208 return;
209
Ivo van Doorn05253c92008-02-25 23:15:08 +0100210 if (rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY)
211 rx = (sample_a > sample_b) ? ANTENNA_A : ANTENNA_B;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200212
Ivo van Doorn05253c92008-02-25 23:15:08 +0100213 if (rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)
214 tx = (sample_a > sample_b) ? ANTENNA_A : ANTENNA_B;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200215
216 rt2x00lib_config_antenna(rt2x00dev, rx, tx);
217}
218
219static void rt2x00lib_evaluate_antenna_eval(struct rt2x00_dev *rt2x00dev)
220{
221 enum antenna rx = rt2x00dev->link.ant.active.rx;
222 enum antenna tx = rt2x00dev->link.ant.active.tx;
223 int rssi_curr = rt2x00_get_link_ant_rssi(&rt2x00dev->link);
224 int rssi_old = rt2x00_update_ant_rssi(&rt2x00dev->link, rssi_curr);
225
226 /*
227 * Legacy driver indicates that we should swap antenna's
228 * when the difference in RSSI is greater that 5. This
229 * also should be done when the RSSI was actually better
230 * then the previous sample.
231 * When the difference exceeds the threshold we should
232 * sample the rssi from the other antenna to make a valid
233 * comparison between the 2 antennas.
234 */
Ivo van Doornb290d432008-02-25 23:15:01 +0100235 if (abs(rssi_curr - rssi_old) < 5)
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200236 return;
237
238 rt2x00dev->link.ant.flags |= ANTENNA_MODE_SAMPLE;
239
240 if (rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY)
241 rx = (rx == ANTENNA_A) ? ANTENNA_B : ANTENNA_A;
242
243 if (rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)
244 tx = (tx == ANTENNA_A) ? ANTENNA_B : ANTENNA_A;
245
246 rt2x00lib_config_antenna(rt2x00dev, rx, tx);
247}
248
249static void rt2x00lib_evaluate_antenna(struct rt2x00_dev *rt2x00dev)
250{
251 /*
252 * Determine if software diversity is enabled for
253 * either the TX or RX antenna (or both).
254 * Always perform this check since within the link
255 * tuner interval the configuration might have changed.
256 */
257 rt2x00dev->link.ant.flags &= ~ANTENNA_RX_DIVERSITY;
258 rt2x00dev->link.ant.flags &= ~ANTENNA_TX_DIVERSITY;
259
260 if (rt2x00dev->hw->conf.antenna_sel_rx == 0 &&
Ivo van Doornb290d432008-02-25 23:15:01 +0100261 rt2x00dev->default_ant.rx == ANTENNA_SW_DIVERSITY)
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200262 rt2x00dev->link.ant.flags |= ANTENNA_RX_DIVERSITY;
263 if (rt2x00dev->hw->conf.antenna_sel_tx == 0 &&
Ivo van Doornb290d432008-02-25 23:15:01 +0100264 rt2x00dev->default_ant.tx == ANTENNA_SW_DIVERSITY)
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200265 rt2x00dev->link.ant.flags |= ANTENNA_TX_DIVERSITY;
266
267 if (!(rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY) &&
268 !(rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)) {
Ivo van Doorn05253c92008-02-25 23:15:08 +0100269 rt2x00dev->link.ant.flags = 0;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200270 return;
271 }
272
273 /*
274 * If we have only sampled the data over the last period
275 * we should now harvest the data. Otherwise just evaluate
276 * the data. The latter should only be performed once
277 * every 2 seconds.
278 */
279 if (rt2x00dev->link.ant.flags & ANTENNA_MODE_SAMPLE)
280 rt2x00lib_evaluate_antenna_sample(rt2x00dev);
281 else if (rt2x00dev->link.count & 1)
282 rt2x00lib_evaluate_antenna_eval(rt2x00dev);
283}
284
285static void rt2x00lib_update_link_stats(struct link *link, int rssi)
286{
287 int avg_rssi = rssi;
288
289 /*
290 * Update global RSSI
291 */
292 if (link->qual.avg_rssi)
293 avg_rssi = MOVING_AVERAGE(link->qual.avg_rssi, rssi, 8);
294 link->qual.avg_rssi = avg_rssi;
295
296 /*
297 * Update antenna RSSI
298 */
299 if (link->ant.rssi_ant)
300 rssi = MOVING_AVERAGE(link->ant.rssi_ant, rssi, 8);
301 link->ant.rssi_ant = rssi;
302}
303
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200304static void rt2x00lib_precalculate_link_signal(struct link_qual *qual)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700305{
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200306 if (qual->rx_failed || qual->rx_success)
307 qual->rx_percentage =
308 (qual->rx_success * 100) /
309 (qual->rx_failed + qual->rx_success);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700310 else
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200311 qual->rx_percentage = 50;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700312
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200313 if (qual->tx_failed || qual->tx_success)
314 qual->tx_percentage =
315 (qual->tx_success * 100) /
316 (qual->tx_failed + qual->tx_success);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700317 else
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200318 qual->tx_percentage = 50;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700319
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200320 qual->rx_success = 0;
321 qual->rx_failed = 0;
322 qual->tx_success = 0;
323 qual->tx_failed = 0;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700324}
325
326static int rt2x00lib_calculate_link_signal(struct rt2x00_dev *rt2x00dev,
327 int rssi)
328{
329 int rssi_percentage = 0;
330 int signal;
331
332 /*
333 * We need a positive value for the RSSI.
334 */
335 if (rssi < 0)
336 rssi += rt2x00dev->rssi_offset;
337
338 /*
339 * Calculate the different percentages,
340 * which will be used for the signal.
341 */
342 if (rt2x00dev->rssi_offset)
343 rssi_percentage = (rssi * 100) / rt2x00dev->rssi_offset;
344
345 /*
346 * Add the individual percentages and use the WEIGHT
347 * defines to calculate the current link signal.
348 */
349 signal = ((WEIGHT_RSSI * rssi_percentage) +
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200350 (WEIGHT_TX * rt2x00dev->link.qual.tx_percentage) +
351 (WEIGHT_RX * rt2x00dev->link.qual.rx_percentage)) / 100;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700352
353 return (signal > 100) ? 100 : signal;
354}
355
356static void rt2x00lib_link_tuner(struct work_struct *work)
357{
358 struct rt2x00_dev *rt2x00dev =
359 container_of(work, struct rt2x00_dev, link.work.work);
360
361 /*
Ivo van Doorn25ab0022007-09-25 20:57:04 +0200362 * When the radio is shutting down we should
363 * immediately cease all link tuning.
364 */
365 if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
366 return;
367
368 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700369 * Update statistics.
370 */
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200371 rt2x00dev->ops->lib->link_stats(rt2x00dev, &rt2x00dev->link.qual);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700372 rt2x00dev->low_level_stats.dot11FCSErrorCount +=
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200373 rt2x00dev->link.qual.rx_failed;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700374
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700375 /*
376 * Only perform the link tuning when Link tuning
377 * has been enabled (This could have been disabled from the EEPROM).
378 */
379 if (!test_bit(CONFIG_DISABLE_LINK_TUNING, &rt2x00dev->flags))
380 rt2x00dev->ops->lib->link_tuner(rt2x00dev);
381
382 /*
Ivo van Doorn725d99d2007-09-25 20:53:20 +0200383 * Precalculate a portion of the link signal which is
384 * in based on the tx/rx success/failure counters.
385 */
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200386 rt2x00lib_precalculate_link_signal(&rt2x00dev->link.qual);
Ivo van Doorn725d99d2007-09-25 20:53:20 +0200387
388 /*
Ivo van Doorna9450b72008-02-03 15:53:40 +0100389 * Send a signal to the led to update the led signal strength.
390 */
391 rt2x00leds_led_quality(rt2x00dev, rt2x00dev->link.qual.avg_rssi);
392
393 /*
Ivo van Doorn53b3f8e2008-02-25 23:15:13 +0100394 * Evaluate antenna setup, make this the last step since this could
395 * possibly reset some statistics.
396 */
397 rt2x00lib_evaluate_antenna(rt2x00dev);
398
399 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700400 * Increase tuner counter, and reschedule the next link tuner run.
401 */
402 rt2x00dev->link.count++;
403 queue_delayed_work(rt2x00dev->hw->workqueue, &rt2x00dev->link.work,
404 LINK_TUNE_INTERVAL);
405}
406
Johannes Berg4150c572007-09-17 01:29:23 -0400407static void rt2x00lib_packetfilter_scheduled(struct work_struct *work)
408{
409 struct rt2x00_dev *rt2x00dev =
410 container_of(work, struct rt2x00_dev, filter_work);
Ivo van Doorn5886d0d2007-10-06 14:13:38 +0200411
Ivo van Doorn133adf02008-04-04 00:01:43 +0200412 rt2x00dev->ops->lib->config_filter(rt2x00dev, rt2x00dev->packet_filter);
Johannes Berg4150c572007-09-17 01:29:23 -0400413}
414
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100415static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
416 struct ieee80211_vif *vif)
Ivo van Doorn5c58ee52007-10-06 13:34:52 +0200417{
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100418 struct rt2x00_dev *rt2x00dev = data;
419 struct rt2x00_intf *intf = vif_to_intf(vif);
420 struct sk_buff *skb;
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100421 struct ieee80211_bss_conf conf;
422 int delayed_flags;
Johannes Berg471b3ef2007-12-28 14:32:58 +0100423
424 /*
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100425 * Copy all data we need during this action under the protection
426 * of a spinlock. Otherwise race conditions might occur which results
427 * into an invalid configuration.
Johannes Berg471b3ef2007-12-28 14:32:58 +0100428 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100429 spin_lock(&intf->lock);
430
431 memcpy(&conf, &intf->conf, sizeof(conf));
432 delayed_flags = intf->delayed_flags;
433 intf->delayed_flags = 0;
434
435 spin_unlock(&intf->lock);
436
437 if (delayed_flags & DELAYED_UPDATE_BEACON) {
Johannes Berge039fa42008-05-15 12:55:29 +0200438 skb = ieee80211_beacon_get(rt2x00dev->hw, vif);
439 if (skb &&
440 rt2x00dev->ops->hw->beacon_update(rt2x00dev->hw, skb))
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100441 dev_kfree_skb(skb);
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100442 }
443
Ivo van Doorn72810372008-03-09 22:46:18 +0100444 if (delayed_flags & DELAYED_CONFIG_ERP)
445 rt2x00lib_config_erp(rt2x00dev, intf, &intf->conf);
Ivo van Doorna2e1d522008-03-31 15:53:44 +0200446
447 if (delayed_flags & DELAYED_LED_ASSOC)
448 rt2x00leds_led_assoc(rt2x00dev, !!rt2x00dev->intf_associated);
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100449}
450
451static void rt2x00lib_intf_scheduled(struct work_struct *work)
452{
453 struct rt2x00_dev *rt2x00dev =
454 container_of(work, struct rt2x00_dev, intf_work);
455
456 /*
457 * Iterate over each interface and perform the
458 * requested configurations.
459 */
460 ieee80211_iterate_active_interfaces(rt2x00dev->hw,
461 rt2x00lib_intf_scheduled_iter,
462 rt2x00dev);
Ivo van Doorn5c58ee52007-10-06 13:34:52 +0200463}
464
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700465/*
466 * Interrupt context handlers.
467 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100468static void rt2x00lib_beacondone_iter(void *data, u8 *mac,
469 struct ieee80211_vif *vif)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700470{
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100471 struct rt2x00_intf *intf = vif_to_intf(vif);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700472
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100473 if (vif->type != IEEE80211_IF_TYPE_AP &&
474 vif->type != IEEE80211_IF_TYPE_IBSS)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700475 return;
476
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100477 spin_lock(&intf->lock);
478 intf->delayed_flags |= DELAYED_UPDATE_BEACON;
479 spin_unlock(&intf->lock);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700480}
481
482void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
483{
484 if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
485 return;
486
Ivo van Doorn633257d2008-05-23 18:14:02 +0200487 ieee80211_iterate_active_interfaces_atomic(rt2x00dev->hw,
488 rt2x00lib_beacondone_iter,
489 rt2x00dev);
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100490
491 queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->intf_work);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700492}
493EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);
494
Ivo van Doorn181d6902008-02-05 16:42:23 -0500495void rt2x00lib_txdone(struct queue_entry *entry,
496 struct txdone_entry_desc *txdesc)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700497{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500498 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
Johannes Berge039fa42008-05-15 12:55:29 +0200499 struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb);
500
501 /*
502 * Send frame to debugfs immediately, after this call is completed
503 * we are going to overwrite the skb->cb array.
504 */
505 rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_TXDONE, entry->skb);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700506
507 /*
508 * Update TX statistics.
509 */
Ivo van Doornfb55f4d2008-05-10 13:42:06 +0200510 rt2x00dev->link.qual.tx_success +=
511 test_bit(TXDONE_SUCCESS, &txdesc->flags);
512 rt2x00dev->link.qual.tx_failed +=
John W. Linvillecb14cb72008-06-10 09:06:52 -0400513 test_bit(TXDONE_FAILURE, &txdesc->flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700514
Ivo van Doorn181d6902008-02-05 16:42:23 -0500515 /*
516 * Initialize TX status
517 */
Johannes Berge039fa42008-05-15 12:55:29 +0200518 memset(&tx_info->status, 0, sizeof(tx_info->status));
519 tx_info->status.ack_signal = 0;
520 tx_info->status.excessive_retries =
Ivo van Doornfb55f4d2008-05-10 13:42:06 +0200521 test_bit(TXDONE_EXCESSIVE_RETRY, &txdesc->flags);
Johannes Berge039fa42008-05-15 12:55:29 +0200522 tx_info->status.retry_count = txdesc->retry;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500523
Johannes Berge039fa42008-05-15 12:55:29 +0200524 if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK)) {
Ivo van Doornfb55f4d2008-05-10 13:42:06 +0200525 if (test_bit(TXDONE_SUCCESS, &txdesc->flags))
Johannes Berge039fa42008-05-15 12:55:29 +0200526 tx_info->flags |= IEEE80211_TX_STAT_ACK;
Ivo van Doornfb55f4d2008-05-10 13:42:06 +0200527 else if (test_bit(TXDONE_FAILURE, &txdesc->flags))
Ivo van Doorn181d6902008-02-05 16:42:23 -0500528 rt2x00dev->low_level_stats.dot11ACKFailureCount++;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700529 }
530
Johannes Berge039fa42008-05-15 12:55:29 +0200531 if (tx_info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) {
Ivo van Doornfb55f4d2008-05-10 13:42:06 +0200532 if (test_bit(TXDONE_SUCCESS, &txdesc->flags))
Ivo van Doorn181d6902008-02-05 16:42:23 -0500533 rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
Ivo van Doornfb55f4d2008-05-10 13:42:06 +0200534 else if (test_bit(TXDONE_FAILURE, &txdesc->flags))
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 /*
Johannes Berge039fa42008-05-15 12:55:29 +0200539 * Only send the status report to mac80211 when TX status was
540 * requested by it. If this was a extra frame coming through
541 * a mac80211 library call (RTS/CTS) then we should not send the
542 * status report back.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700543 */
Johannes Berge039fa42008-05-15 12:55:29 +0200544 if (tx_info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS)
545 ieee80211_tx_status_irqsafe(rt2x00dev->hw, entry->skb);
Ivo van Doornbaf26a72008-02-17 17:32:08 +0100546 else
Ivo van Doornfb55f4d2008-05-10 13:42:06 +0200547 dev_kfree_skb_irq(entry->skb);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700548 entry->skb = NULL;
549}
550EXPORT_SYMBOL_GPL(rt2x00lib_txdone);
551
Ivo van Doorn181d6902008-02-05 16:42:23 -0500552void rt2x00lib_rxdone(struct queue_entry *entry,
553 struct rxdone_entry_desc *rxdesc)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700554{
Ivo van Doorn181d6902008-02-05 16:42:23 -0500555 struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700556 struct ieee80211_rx_status *rx_status = &rt2x00dev->rx_status;
Gertjan van Wingerde239c2492008-06-06 22:54:12 +0200557 unsigned int header_size = ieee80211_get_hdrlen_from_skb(entry->skb);
Johannes Berg8318d782008-01-24 19:38:38 +0100558 struct ieee80211_supported_band *sband;
Mattias Nissler61af43c2007-11-27 21:50:26 +0100559 struct ieee80211_hdr *hdr;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100560 const struct rt2x00_rate *rate;
Gertjan van Wingerde239c2492008-06-06 22:54:12 +0200561 unsigned int align;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700562 unsigned int i;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100563 int idx = -1;
Mattias Nissler61af43c2007-11-27 21:50:26 +0100564 u16 fc;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700565
566 /*
Gertjan van Wingerde239c2492008-06-06 22:54:12 +0200567 * The data behind the ieee80211 header must be
568 * aligned on a 4 byte boundary. We already reserved
569 * 2 bytes for header_size % 4 == 2 optimization.
570 * To determine the number of bytes which the data
571 * should be moved to the left, we must add these
572 * 2 bytes to the header_size.
573 */
574 align = (header_size + 2) % 4;
575
576 if (align) {
577 skb_push(entry->skb, align);
578 /* Move entire frame in 1 command */
579 memmove(entry->skb->data, entry->skb->data + align,
580 rxdesc->size);
581 }
582
583 /* Update data pointers, trim buffer to correct size */
584 skb_trim(entry->skb, rxdesc->size);
585
586 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700587 * Update RX statistics.
588 */
Johannes Berg8318d782008-01-24 19:38:38 +0100589 sband = &rt2x00dev->bands[rt2x00dev->curr_band];
590 for (i = 0; i < sband->n_bitrates; i++) {
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100591 rate = rt2x00_get_rate(sband->bitrates[i].hw_value);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700592
Ivo van Doorn19d30e02008-03-15 21:38:07 +0100593 if (((rxdesc->dev_flags & RXDONE_SIGNAL_PLCP) &&
594 (rate->plcp == rxdesc->signal)) ||
595 (!(rxdesc->dev_flags & RXDONE_SIGNAL_PLCP) &&
596 (rate->bitrate == rxdesc->signal))) {
Johannes Berg8318d782008-01-24 19:38:38 +0100597 idx = i;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700598 break;
599 }
600 }
601
Ivo van Doorn866a0502008-03-25 14:12:45 +0100602 if (idx < 0) {
603 WARNING(rt2x00dev, "Frame received with unrecognized signal,"
604 "signal=0x%.2x, plcp=%d.\n", rxdesc->signal,
605 !!(rxdesc->dev_flags & RXDONE_SIGNAL_PLCP));
606 idx = 0;
607 }
608
Mattias Nissler61af43c2007-11-27 21:50:26 +0100609 /*
Ivo van Doorn7e56d382008-01-06 23:41:28 +0100610 * Only update link status if this is a beacon frame carrying our bssid.
Mattias Nissler61af43c2007-11-27 21:50:26 +0100611 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100612 hdr = (struct ieee80211_hdr *)entry->skb->data;
Ivo van Doorn7e56d382008-01-06 23:41:28 +0100613 fc = le16_to_cpu(hdr->frame_control);
Ivo van Doorn19d30e02008-03-15 21:38:07 +0100614 if (is_beacon(fc) && (rxdesc->dev_flags & RXDONE_MY_BSS))
Ivo van Doorn181d6902008-02-05 16:42:23 -0500615 rt2x00lib_update_link_stats(&rt2x00dev->link, rxdesc->rssi);
Mattias Nissler61af43c2007-11-27 21:50:26 +0100616
Ivo van Doornebcf26d2007-10-13 16:26:12 +0200617 rt2x00dev->link.qual.rx_success++;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200618
Johannes Berg8318d782008-01-24 19:38:38 +0100619 rx_status->rate_idx = idx;
Bruno Randolf566bfe52008-05-08 19:15:40 +0200620 rx_status->qual =
Ivo van Doorn181d6902008-02-05 16:42:23 -0500621 rt2x00lib_calculate_link_signal(rt2x00dev, rxdesc->rssi);
Bruno Randolf566bfe52008-05-08 19:15:40 +0200622 rx_status->signal = rxdesc->rssi;
Ivo van Doorn181d6902008-02-05 16:42:23 -0500623 rx_status->flag = rxdesc->flags;
Ivo van Doorn69f81a22007-10-13 16:26:36 +0200624 rx_status->antenna = rt2x00dev->link.ant.active.rx;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700625
626 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500627 * Send frame to mac80211 & debugfs.
628 * mac80211 will clean up the skb structure.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700629 */
Ivo van Doorn5a6e5992008-05-10 13:41:32 +0200630 rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_RXDONE, entry->skb);
Ivo van Doorn181d6902008-02-05 16:42:23 -0500631 ieee80211_rx_irqsafe(rt2x00dev->hw, entry->skb, rx_status);
632 entry->skb = NULL;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700633}
634EXPORT_SYMBOL_GPL(rt2x00lib_rxdone);
635
636/*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700637 * Driver initialization handlers.
638 */
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100639const struct rt2x00_rate rt2x00_supported_rates[12] = {
640 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100641 .flags = DEV_RATE_CCK | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100642 .bitrate = 10,
Ivo van Doornaa776722008-03-09 22:48:08 +0100643 .ratemask = BIT(0),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100644 .plcp = 0x00,
645 },
646 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100647 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100648 .bitrate = 20,
Ivo van Doornaa776722008-03-09 22:48:08 +0100649 .ratemask = BIT(1),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100650 .plcp = 0x01,
651 },
652 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100653 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100654 .bitrate = 55,
Ivo van Doornaa776722008-03-09 22:48:08 +0100655 .ratemask = BIT(2),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100656 .plcp = 0x02,
657 },
658 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100659 .flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100660 .bitrate = 110,
Ivo van Doornaa776722008-03-09 22:48:08 +0100661 .ratemask = BIT(3),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100662 .plcp = 0x03,
663 },
664 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100665 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100666 .bitrate = 60,
Ivo van Doornaa776722008-03-09 22:48:08 +0100667 .ratemask = BIT(4),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100668 .plcp = 0x0b,
669 },
670 {
671 .flags = DEV_RATE_OFDM,
672 .bitrate = 90,
Ivo van Doornaa776722008-03-09 22:48:08 +0100673 .ratemask = BIT(5),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100674 .plcp = 0x0f,
675 },
676 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100677 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100678 .bitrate = 120,
Ivo van Doornaa776722008-03-09 22:48:08 +0100679 .ratemask = BIT(6),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100680 .plcp = 0x0a,
681 },
682 {
683 .flags = DEV_RATE_OFDM,
684 .bitrate = 180,
Ivo van Doornaa776722008-03-09 22:48:08 +0100685 .ratemask = BIT(7),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100686 .plcp = 0x0e,
687 },
688 {
Ivo van Doornaa776722008-03-09 22:48:08 +0100689 .flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100690 .bitrate = 240,
Ivo van Doornaa776722008-03-09 22:48:08 +0100691 .ratemask = BIT(8),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100692 .plcp = 0x09,
693 },
694 {
695 .flags = DEV_RATE_OFDM,
696 .bitrate = 360,
Ivo van Doornaa776722008-03-09 22:48:08 +0100697 .ratemask = BIT(9),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100698 .plcp = 0x0d,
699 },
700 {
701 .flags = DEV_RATE_OFDM,
702 .bitrate = 480,
Ivo van Doornaa776722008-03-09 22:48:08 +0100703 .ratemask = BIT(10),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100704 .plcp = 0x08,
705 },
706 {
707 .flags = DEV_RATE_OFDM,
708 .bitrate = 540,
Ivo van Doornaa776722008-03-09 22:48:08 +0100709 .ratemask = BIT(11),
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100710 .plcp = 0x0c,
711 },
712};
713
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700714static void rt2x00lib_channel(struct ieee80211_channel *entry,
715 const int channel, const int tx_power,
716 const int value)
717{
Ivo van Doornf2a3c7f2008-02-03 15:52:45 +0100718 entry->center_freq = ieee80211_channel_to_frequency(channel);
Johannes Berg8318d782008-01-24 19:38:38 +0100719 entry->hw_value = value;
720 entry->max_power = tx_power;
721 entry->max_antenna_gain = 0xff;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700722}
723
724static void rt2x00lib_rate(struct ieee80211_rate *entry,
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100725 const u16 index, const struct rt2x00_rate *rate)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700726{
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100727 entry->flags = 0;
728 entry->bitrate = rate->bitrate;
729 entry->hw_value = rt2x00_create_rate_hw_value(index, 0);
Johannes Berg8318d782008-01-24 19:38:38 +0100730 entry->hw_value_short = entry->hw_value;
Ivo van Doorn70e2fed2008-02-03 15:50:40 +0100731
732 if (rate->flags & DEV_RATE_SHORT_PREAMBLE) {
733 entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
734 entry->hw_value_short |= rt2x00_create_rate_hw_value(index, 1);
735 }
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700736}
737
738static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
739 struct hw_mode_spec *spec)
740{
741 struct ieee80211_hw *hw = rt2x00dev->hw;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700742 struct ieee80211_channel *channels;
743 struct ieee80211_rate *rates;
Ivo van Doorn31562e82008-02-17 17:35:05 +0100744 unsigned int num_rates;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700745 unsigned int i;
746 unsigned char tx_power;
747
Ivo van Doorn31562e82008-02-17 17:35:05 +0100748 num_rates = 0;
749 if (spec->supported_rates & SUPPORT_RATE_CCK)
750 num_rates += 4;
751 if (spec->supported_rates & SUPPORT_RATE_OFDM)
752 num_rates += 8;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700753
754 channels = kzalloc(sizeof(*channels) * spec->num_channels, GFP_KERNEL);
755 if (!channels)
Johannes Berg8318d782008-01-24 19:38:38 +0100756 return -ENOMEM;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700757
Ivo van Doorn31562e82008-02-17 17:35:05 +0100758 rates = kzalloc(sizeof(*rates) * num_rates, GFP_KERNEL);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700759 if (!rates)
760 goto exit_free_channels;
761
762 /*
763 * Initialize Rate list.
764 */
Ivo van Doorn31562e82008-02-17 17:35:05 +0100765 for (i = 0; i < num_rates; i++)
Ivo van Doorn8f5fa7f2008-02-03 15:54:34 +0100766 rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i));
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700767
768 /*
769 * Initialize Channel list.
770 */
771 for (i = 0; i < spec->num_channels; i++) {
Ivo van Doorn31562e82008-02-17 17:35:05 +0100772 if (spec->channels[i].channel <= 14) {
773 if (spec->tx_power_bg)
774 tx_power = spec->tx_power_bg[i];
775 else
776 tx_power = spec->tx_power_default;
777 } else {
778 if (spec->tx_power_a)
779 tx_power = spec->tx_power_a[i];
780 else
781 tx_power = spec->tx_power_default;
782 }
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700783
784 rt2x00lib_channel(&channels[i],
785 spec->channels[i].channel, tx_power, i);
786 }
787
788 /*
Ivo van Doorn31562e82008-02-17 17:35:05 +0100789 * Intitialize 802.11b, 802.11g
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700790 * Rates: CCK, OFDM.
Johannes Berg8318d782008-01-24 19:38:38 +0100791 * Channels: 2.4 GHz
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700792 */
Gertjan van Wingerde47ac2682008-02-17 17:35:55 +0100793 if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
Ivo van Doorn31562e82008-02-17 17:35:05 +0100794 rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_channels = 14;
795 rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_bitrates = num_rates;
796 rt2x00dev->bands[IEEE80211_BAND_2GHZ].channels = channels;
797 rt2x00dev->bands[IEEE80211_BAND_2GHZ].bitrates = rates;
798 hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
799 &rt2x00dev->bands[IEEE80211_BAND_2GHZ];
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700800 }
801
802 /*
803 * Intitialize 802.11a
804 * Rates: OFDM.
805 * Channels: OFDM, UNII, HiperLAN2.
806 */
Gertjan van Wingerde47ac2682008-02-17 17:35:55 +0100807 if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
Ivo van Doorn31562e82008-02-17 17:35:05 +0100808 rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_channels =
809 spec->num_channels - 14;
810 rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_bitrates =
811 num_rates - 4;
812 rt2x00dev->bands[IEEE80211_BAND_5GHZ].channels = &channels[14];
813 rt2x00dev->bands[IEEE80211_BAND_5GHZ].bitrates = &rates[4];
814 hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
815 &rt2x00dev->bands[IEEE80211_BAND_5GHZ];
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700816 }
817
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700818 return 0;
819
Johannes Berg8318d782008-01-24 19:38:38 +0100820 exit_free_channels:
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700821 kfree(channels);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700822 ERROR(rt2x00dev, "Allocation ieee80211 modes failed.\n");
823 return -ENOMEM;
824}
825
826static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
827{
Ivo van Doorn066cb632007-09-25 20:55:39 +0200828 if (test_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags))
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700829 ieee80211_unregister_hw(rt2x00dev->hw);
830
Johannes Berg8318d782008-01-24 19:38:38 +0100831 if (likely(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ])) {
832 kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
833 kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->bitrates);
834 rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
835 rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700836 }
837}
838
839static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
840{
841 struct hw_mode_spec *spec = &rt2x00dev->spec;
842 int status;
843
844 /*
845 * Initialize HW modes.
846 */
847 status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
848 if (status)
849 return status;
850
851 /*
Gertjan van Wingerde61448f82008-05-10 13:43:33 +0200852 * Initialize HW fields.
853 */
854 rt2x00dev->hw->queues = rt2x00dev->ops->tx_queues;
855
856 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700857 * Register HW.
858 */
859 status = ieee80211_register_hw(rt2x00dev->hw);
860 if (status) {
861 rt2x00lib_remove_hw(rt2x00dev);
862 return status;
863 }
864
Ivo van Doorn066cb632007-09-25 20:55:39 +0200865 __set_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700866
867 return 0;
868}
869
870/*
871 * Initialization/uninitialization handlers.
872 */
Ivo van Doorne37ea212008-01-06 23:40:07 +0100873static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700874{
875 if (!__test_and_clear_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
876 return;
877
878 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +0100879 * Unregister extra components.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700880 */
881 rt2x00rfkill_unregister(rt2x00dev);
882
883 /*
884 * Allow the HW to uninitialize.
885 */
886 rt2x00dev->ops->lib->uninitialize(rt2x00dev);
887
888 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500889 * Free allocated queue entries.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700890 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500891 rt2x00queue_uninitialize(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700892}
893
Ivo van Doorne37ea212008-01-06 23:40:07 +0100894static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700895{
896 int status;
897
898 if (test_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
899 return 0;
900
901 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -0500902 * Allocate all queue entries.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700903 */
Ivo van Doorn181d6902008-02-05 16:42:23 -0500904 status = rt2x00queue_initialize(rt2x00dev);
905 if (status)
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700906 return status;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700907
908 /*
909 * Initialize the device.
910 */
911 status = rt2x00dev->ops->lib->initialize(rt2x00dev);
Ivo van Doorned499982008-05-05 17:23:47 +0200912 if (status) {
913 rt2x00queue_uninitialize(rt2x00dev);
914 return status;
915 }
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700916
917 __set_bit(DEVICE_INITIALIZED, &rt2x00dev->flags);
918
919 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +0100920 * Register the extra components.
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700921 */
Ivo van Doorn1682fe62008-03-13 15:38:03 +0100922 rt2x00rfkill_register(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700923
924 return 0;
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700925}
926
Ivo van Doorne37ea212008-01-06 23:40:07 +0100927int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
928{
929 int retval;
930
931 if (test_bit(DEVICE_STARTED, &rt2x00dev->flags))
932 return 0;
933
934 /*
935 * If this is the first interface which is added,
936 * we should load the firmware now.
937 */
Ivo van Doorn9404ef32008-02-03 15:48:38 +0100938 retval = rt2x00lib_load_firmware(rt2x00dev);
939 if (retval)
940 return retval;
Ivo van Doorne37ea212008-01-06 23:40:07 +0100941
942 /*
943 * Initialize the device.
944 */
945 retval = rt2x00lib_initialize(rt2x00dev);
946 if (retval)
947 return retval;
948
949 /*
950 * Enable radio.
951 */
952 retval = rt2x00lib_enable_radio(rt2x00dev);
953 if (retval) {
954 rt2x00lib_uninitialize(rt2x00dev);
955 return retval;
956 }
957
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100958 rt2x00dev->intf_ap_count = 0;
959 rt2x00dev->intf_sta_count = 0;
960 rt2x00dev->intf_associated = 0;
961
Ivo van Doorne37ea212008-01-06 23:40:07 +0100962 __set_bit(DEVICE_STARTED, &rt2x00dev->flags);
963
964 return 0;
965}
966
967void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
968{
969 if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
970 return;
971
972 /*
973 * Perhaps we can add something smarter here,
974 * but for now just disabling the radio should do.
975 */
976 rt2x00lib_disable_radio(rt2x00dev);
977
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100978 rt2x00dev->intf_ap_count = 0;
979 rt2x00dev->intf_sta_count = 0;
980 rt2x00dev->intf_associated = 0;
981
Ivo van Doorne37ea212008-01-06 23:40:07 +0100982 __clear_bit(DEVICE_STARTED, &rt2x00dev->flags);
983}
984
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700985/*
986 * driver allocation handlers.
987 */
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700988int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
989{
990 int retval = -ENOMEM;
991
992 /*
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +0100993 * Make room for rt2x00_intf inside the per-interface
994 * structure ieee80211_vif.
995 */
996 rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf);
997
998 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -0700999 * Let the driver probe the device to detect the capabilities.
1000 */
1001 retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
1002 if (retval) {
1003 ERROR(rt2x00dev, "Failed to allocate device.\n");
1004 goto exit;
1005 }
1006
1007 /*
1008 * Initialize configuration work.
1009 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001010 INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
Johannes Berg4150c572007-09-17 01:29:23 -04001011 INIT_WORK(&rt2x00dev->filter_work, rt2x00lib_packetfilter_scheduled);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001012 INIT_DELAYED_WORK(&rt2x00dev->link.work, rt2x00lib_link_tuner);
1013
1014 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001015 * Allocate queue array.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001016 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001017 retval = rt2x00queue_allocate(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001018 if (retval)
1019 goto exit;
1020
1021 /*
1022 * Initialize ieee80211 structure.
1023 */
1024 retval = rt2x00lib_probe_hw(rt2x00dev);
1025 if (retval) {
1026 ERROR(rt2x00dev, "Failed to initialize hw.\n");
1027 goto exit;
1028 }
1029
1030 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001031 * Register extra components.
Ivo van Doorna9450b72008-02-03 15:53:40 +01001032 */
1033 rt2x00leds_register(rt2x00dev);
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001034 rt2x00rfkill_allocate(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001035 rt2x00debug_register(rt2x00dev);
1036
Ivo van Doorn066cb632007-09-25 20:55:39 +02001037 __set_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1038
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001039 return 0;
1040
1041exit:
1042 rt2x00lib_remove_dev(rt2x00dev);
1043
1044 return retval;
1045}
1046EXPORT_SYMBOL_GPL(rt2x00lib_probe_dev);
1047
1048void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
1049{
Ivo van Doorn066cb632007-09-25 20:55:39 +02001050 __clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1051
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001052 /*
1053 * Disable radio.
1054 */
1055 rt2x00lib_disable_radio(rt2x00dev);
1056
1057 /*
1058 * Uninitialize device.
1059 */
1060 rt2x00lib_uninitialize(rt2x00dev);
1061
1062 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001063 * Free extra components
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001064 */
1065 rt2x00debug_deregister(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001066 rt2x00rfkill_free(rt2x00dev);
Ivo van Doorna9450b72008-02-03 15:53:40 +01001067 rt2x00leds_unregister(rt2x00dev);
1068
1069 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001070 * Free ieee80211_hw memory.
1071 */
1072 rt2x00lib_remove_hw(rt2x00dev);
1073
1074 /*
1075 * Free firmware image.
1076 */
1077 rt2x00lib_free_firmware(rt2x00dev);
1078
1079 /*
Ivo van Doorn181d6902008-02-05 16:42:23 -05001080 * Free queue structures.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001081 */
Ivo van Doorn181d6902008-02-05 16:42:23 -05001082 rt2x00queue_free(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001083}
1084EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev);
1085
1086/*
1087 * Device state handlers
1088 */
1089#ifdef CONFIG_PM
1090int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state)
1091{
1092 int retval;
1093
1094 NOTICE(rt2x00dev, "Going to sleep.\n");
Ivo van Doorn066cb632007-09-25 20:55:39 +02001095 __clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1096
1097 /*
1098 * Only continue if mac80211 has open interfaces.
1099 */
1100 if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
1101 goto exit;
Ivo van Doorn6d7f9872007-10-06 14:12:42 +02001102 __set_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001103
1104 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001105 * Disable radio.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001106 */
Ivo van Doorne37ea212008-01-06 23:40:07 +01001107 rt2x00lib_stop(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001108 rt2x00lib_uninitialize(rt2x00dev);
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001109
1110 /*
1111 * Suspend/disable extra components.
1112 */
Ivo van Doorna9450b72008-02-03 15:53:40 +01001113 rt2x00leds_suspend(rt2x00dev);
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001114 rt2x00rfkill_suspend(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001115 rt2x00debug_deregister(rt2x00dev);
1116
Ivo van Doorn066cb632007-09-25 20:55:39 +02001117exit:
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001118 /*
Ivo van Doorn98963222008-03-27 17:15:24 +01001119 * Set device mode to sleep for power management,
1120 * on some hardware this call seems to consistently fail.
1121 * From the specifications it is hard to tell why it fails,
1122 * and if this is a "bad thing".
1123 * Overall it is safe to just ignore the failure and
1124 * continue suspending. The only downside is that the
1125 * device will not be in optimal power save mode, but with
1126 * the radio and the other components already disabled the
1127 * device is as good as disabled.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001128 */
1129 retval = rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP);
1130 if (retval)
Ivo van Doorn98963222008-03-27 17:15:24 +01001131 WARNING(rt2x00dev, "Device failed to enter sleep state, "
1132 "continue suspending.\n");
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001133
1134 return 0;
1135}
1136EXPORT_SYMBOL_GPL(rt2x00lib_suspend);
1137
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001138static void rt2x00lib_resume_intf(void *data, u8 *mac,
1139 struct ieee80211_vif *vif)
1140{
1141 struct rt2x00_dev *rt2x00dev = data;
1142 struct rt2x00_intf *intf = vif_to_intf(vif);
1143
1144 spin_lock(&intf->lock);
1145
1146 rt2x00lib_config_intf(rt2x00dev, intf,
1147 vif->type, intf->mac, intf->bssid);
1148
1149
1150 /*
1151 * Master or Ad-hoc mode require a new beacon update.
1152 */
1153 if (vif->type == IEEE80211_IF_TYPE_AP ||
1154 vif->type == IEEE80211_IF_TYPE_IBSS)
1155 intf->delayed_flags |= DELAYED_UPDATE_BEACON;
1156
1157 spin_unlock(&intf->lock);
1158}
1159
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001160int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
1161{
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001162 int retval;
1163
1164 NOTICE(rt2x00dev, "Waking up.\n");
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001165
1166 /*
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001167 * Restore/enable extra components.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001168 */
1169 rt2x00debug_register(rt2x00dev);
Ivo van Doorn1682fe62008-03-13 15:38:03 +01001170 rt2x00rfkill_resume(rt2x00dev);
Ivo van Doorna9450b72008-02-03 15:53:40 +01001171 rt2x00leds_resume(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001172
1173 /*
Ivo van Doorn6d7f9872007-10-06 14:12:42 +02001174 * Only continue if mac80211 had open interfaces.
Ivo van Doorn066cb632007-09-25 20:55:39 +02001175 */
Ivo van Doorn6d7f9872007-10-06 14:12:42 +02001176 if (!__test_and_clear_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags))
Ivo van Doorn066cb632007-09-25 20:55:39 +02001177 return 0;
1178
1179 /*
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001180 * Reinitialize device and all active interfaces.
1181 */
Ivo van Doorne37ea212008-01-06 23:40:07 +01001182 retval = rt2x00lib_start(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001183 if (retval)
1184 goto exit;
1185
1186 /*
1187 * Reconfigure device.
1188 */
Ivo van Doorn066cb632007-09-25 20:55:39 +02001189 rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf, 1);
1190 if (!rt2x00dev->hw->conf.radio_enabled)
1191 rt2x00lib_disable_radio(rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001192
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001193 /*
1194 * Iterator over each active interface to
1195 * reconfigure the hardware.
1196 */
1197 ieee80211_iterate_active_interfaces(rt2x00dev->hw,
1198 rt2x00lib_resume_intf, rt2x00dev);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001199
1200 /*
Ivo van Doorne37ea212008-01-06 23:40:07 +01001201 * We are ready again to receive requests from mac80211.
1202 */
1203 __set_bit(DEVICE_PRESENT, &rt2x00dev->flags);
1204
1205 /*
Ivo van Doorn066cb632007-09-25 20:55:39 +02001206 * It is possible that during that mac80211 has attempted
1207 * to send frames while we were suspending or resuming.
1208 * In that case we have disabled the TX queue and should
1209 * now enable it again
1210 */
Johannes Berg36d68252008-05-15 12:55:26 +02001211 ieee80211_wake_queues(rt2x00dev->hw);
Ivo van Doorn066cb632007-09-25 20:55:39 +02001212
1213 /*
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001214 * During interface iteration we might have changed the
1215 * delayed_flags, time to handles the event by calling
1216 * the work handler directly.
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001217 */
Ivo van Doorn6bb40dd2008-02-03 15:49:59 +01001218 rt2x00lib_intf_scheduled(&rt2x00dev->intf_work);
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001219
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001220 return 0;
1221
1222exit:
1223 rt2x00lib_disable_radio(rt2x00dev);
1224 rt2x00lib_uninitialize(rt2x00dev);
1225 rt2x00debug_deregister(rt2x00dev);
1226
Ivo van Doorn95ea3622007-09-25 17:57:13 -07001227 return retval;
1228}
1229EXPORT_SYMBOL_GPL(rt2x00lib_resume);
1230#endif /* CONFIG_PM */
1231
1232/*
1233 * rt2x00lib module information.
1234 */
1235MODULE_AUTHOR(DRV_PROJECT);
1236MODULE_VERSION(DRV_VERSION);
1237MODULE_DESCRIPTION("rt2x00 library");
1238MODULE_LICENSE("GPL");