rt2x00dev.c 30 KB
Newer Older
1
/*
2
	Copyright (C) 2004 - 2008 rt2x00 SourceForge Project
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
	<http://rt2x00.serialmonkey.com>

	This program is free software; you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation; either version 2 of the License, or
	(at your option) any later version.

	This program is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with this program; if not, write to the
	Free Software Foundation, Inc.,
	59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*
	Module: rt2x00lib
	Abstract: rt2x00 generic device routines.
 */

#include <linux/kernel.h>
#include <linux/module.h>

#include "rt2x00.h"
#include "rt2x00lib.h"

/*
 * Link tuning handlers
 */
35
void rt2x00lib_reset_link_tuner(struct rt2x00_dev *rt2x00dev)
36
{
37
38
39
40
41
42
43
44
45
46
47
	if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
		return;

	/*
	 * Reset link information.
	 * Both the currently active vgc level as well as
	 * the link tuner counter should be reset. Resetting
	 * the counter is important for devices where the
	 * device should only perform link tuning during the
	 * first minute after being enabled.
	 */
48
49
50
	rt2x00dev->link.count = 0;
	rt2x00dev->link.vgc_level = 0;

51
52
53
54
55
56
57
58
59
60
61
	/*
	 * Reset the link tuner.
	 */
	rt2x00dev->ops->lib->reset_tuner(rt2x00dev);
}

static void rt2x00lib_start_link_tuner(struct rt2x00_dev *rt2x00dev)
{
	/*
	 * Clear all (possibly) pre-existing quality statistics.
	 */
62
63
64
65
66
67
68
69
70
71
72
73
	memset(&rt2x00dev->link.qual, 0, sizeof(rt2x00dev->link.qual));

	/*
	 * The RX and TX percentage should start at 50%
	 * this will assure we will get at least get some
	 * decent value when the link tuner starts.
	 * The value will be dropped and overwritten with
	 * the correct (measured )value anyway during the
	 * first run of the link tuner.
	 */
	rt2x00dev->link.qual.rx_percentage = 50;
	rt2x00dev->link.qual.tx_percentage = 50;
74

75
	rt2x00lib_reset_link_tuner(rt2x00dev);
76
77
78
79
80
81
82

	queue_delayed_work(rt2x00dev->hw->workqueue,
			   &rt2x00dev->link.work, LINK_TUNE_INTERVAL);
}

static void rt2x00lib_stop_link_tuner(struct rt2x00_dev *rt2x00dev)
{
83
	cancel_delayed_work_sync(&rt2x00dev->link.work);
84
85
86
87
88
89
90
91
92
93
94
95
96
97
}

/*
 * Radio control handlers.
 */
int rt2x00lib_enable_radio(struct rt2x00_dev *rt2x00dev)
{
	int status;

	/*
	 * Don't enable the radio twice.
	 * And check if the hardware button has been disabled.
	 */
	if (test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags) ||
98
	    test_bit(DEVICE_DISABLED_RADIO_HW, &rt2x00dev->flags))
99
100
		return 0;

101
	/*
102
	 * Initialize all data queues.
103
	 */
104
105
	rt2x00queue_init_rx(rt2x00dev);
	rt2x00queue_init_tx(rt2x00dev);
106

107
108
109
	/*
	 * Enable radio.
	 */
110
111
	status =
	    rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_ON);
112
113
114
	if (status)
		return status;

115
116
	rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_ON);

117
	rt2x00leds_led_radio(rt2x00dev, true);
118
	rt2x00led_led_activity(rt2x00dev, true);
119

120
121
122
123
124
	__set_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags);

	/*
	 * Enable RX.
	 */
125
	rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_ON);
126
127
128
129

	/*
	 * Start the TX queues.
	 */
130
	ieee80211_wake_queues(rt2x00dev->hw);
131
132
133
134
135
136
137
138
139
140

	return 0;
}

void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
{
	if (!__test_and_clear_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
		return;

	/*
141
	 * Stop all scheduled work.
142
	 */
143
144
	if (work_pending(&rt2x00dev->intf_work))
		cancel_work_sync(&rt2x00dev->intf_work);
145
146
	if (work_pending(&rt2x00dev->filter_work))
		cancel_work_sync(&rt2x00dev->filter_work);
147
148
149
150
151
152
153
154
155

	/*
	 * Stop the TX queues.
	 */
	ieee80211_stop_queues(rt2x00dev->hw);

	/*
	 * Disable RX.
	 */
156
	rt2x00lib_toggle_rx(rt2x00dev, STATE_RADIO_RX_OFF);
157
158
159
160
161

	/*
	 * Disable radio.
	 */
	rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF);
162
	rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_OFF);
163
	rt2x00led_led_activity(rt2x00dev, false);
164
	rt2x00leds_led_radio(rt2x00dev, false);
165
166
}

167
void rt2x00lib_toggle_rx(struct rt2x00_dev *rt2x00dev, enum dev_state state)
168
169
170
171
{
	/*
	 * When we are disabling the RX, we should also stop the link tuner.
	 */
172
	if (state == STATE_RADIO_RX_OFF)
173
174
175
176
177
178
179
		rt2x00lib_stop_link_tuner(rt2x00dev);

	rt2x00dev->ops->lib->set_device_state(rt2x00dev, state);

	/*
	 * When we are enabling the RX, we should also start the link tuner.
	 */
180
	if (state == STATE_RADIO_RX_ON &&
181
	    (rt2x00dev->intf_ap_count || rt2x00dev->intf_sta_count))
182
183
184
		rt2x00lib_start_link_tuner(rt2x00dev);
}

185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
static void rt2x00lib_evaluate_antenna_sample(struct rt2x00_dev *rt2x00dev)
{
	enum antenna rx = rt2x00dev->link.ant.active.rx;
	enum antenna tx = rt2x00dev->link.ant.active.tx;
	int sample_a =
	    rt2x00_get_link_ant_rssi_history(&rt2x00dev->link, ANTENNA_A);
	int sample_b =
	    rt2x00_get_link_ant_rssi_history(&rt2x00dev->link, ANTENNA_B);

	/*
	 * We are done sampling. Now we should evaluate the results.
	 */
	rt2x00dev->link.ant.flags &= ~ANTENNA_MODE_SAMPLE;

	/*
	 * During the last period we have sampled the RSSI
	 * from both antenna's. It now is time to determine
	 * which antenna demonstrated the best performance.
	 * When we are already on the antenna with the best
	 * performance, then there really is nothing for us
	 * left to do.
	 */
	if (sample_a == sample_b)
		return;

210
211
	if (rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY)
		rx = (sample_a > sample_b) ? ANTENNA_A : ANTENNA_B;
212

213
214
	if (rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)
		tx = (sample_a > sample_b) ? ANTENNA_A : ANTENNA_B;
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234

	rt2x00lib_config_antenna(rt2x00dev, rx, tx);
}

static void rt2x00lib_evaluate_antenna_eval(struct rt2x00_dev *rt2x00dev)
{
	enum antenna rx = rt2x00dev->link.ant.active.rx;
	enum antenna tx = rt2x00dev->link.ant.active.tx;
	int rssi_curr = rt2x00_get_link_ant_rssi(&rt2x00dev->link);
	int rssi_old = rt2x00_update_ant_rssi(&rt2x00dev->link, rssi_curr);

	/*
	 * Legacy driver indicates that we should swap antenna's
	 * when the difference in RSSI is greater that 5. This
	 * also should be done when the RSSI was actually better
	 * then the previous sample.
	 * When the difference exceeds the threshold we should
	 * sample the rssi from the other antenna to make a valid
	 * comparison between the 2 antennas.
	 */
Ivo van Doorn's avatar
Ivo van Doorn committed
235
	if (abs(rssi_curr - rssi_old) < 5)
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
		return;

	rt2x00dev->link.ant.flags |= ANTENNA_MODE_SAMPLE;

	if (rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY)
		rx = (rx == ANTENNA_A) ? ANTENNA_B : ANTENNA_A;

	if (rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)
		tx = (tx == ANTENNA_A) ? ANTENNA_B : ANTENNA_A;

	rt2x00lib_config_antenna(rt2x00dev, rx, tx);
}

static void rt2x00lib_evaluate_antenna(struct rt2x00_dev *rt2x00dev)
{
	/*
	 * Determine if software diversity is enabled for
	 * either the TX or RX antenna (or both).
	 * Always perform this check since within the link
	 * tuner interval the configuration might have changed.
	 */
	rt2x00dev->link.ant.flags &= ~ANTENNA_RX_DIVERSITY;
	rt2x00dev->link.ant.flags &= ~ANTENNA_TX_DIVERSITY;

	if (rt2x00dev->hw->conf.antenna_sel_rx == 0 &&
Ivo van Doorn's avatar
Ivo van Doorn committed
261
	    rt2x00dev->default_ant.rx == ANTENNA_SW_DIVERSITY)
262
263
		rt2x00dev->link.ant.flags |= ANTENNA_RX_DIVERSITY;
	if (rt2x00dev->hw->conf.antenna_sel_tx == 0 &&
Ivo van Doorn's avatar
Ivo van Doorn committed
264
	    rt2x00dev->default_ant.tx == ANTENNA_SW_DIVERSITY)
265
266
267
268
		rt2x00dev->link.ant.flags |= ANTENNA_TX_DIVERSITY;

	if (!(rt2x00dev->link.ant.flags & ANTENNA_RX_DIVERSITY) &&
	    !(rt2x00dev->link.ant.flags & ANTENNA_TX_DIVERSITY)) {
269
		rt2x00dev->link.ant.flags = 0;
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
		return;
	}

	/*
	 * If we have only sampled the data over the last period
	 * we should now harvest the data. Otherwise just evaluate
	 * the data. The latter should only be performed once
	 * every 2 seconds.
	 */
	if (rt2x00dev->link.ant.flags & ANTENNA_MODE_SAMPLE)
		rt2x00lib_evaluate_antenna_sample(rt2x00dev);
	else if (rt2x00dev->link.count & 1)
		rt2x00lib_evaluate_antenna_eval(rt2x00dev);
}

static void rt2x00lib_update_link_stats(struct link *link, int rssi)
{
	int avg_rssi = rssi;

	/*
	 * Update global RSSI
	 */
	if (link->qual.avg_rssi)
		avg_rssi = MOVING_AVERAGE(link->qual.avg_rssi, rssi, 8);
	link->qual.avg_rssi = avg_rssi;

	/*
	 * Update antenna RSSI
	 */
	if (link->ant.rssi_ant)
		rssi = MOVING_AVERAGE(link->ant.rssi_ant, rssi, 8);
	link->ant.rssi_ant = rssi;
}

304
static void rt2x00lib_precalculate_link_signal(struct link_qual *qual)
305
{
306
307
308
309
	if (qual->rx_failed || qual->rx_success)
		qual->rx_percentage =
		    (qual->rx_success * 100) /
		    (qual->rx_failed + qual->rx_success);
310
	else
311
		qual->rx_percentage = 50;
312

313
314
315
316
	if (qual->tx_failed || qual->tx_success)
		qual->tx_percentage =
		    (qual->tx_success * 100) /
		    (qual->tx_failed + qual->tx_success);
317
	else
318
		qual->tx_percentage = 50;
319

320
321
322
323
	qual->rx_success = 0;
	qual->rx_failed = 0;
	qual->tx_success = 0;
	qual->tx_failed = 0;
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
}

static int rt2x00lib_calculate_link_signal(struct rt2x00_dev *rt2x00dev,
					   int rssi)
{
	int rssi_percentage = 0;
	int signal;

	/*
	 * We need a positive value for the RSSI.
	 */
	if (rssi < 0)
		rssi += rt2x00dev->rssi_offset;

	/*
	 * Calculate the different percentages,
	 * which will be used for the signal.
	 */
	if (rt2x00dev->rssi_offset)
		rssi_percentage = (rssi * 100) / rt2x00dev->rssi_offset;

	/*
	 * Add the individual percentages and use the WEIGHT
	 * defines to calculate the current link signal.
	 */
	signal = ((WEIGHT_RSSI * rssi_percentage) +
350
351
		  (WEIGHT_TX * rt2x00dev->link.qual.tx_percentage) +
		  (WEIGHT_RX * rt2x00dev->link.qual.rx_percentage)) / 100;
352
353
354
355
356
357
358
359
360

	return (signal > 100) ? 100 : signal;
}

static void rt2x00lib_link_tuner(struct work_struct *work)
{
	struct rt2x00_dev *rt2x00dev =
	    container_of(work, struct rt2x00_dev, link.work.work);

361
362
363
364
365
366
367
	/*
	 * When the radio is shutting down we should
	 * immediately cease all link tuning.
	 */
	if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
		return;

368
369
370
	/*
	 * Update statistics.
	 */
371
	rt2x00dev->ops->lib->link_stats(rt2x00dev, &rt2x00dev->link.qual);
372
	rt2x00dev->low_level_stats.dot11FCSErrorCount +=
373
	    rt2x00dev->link.qual.rx_failed;
374
375
376
377
378
379
380
381

	/*
	 * Only perform the link tuning when Link tuning
	 * has been enabled (This could have been disabled from the EEPROM).
	 */
	if (!test_bit(CONFIG_DISABLE_LINK_TUNING, &rt2x00dev->flags))
		rt2x00dev->ops->lib->link_tuner(rt2x00dev);

382
383
384
385
	/*
	 * Precalculate a portion of the link signal which is
	 * in based on the tx/rx success/failure counters.
	 */
386
	rt2x00lib_precalculate_link_signal(&rt2x00dev->link.qual);
387

388
389
390
391
392
	/*
	 * Send a signal to the led to update the led signal strength.
	 */
	rt2x00leds_led_quality(rt2x00dev, rt2x00dev->link.qual.avg_rssi);

393
394
395
396
397
398
	/*
	 * Evaluate antenna setup, make this the last step since this could
	 * possibly reset some statistics.
	 */
	rt2x00lib_evaluate_antenna(rt2x00dev);

399
400
401
402
403
404
405
406
	/*
	 * Increase tuner counter, and reschedule the next link tuner run.
	 */
	rt2x00dev->link.count++;
	queue_delayed_work(rt2x00dev->hw->workqueue, &rt2x00dev->link.work,
			   LINK_TUNE_INTERVAL);
}

407
408
409
410
static void rt2x00lib_packetfilter_scheduled(struct work_struct *work)
{
	struct rt2x00_dev *rt2x00dev =
	    container_of(work, struct rt2x00_dev, filter_work);
411

412
	rt2x00dev->ops->lib->config_filter(rt2x00dev, rt2x00dev->packet_filter);
413
414
}

415
416
static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
					  struct ieee80211_vif *vif)
417
{
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
	struct rt2x00_dev *rt2x00dev = data;
	struct rt2x00_intf *intf = vif_to_intf(vif);
	struct sk_buff *skb;
	struct ieee80211_bss_conf conf;
	int delayed_flags;

	/*
	 * Copy all data we need during this action under the protection
	 * of a spinlock. Otherwise race conditions might occur which results
	 * into an invalid configuration.
	 */
	spin_lock(&intf->lock);

	memcpy(&conf, &intf->conf, sizeof(conf));
	delayed_flags = intf->delayed_flags;
	intf->delayed_flags = 0;

	spin_unlock(&intf->lock);

	if (delayed_flags & DELAYED_UPDATE_BEACON) {
438
439
440
		skb = ieee80211_beacon_get(rt2x00dev->hw, vif);
		if (skb &&
		    rt2x00dev->ops->hw->beacon_update(rt2x00dev->hw, skb))
441
442
443
			dev_kfree_skb(skb);
	}

444
445
	if (delayed_flags & DELAYED_CONFIG_ERP)
		rt2x00lib_config_erp(rt2x00dev, intf, &intf->conf);
446
447
448

	if (delayed_flags & DELAYED_LED_ASSOC)
		rt2x00leds_led_assoc(rt2x00dev, !!rt2x00dev->intf_associated);
449
}
450

451
452
453
454
static void rt2x00lib_intf_scheduled(struct work_struct *work)
{
	struct rt2x00_dev *rt2x00dev =
	    container_of(work, struct rt2x00_dev, intf_work);
455
456

	/*
457
458
	 * Iterate over each interface and perform the
	 * requested configurations.
459
	 */
460
461
462
	ieee80211_iterate_active_interfaces(rt2x00dev->hw,
					    rt2x00lib_intf_scheduled_iter,
					    rt2x00dev);
463
464
}

465
466
467
/*
 * Interrupt context handlers.
 */
468
469
static void rt2x00lib_beacondone_iter(void *data, u8 *mac,
				      struct ieee80211_vif *vif)
470
{
471
	struct rt2x00_intf *intf = vif_to_intf(vif);
472

473
474
	if (vif->type != IEEE80211_IF_TYPE_AP &&
	    vif->type != IEEE80211_IF_TYPE_IBSS)
475
476
		return;

477
478
479
	spin_lock(&intf->lock);
	intf->delayed_flags |= DELAYED_UPDATE_BEACON;
	spin_unlock(&intf->lock);
480
481
482
483
484
485
486
}

void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
{
	if (!test_bit(DEVICE_ENABLED_RADIO, &rt2x00dev->flags))
		return;

487
488
489
	ieee80211_iterate_active_interfaces_atomic(rt2x00dev->hw,
						   rt2x00lib_beacondone_iter,
						   rt2x00dev);
490
491

	queue_work(rt2x00dev->hw->workqueue, &rt2x00dev->intf_work);
492
493
494
}
EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);

495
496
void rt2x00lib_txdone(struct queue_entry *entry,
		      struct txdone_entry_desc *txdesc)
497
{
498
	struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
499
500
501
502
503
504
505
	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb);

	/*
	 * Send frame to debugfs immediately, after this call is completed
	 * we are going to overwrite the skb->cb array.
	 */
	rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_TXDONE, entry->skb);
506
507
508
509

	/*
	 * Update TX statistics.
	 */
510
511
512
	rt2x00dev->link.qual.tx_success +=
	    test_bit(TXDONE_SUCCESS, &txdesc->flags);
	rt2x00dev->link.qual.tx_failed +=
513
	    test_bit(TXDONE_FAILURE, &txdesc->flags);
514

515
516
517
	/*
	 * Initialize TX status
	 */
518
519
520
	memset(&tx_info->status, 0, sizeof(tx_info->status));
	tx_info->status.ack_signal = 0;
	tx_info->status.excessive_retries =
521
	    test_bit(TXDONE_EXCESSIVE_RETRY, &txdesc->flags);
522
	tx_info->status.retry_count = txdesc->retry;
523

524
	if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK)) {
525
		if (test_bit(TXDONE_SUCCESS, &txdesc->flags))
526
			tx_info->flags |= IEEE80211_TX_STAT_ACK;
527
		else if (test_bit(TXDONE_FAILURE, &txdesc->flags))
528
			rt2x00dev->low_level_stats.dot11ACKFailureCount++;
529
530
	}

531
	if (tx_info->flags & IEEE80211_TX_CTL_USE_RTS_CTS) {
532
		if (test_bit(TXDONE_SUCCESS, &txdesc->flags))
533
			rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
534
		else if (test_bit(TXDONE_FAILURE, &txdesc->flags))
535
			rt2x00dev->low_level_stats.dot11RTSFailureCount++;
536
537
538
	}

	/*
539
540
541
542
	 * Only send the status report to mac80211 when TX status was
	 * requested by it. If this was a extra frame coming through
	 * a mac80211 library call (RTS/CTS) then we should not send the
	 * status report back.
543
	 */
544
545
	if (tx_info->flags & IEEE80211_TX_CTL_REQ_TX_STATUS)
		ieee80211_tx_status_irqsafe(rt2x00dev->hw, entry->skb);
546
	else
547
		dev_kfree_skb_irq(entry->skb);
548
549
550
551
	entry->skb = NULL;
}
EXPORT_SYMBOL_GPL(rt2x00lib_txdone);

552
553
void rt2x00lib_rxdone(struct queue_entry *entry,
		      struct rxdone_entry_desc *rxdesc)
554
{
555
	struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
556
	struct ieee80211_rx_status *rx_status = &rt2x00dev->rx_status;
557
	unsigned int header_size = ieee80211_get_hdrlen_from_skb(entry->skb);
558
	struct ieee80211_supported_band *sband;
559
	struct ieee80211_hdr *hdr;
560
	const struct rt2x00_rate *rate;
561
	unsigned int align;
562
	unsigned int i;
563
	int idx = -1;
564
	u16 fc;
565

566
567
	/*
	 * The data behind the ieee80211 header must be
568
	 * aligned on a 4 byte boundary.
569
	 */
570
	align = ((unsigned long)(entry->skb->data + header_size)) & 3;
571
572
573
574
575
576
577
578
579
580
581

	if (align) {
		skb_push(entry->skb, align);
		/* Move entire frame in 1 command */
		memmove(entry->skb->data, entry->skb->data + align,
			rxdesc->size);
	}

	/* Update data pointers, trim buffer to correct size */
	skb_trim(entry->skb, rxdesc->size);

582
583
584
	/*
	 * Update RX statistics.
	 */
585
586
	sband = &rt2x00dev->bands[rt2x00dev->curr_band];
	for (i = 0; i < sband->n_bitrates; i++) {
587
		rate = rt2x00_get_rate(sband->bitrates[i].hw_value);
588

589
590
591
592
		if (((rxdesc->dev_flags & RXDONE_SIGNAL_PLCP) &&
		     (rate->plcp == rxdesc->signal)) ||
		    (!(rxdesc->dev_flags & RXDONE_SIGNAL_PLCP) &&
		      (rate->bitrate == rxdesc->signal))) {
593
			idx = i;
594
595
596
597
			break;
		}
	}

598
599
600
601
602
603
604
	if (idx < 0) {
		WARNING(rt2x00dev, "Frame received with unrecognized signal,"
			"signal=0x%.2x, plcp=%d.\n", rxdesc->signal,
			!!(rxdesc->dev_flags & RXDONE_SIGNAL_PLCP));
		idx = 0;
	}

605
	/*
606
	 * Only update link status if this is a beacon frame carrying our bssid.
607
	 */
608
	hdr = (struct ieee80211_hdr *)entry->skb->data;
609
	fc = le16_to_cpu(hdr->frame_control);
610
	if (is_beacon(fc) && (rxdesc->dev_flags & RXDONE_MY_BSS))
611
		rt2x00lib_update_link_stats(&rt2x00dev->link, rxdesc->rssi);
612

613
	rt2x00dev->link.qual.rx_success++;
614

615
	rx_status->rate_idx = idx;
616
	rx_status->qual =
617
	    rt2x00lib_calculate_link_signal(rt2x00dev, rxdesc->rssi);
618
	rx_status->signal = rxdesc->rssi;
619
	rx_status->flag = rxdesc->flags;
620
	rx_status->antenna = rt2x00dev->link.ant.active.rx;
621
622

	/*
623
624
	 * Send frame to mac80211 & debugfs.
	 * mac80211 will clean up the skb structure.
625
	 */
626
	rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_RXDONE, entry->skb);
627
628
	ieee80211_rx_irqsafe(rt2x00dev->hw, entry->skb, rx_status);
	entry->skb = NULL;
629
630
631
632
633
634
}
EXPORT_SYMBOL_GPL(rt2x00lib_rxdone);

/*
 * Driver initialization handlers.
 */
635
636
const struct rt2x00_rate rt2x00_supported_rates[12] = {
	{
637
		.flags = DEV_RATE_CCK | DEV_RATE_BASIC,
638
		.bitrate = 10,
639
		.ratemask = BIT(0),
640
641
642
		.plcp = 0x00,
	},
	{
643
		.flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
644
		.bitrate = 20,
645
		.ratemask = BIT(1),
646
647
648
		.plcp = 0x01,
	},
	{
649
		.flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
650
		.bitrate = 55,
651
		.ratemask = BIT(2),
652
653
654
		.plcp = 0x02,
	},
	{
655
		.flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE | DEV_RATE_BASIC,
656
		.bitrate = 110,
657
		.ratemask = BIT(3),
658
659
660
		.plcp = 0x03,
	},
	{
661
		.flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
662
		.bitrate = 60,
663
		.ratemask = BIT(4),
664
665
666
667
668
		.plcp = 0x0b,
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 90,
669
		.ratemask = BIT(5),
670
671
672
		.plcp = 0x0f,
	},
	{
673
		.flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
674
		.bitrate = 120,
675
		.ratemask = BIT(6),
676
677
678
679
680
		.plcp = 0x0a,
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 180,
681
		.ratemask = BIT(7),
682
683
684
		.plcp = 0x0e,
	},
	{
685
		.flags = DEV_RATE_OFDM | DEV_RATE_BASIC,
686
		.bitrate = 240,
687
		.ratemask = BIT(8),
688
689
690
691
692
		.plcp = 0x09,
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 360,
693
		.ratemask = BIT(9),
694
695
696
697
698
		.plcp = 0x0d,
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 480,
699
		.ratemask = BIT(10),
700
701
702
703
704
		.plcp = 0x08,
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 540,
705
		.ratemask = BIT(11),
706
707
708
709
		.plcp = 0x0c,
	},
};

710
711
712
713
static void rt2x00lib_channel(struct ieee80211_channel *entry,
			      const int channel, const int tx_power,
			      const int value)
{
714
	entry->center_freq = ieee80211_channel_to_frequency(channel);
715
716
717
	entry->hw_value = value;
	entry->max_power = tx_power;
	entry->max_antenna_gain = 0xff;
718
719
720
}

static void rt2x00lib_rate(struct ieee80211_rate *entry,
721
			   const u16 index, const struct rt2x00_rate *rate)
722
{
723
724
725
	entry->flags = 0;
	entry->bitrate = rate->bitrate;
	entry->hw_value = rt2x00_create_rate_hw_value(index, 0);
726
	entry->hw_value_short = entry->hw_value;
727
728
729
730
731

	if (rate->flags & DEV_RATE_SHORT_PREAMBLE) {
		entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
		entry->hw_value_short |= rt2x00_create_rate_hw_value(index, 1);
	}
732
733
734
735
736
737
738
739
}

static int rt2x00lib_probe_hw_modes(struct rt2x00_dev *rt2x00dev,
				    struct hw_mode_spec *spec)
{
	struct ieee80211_hw *hw = rt2x00dev->hw;
	struct ieee80211_channel *channels;
	struct ieee80211_rate *rates;
740
	unsigned int num_rates;
741
742
743
	unsigned int i;
	unsigned char tx_power;

744
745
746
747
748
	num_rates = 0;
	if (spec->supported_rates & SUPPORT_RATE_CCK)
		num_rates += 4;
	if (spec->supported_rates & SUPPORT_RATE_OFDM)
		num_rates += 8;
749
750
751

	channels = kzalloc(sizeof(*channels) * spec->num_channels, GFP_KERNEL);
	if (!channels)
752
		return -ENOMEM;
753

754
	rates = kzalloc(sizeof(*rates) * num_rates, GFP_KERNEL);
755
756
757
758
759
760
	if (!rates)
		goto exit_free_channels;

	/*
	 * Initialize Rate list.
	 */
761
	for (i = 0; i < num_rates; i++)
762
		rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i));
763
764
765
766
767

	/*
	 * Initialize Channel list.
	 */
	for (i = 0; i < spec->num_channels; i++) {
768
769
770
771
772
773
774
775
776
777
778
		if (spec->channels[i].channel <= 14) {
			if (spec->tx_power_bg)
				tx_power = spec->tx_power_bg[i];
			else
				tx_power = spec->tx_power_default;
		} else {
			if (spec->tx_power_a)
				tx_power = spec->tx_power_a[i];
			else
				tx_power = spec->tx_power_default;
		}
779
780
781
782
783
784

		rt2x00lib_channel(&channels[i],
				  spec->channels[i].channel, tx_power, i);
	}

	/*
785
	 * Intitialize 802.11b, 802.11g
786
	 * Rates: CCK, OFDM.
787
	 * Channels: 2.4 GHz
788
	 */
789
	if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
790
791
792
793
794
795
		rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_channels = 14;
		rt2x00dev->bands[IEEE80211_BAND_2GHZ].n_bitrates = num_rates;
		rt2x00dev->bands[IEEE80211_BAND_2GHZ].channels = channels;
		rt2x00dev->bands[IEEE80211_BAND_2GHZ].bitrates = rates;
		hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
		    &rt2x00dev->bands[IEEE80211_BAND_2GHZ];
796
797
798
799
800
801
802
	}

	/*
	 * Intitialize 802.11a
	 * Rates: OFDM.
	 * Channels: OFDM, UNII, HiperLAN2.
	 */
803
	if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
804
805
806
807
808
809
810
811
		rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_channels =
		    spec->num_channels - 14;
		rt2x00dev->bands[IEEE80211_BAND_5GHZ].n_bitrates =
		    num_rates - 4;
		rt2x00dev->bands[IEEE80211_BAND_5GHZ].channels = &channels[14];
		rt2x00dev->bands[IEEE80211_BAND_5GHZ].bitrates = &rates[4];
		hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
		    &rt2x00dev->bands[IEEE80211_BAND_5GHZ];
812
813
814
815
	}

	return 0;

816
 exit_free_channels:
817
818
819
820
821
822
823
	kfree(channels);
	ERROR(rt2x00dev, "Allocation ieee80211 modes failed.\n");
	return -ENOMEM;
}

static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
{
824
	if (test_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags))
825
826
		ieee80211_unregister_hw(rt2x00dev->hw);

827
828
829
830
831
	if (likely(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ])) {
		kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->channels);
		kfree(rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ]->bitrates);
		rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
		rt2x00dev->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
	}
}

static int rt2x00lib_probe_hw(struct rt2x00_dev *rt2x00dev)
{
	struct hw_mode_spec *spec = &rt2x00dev->spec;
	int status;

	/*
	 * Initialize HW modes.
	 */
	status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
	if (status)
		return status;

847
848
849
850
851
	/*
	 * Initialize HW fields.
	 */
	rt2x00dev->hw->queues = rt2x00dev->ops->tx_queues;

852
853
854
855
856
857
858
859
860
	/*
	 * Register HW.
	 */
	status = ieee80211_register_hw(rt2x00dev->hw);
	if (status) {
		rt2x00lib_remove_hw(rt2x00dev);
		return status;
	}

861
	__set_bit(DEVICE_REGISTERED_HW, &rt2x00dev->flags);
862
863
864
865
866
867
868

	return 0;
}

/*
 * Initialization/uninitialization handlers.
 */
869
static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
870
871
872
873
874
{
	if (!__test_and_clear_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
		return;

	/*
875
	 * Unregister extra components.
876
877
878
879
880
881
882
883
884
	 */
	rt2x00rfkill_unregister(rt2x00dev);

	/*
	 * Allow the HW to uninitialize.
	 */
	rt2x00dev->ops->lib->uninitialize(rt2x00dev);

	/*
885
	 * Free allocated queue entries.
886
	 */
887
	rt2x00queue_uninitialize(rt2x00dev);
888
889
}

890
static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
891
892
893
894
895
896
897
{
	int status;

	if (test_bit(DEVICE_INITIALIZED, &rt2x00dev->flags))
		return 0;

	/*
898
	 * Allocate all queue entries.
899
	 */
900
901
	status = rt2x00queue_initialize(rt2x00dev);
	if (status)
902
903
904
905
906
907
		return status;

	/*
	 * Initialize the device.
	 */
	status = rt2x00dev->ops->lib->initialize(rt2x00dev);
908
909
910
911
	if (status) {
		rt2x00queue_uninitialize(rt2x00dev);
		return status;
	}
912
913
914
915

	__set_bit(DEVICE_INITIALIZED, &rt2x00dev->flags);

	/*
916
	 * Register the extra components.
917
	 */
918
	rt2x00rfkill_register(rt2x00dev);
919
920
921
922

	return 0;
}

923
924
925
926
927
928
929
930
931
932
933
int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
{
	int retval;

	if (test_bit(DEVICE_STARTED, &rt2x00dev->flags))
		return 0;

	/*
	 * If this is the first interface which is added,
	 * we should load the firmware now.
	 */
934
935
936
	retval = rt2x00lib_load_firmware(rt2x00dev);
	if (retval)
		return retval;
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953

	/*
	 * Initialize the device.
	 */
	retval = rt2x00lib_initialize(rt2x00dev);
	if (retval)
		return retval;

	/*
	 * Enable radio.
	 */
	retval = rt2x00lib_enable_radio(rt2x00dev);
	if (retval) {
		rt2x00lib_uninitialize(rt2x00dev);
		return retval;
	}

954
955
956
957
	rt2x00dev->intf_ap_count = 0;
	rt2x00dev->intf_sta_count = 0;
	rt2x00dev->intf_associated = 0;

958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
	__set_bit(DEVICE_STARTED, &rt2x00dev->flags);

	return 0;
}

void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
{
	if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
		return;

	/*
	 * Perhaps we can add something smarter here,
	 * but for now just disabling the radio should do.
	 */
	rt2x00lib_disable_radio(rt2x00dev);

974
975
976
977
	rt2x00dev->intf_ap_count = 0;
	rt2x00dev->intf_sta_count = 0;
	rt2x00dev->intf_associated = 0;

978
979
980
	__clear_bit(DEVICE_STARTED, &rt2x00dev->flags);
}

981
982
983
984
985
986
987
/*
 * driver allocation handlers.
 */
int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
{
	int retval = -ENOMEM;

988
989
990
991
992
993
	/*
	 * Make room for rt2x00_intf inside the per-interface
	 * structure ieee80211_vif.
	 */
	rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf);

994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
	/*
	 * Let the driver probe the device to detect the capabilities.
	 */
	retval = rt2x00dev->ops->lib->probe_hw(rt2x00dev);
	if (retval) {
		ERROR(rt2x00dev, "Failed to allocate device.\n");
		goto exit;
	}

	/*
	 * Initialize configuration work.
	 */
1006
	INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
1007
	INIT_WORK(&rt2x00dev->filter_work, rt2x00lib_packetfilter_scheduled);
1008
1009
1010
	INIT_DELAYED_WORK(&rt2x00dev->link.work, rt2x00lib_link_tuner);

	/*
1011
	 * Allocate queue array.
1012
	 */
1013
	retval = rt2x00queue_allocate(rt2x00dev);
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
	if (retval)
		goto exit;

	/*
	 * Initialize ieee80211 structure.
	 */
	retval = rt2x00lib_probe_hw(rt2x00dev);
	if (retval) {
		ERROR(rt2x00dev, "Failed to initialize hw.\n");
		goto exit;
	}

1026
	/*
1027
	 * Register extra components.
1028
1029
	 */
	rt2x00leds_register(rt2x00dev);
1030
	rt2x00rfkill_allocate(rt2x00dev);
1031
1032
	rt2x00debug_register(rt2x00dev);

1033
1034
	__set_bit(DEVICE_PRESENT, &rt2x00dev->flags);

1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
	return 0;

exit:
	rt2x00lib_remove_dev(rt2x00dev);

	return retval;
}
EXPORT_SYMBOL_GPL(rt2x00lib_probe_dev);

void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
{
1046
1047
	__clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);

1048
1049
1050
1051
1052
1053
1054
1055
1056
1057
1058
	/*
	 * Disable radio.
	 */
	rt2x00lib_disable_radio(rt2x00dev);

	/*
	 * Uninitialize device.
	 */
	rt2x00lib_uninitialize(rt2x00dev);

	/*
1059
	 * Free extra components
1060
1061
1062
	 */
	rt2x00debug_deregister(rt2x00dev);
	rt2x00rfkill_free(rt2x00dev);
1063
1064
	rt2x00leds_unregister(rt2x00dev);

1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
	/*
	 * Free ieee80211_hw memory.
	 */
	rt2x00lib_remove_hw(rt2x00dev);

	/*
	 * Free firmware image.
	 */
	rt2x00lib_free_firmware(rt2x00dev);

	/*
1076
	 * Free queue structures.
1077
	 */
1078
	rt2x00queue_free(rt2x00dev);
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
}
EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev);

/*
 * Device state handlers
 */
#ifdef CONFIG_PM
int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state)
{
	int retval;

	NOTICE(rt2x00dev, "Going to sleep.\n");
1091
1092
1093
1094
1095
1096
1097
	__clear_bit(DEVICE_PRESENT, &rt2x00dev->flags);

	/*
	 * Only continue if mac80211 has open interfaces.
	 */
	if (!test_bit(DEVICE_STARTED, &rt2x00dev->flags))
		goto exit;
1098
	__set_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags);
1099
1100

	/*
1101
	 * Disable radio.
1102
	 */
1103
	rt2x00lib_stop(rt2x00dev);
1104
	rt2x00lib_uninitialize(rt2x00dev);
1105
1106
1107
1108

	/*
	 * Suspend/disable extra components.
	 */
1109
	rt2x00leds_suspend(rt2x00dev);
1110
	rt2x00rfkill_suspend(rt2x00dev);
1111
1112
	rt2x00debug_deregister(rt2x00dev);

1113
exit:
1114
	/*
1115
1116
1117
1118
1119
1120
1121
1122
1123
	 * Set device mode to sleep for power management,
	 * on some hardware this call seems to consistently fail.
	 * From the specifications it is hard to tell why it fails,
	 * and if this is a "bad thing".
	 * Overall it is safe to just ignore the failure and
	 * continue suspending. The only downside is that the
	 * device will not be in optimal power save mode, but with
	 * the radio and the other components already disabled the
	 * device is as good as disabled.
1124
1125
1126
	 */
	retval = rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP);
	if (retval)
1127
1128
		WARNING(rt2x00dev, "Device failed to enter sleep state, "
			"continue suspending.\n");
1129
1130
1131
1132
1133

	return 0;
}
EXPORT_SYMBOL_GPL(rt2x00lib_suspend);

1134
1135
1136
1137
1138
1139
1140
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
static void rt2x00lib_resume_intf(void *data, u8 *mac,
				  struct ieee80211_vif *vif)
{
	struct rt2x00_dev *rt2x00dev = data;
	struct rt2x00_intf *intf = vif_to_intf(vif);

	spin_lock(&intf->lock);

	rt2x00lib_config_intf(rt2x00dev, intf,
			      vif->type, intf->mac, intf->bssid);


	/*
	 * Master or Ad-hoc mode require a new beacon update.
	 */
	if (vif->type == IEEE80211_IF_TYPE_AP ||
	    vif->type == IEEE80211_IF_TYPE_IBSS)
		intf->delayed_flags |= DELAYED_UPDATE_BEACON;

	spin_unlock(&intf->lock);
}

1156
1157
1158
1159
1160
1161
1162
int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
{
	int retval;

	NOTICE(rt2x00dev, "Waking up.\n");

	/*
1163
	 * Restore/enable extra components.
1164
1165
	 */
	rt2x00debug_register(rt2x00dev);
1166
	rt2x00rfkill_resume(rt2x00dev);
1167
	rt2x00leds_resume(rt2x00dev);
1168

1169
	/*
1170
	 * Only continue if mac80211 had open interfaces.
1171
	 */
1172
	if (!__test_and_clear_bit(DEVICE_STARTED_SUSPEND, &rt2x00dev->flags))
1173
1174
		return 0;

1175
1176
1177
	/*
	 * Reinitialize device and all active interfaces.
	 */
1178
	retval = rt2x00lib_start(rt2x00dev);
1179
1180
1181
1182
1183
1184
	if (retval)
		goto exit;

	/*
	 * Reconfigure device.
	 */
1185
1186
1187
	rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf, 1);
	if (!rt2x00dev->hw->conf.radio_enabled)
		rt2x00lib_disable_radio(rt2x00dev);
1188

1189
1190
1191
1192
1193
1194
	/*
	 * Iterator over each active interface to
	 * reconfigure the hardware.
	 */
	ieee80211_iterate_active_interfaces(rt2x00dev->hw,
					    rt2x00lib_resume_intf, rt2x00dev);
1195

1196
1197
1198
1199
1200
	/*
	 * We are ready again to receive requests from mac80211.
	 */
	__set_bit(DEVICE_PRESENT, &rt2x00dev->flags);

1201
1202
1203
1204
1205
1206
	/*
	 * It is possible that during that mac80211 has attempted
	 * to send frames while we were suspending or resuming.
	 * In that case we have disabled the TX queue and should
	 * now enable it again
	 */
1207
	ieee80211_wake_queues(rt2x00dev->hw);
1208

1209
	/*
1210
1211
1212
	 * During interface iteration we might have changed the
	 * delayed_flags, time to handles the event by calling
	 * the work handler directly.
1213
	 */
1214
	rt2x00lib_intf_scheduled(&rt2x00dev->intf_work);
1215
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234

	return 0;

exit:
	rt2x00lib_disable_radio(rt2x00dev);
	rt2x00lib_uninitialize(rt2x00dev);
	rt2x00debug_deregister(rt2x00dev);

	return retval;
}
EXPORT_SYMBOL_GPL(rt2x00lib_resume);
#endif /* CONFIG_PM */

/*
 * rt2x00lib module information.
 */
MODULE_AUTHOR(DRV_PROJECT);
MODULE_VERSION(DRV_VERSION);
MODULE_DESCRIPTION("rt2x00 library");
MODULE_LICENSE("GPL");