rt2x00dev.c 29.2 KB
Newer Older
1
/*
2
3
	Copyright (C) 2010 Willow Garage <http://www.willowgarage.com>
	Copyright (C) 2004 - 2010 Ivo van Doorn <IvDoorn@gmail.com>
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
	<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>
29
#include <linux/slab.h>
30
#include <linux/log2.h>
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

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

/*
 * 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.
	 */
46
	if (test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
47
48
		return 0;

49
	/*
50
	 * Initialize all data queues.
51
	 */
52
	rt2x00queue_init_queues(rt2x00dev);
53

54
55
56
	/*
	 * Enable radio.
	 */
57
58
	status =
	    rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_ON);
59
60
61
	if (status)
		return status;

62
63
	rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_ON);

64
	rt2x00leds_led_radio(rt2x00dev, true);
65
	rt2x00led_led_activity(rt2x00dev, true);
66

67
	set_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags);
68
69

	/*
70
	 * Enable queues.
71
	 */
72
	rt2x00queue_start_queues(rt2x00dev);
73
	rt2x00link_start_tuner(rt2x00dev);
74
	rt2x00link_start_agc(rt2x00dev);
75

76
77
78
79
80
	/*
	 * Start watchdog monitoring.
	 */
	rt2x00link_start_watchdog(rt2x00dev);

81
82
83
84
85
	return 0;
}

void rt2x00lib_disable_radio(struct rt2x00_dev *rt2x00dev)
{
86
	if (!test_and_clear_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
87
88
		return;

89
90
91
92
93
	/*
	 * Stop watchdog monitoring.
	 */
	rt2x00link_stop_watchdog(rt2x00dev);

94
	/*
95
	 * Stop all queues
96
	 */
97
	rt2x00link_stop_agc(rt2x00dev);
98
	rt2x00link_stop_tuner(rt2x00dev);
99
	rt2x00queue_stop_queues(rt2x00dev);
100
	rt2x00queue_flush_queues(rt2x00dev, true);
101
102
103
104
105

	/*
	 * Disable radio.
	 */
	rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_OFF);
106
	rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_RADIO_IRQ_OFF);
107
	rt2x00led_led_activity(rt2x00dev, false);
108
	rt2x00leds_led_radio(rt2x00dev, false);
109
110
}

111
112
static void rt2x00lib_intf_scheduled_iter(void *data, u8 *mac,
					  struct ieee80211_vif *vif)
113
{
114
115
116
	struct rt2x00_dev *rt2x00dev = data;
	struct rt2x00_intf *intf = vif_to_intf(vif);

117
118
119
120
121
122
	/*
	 * It is possible the radio was disabled while the work had been
	 * scheduled. If that happens we should return here immediately,
	 * note that in the spinlock protected area above the delayed_flags
	 * have been cleared correctly.
	 */
123
	if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
124
125
		return;

126
	if (test_and_clear_bit(DELAYED_UPDATE_BEACON, &intf->delayed_flags))
127
		rt2x00queue_update_beacon(rt2x00dev, vif);
128
}
129

130
131
132
133
static void rt2x00lib_intf_scheduled(struct work_struct *work)
{
	struct rt2x00_dev *rt2x00dev =
	    container_of(work, struct rt2x00_dev, intf_work);
134
135

	/*
136
137
	 * Iterate over each interface and perform the
	 * requested configurations.
138
	 */
139
140
141
	ieee80211_iterate_active_interfaces(rt2x00dev->hw,
					    rt2x00lib_intf_scheduled_iter,
					    rt2x00dev);
142
143
}

144
145
146
/*
 * Interrupt context handlers.
 */
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
static void rt2x00lib_bc_buffer_iter(void *data, u8 *mac,
				     struct ieee80211_vif *vif)
{
	struct rt2x00_dev *rt2x00dev = data;
	struct sk_buff *skb;

	/*
	 * Only AP mode interfaces do broad- and multicast buffering
	 */
	if (vif->type != NL80211_IFTYPE_AP)
		return;

	/*
	 * Send out buffered broad- and multicast frames
	 */
	skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif);
	while (skb) {
		rt2x00mac_tx(rt2x00dev->hw, skb);
		skb = ieee80211_get_buffered_bc(rt2x00dev->hw, vif);
	}
}

169
170
static void rt2x00lib_beaconupdate_iter(void *data, u8 *mac,
					struct ieee80211_vif *vif)
171
{
172
	struct rt2x00_dev *rt2x00dev = data;
173

174
	if (vif->type != NL80211_IFTYPE_AP &&
Andrey Yurovsky's avatar
Andrey Yurovsky committed
175
	    vif->type != NL80211_IFTYPE_ADHOC &&
Ivo van Doorn's avatar
Ivo van Doorn committed
176
177
	    vif->type != NL80211_IFTYPE_MESH_POINT &&
	    vif->type != NL80211_IFTYPE_WDS)
178
179
		return;

180
181
182
183
184
185
186
	/*
	 * Update the beacon without locking. This is safe on PCI devices
	 * as they only update the beacon periodically here. This should
	 * never be called for USB devices.
	 */
	WARN_ON(rt2x00_is_usb(rt2x00dev));
	rt2x00queue_update_beacon_locked(rt2x00dev, vif);
187
188
189
190
}

void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
{
191
	if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
192
193
		return;

194
	/* send buffered bc/mc frames out for every bssid */
195
196
197
	ieee80211_iterate_active_interfaces_atomic(rt2x00dev->hw,
						   rt2x00lib_bc_buffer_iter,
						   rt2x00dev);
198
199
200
201
202
203
204
	/*
	 * Devices with pre tbtt interrupt don't need to update the beacon
	 * here as they will fetch the next beacon directly prior to
	 * transmission.
	 */
	if (test_bit(DRIVER_SUPPORT_PRE_TBTT_INTERRUPT, &rt2x00dev->flags))
		return;
205
206

	/* fetch next beacon */
207
208
209
	ieee80211_iterate_active_interfaces_atomic(rt2x00dev->hw,
						   rt2x00lib_beaconupdate_iter,
						   rt2x00dev);
210
211
212
}
EXPORT_SYMBOL_GPL(rt2x00lib_beacondone);

213
214
215
216
217
218
void rt2x00lib_pretbtt(struct rt2x00_dev *rt2x00dev)
{
	if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
		return;

	/* fetch next beacon */
219
220
221
	ieee80211_iterate_active_interfaces_atomic(rt2x00dev->hw,
						   rt2x00lib_beaconupdate_iter,
						   rt2x00dev);
222
223
224
}
EXPORT_SYMBOL_GPL(rt2x00lib_pretbtt);

225
226
227
228
229
230
231
void rt2x00lib_dmastart(struct queue_entry *entry)
{
	set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
	rt2x00queue_index_inc(entry->queue, Q_INDEX);
}
EXPORT_SYMBOL_GPL(rt2x00lib_dmastart);

232
233
void rt2x00lib_dmadone(struct queue_entry *entry)
{
234
	set_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags);
Ivo van Doorn's avatar
Ivo van Doorn committed
235
	clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
236
237
238
239
	rt2x00queue_index_inc(entry->queue, Q_INDEX_DMA_DONE);
}
EXPORT_SYMBOL_GPL(rt2x00lib_dmadone);

240
241
void rt2x00lib_txdone(struct queue_entry *entry,
		      struct txdone_entry_desc *txdesc)
242
{
243
	struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
244
	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb);
245
	struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
246
	unsigned int header_length, i;
247
	u8 rate_idx, rate_flags, retry_rates;
248
	u8 skbdesc_flags = skbdesc->flags;
249
	bool success;
Ivo van Doorn's avatar
Ivo van Doorn committed
250

251
252
253
	/*
	 * Unmap the skb.
	 */
254
	rt2x00queue_unmap_skb(entry);
255
256
257
258
259
260
261
262
263
264
265

	/*
	 * Remove the extra tx headroom from the skb.
	 */
	skb_pull(entry->skb, rt2x00dev->ops->extra_tx_headroom);

	/*
	 * Signal that the TX descriptor is no longer in the skb.
	 */
	skbdesc->flags &= ~SKBDESC_DESC_IN_SKB;

266
267
268
269
270
	/*
	 * Determine the length of 802.11 header.
	 */
	header_length = ieee80211_get_hdrlen_from_skb(entry->skb);

271
272
273
274
	/*
	 * Remove L2 padding which was added during
	 */
	if (test_bit(DRIVER_REQUIRE_L2PAD, &rt2x00dev->flags))
275
		rt2x00queue_remove_l2pad(entry->skb, header_length);
276

277
278
279
	/*
	 * If the IV/EIV data was stripped from the frame before it was
	 * passed to the hardware, we should now reinsert it again because
280
	 * mac80211 will expect the same data to be present it the
281
282
283
	 * frame as it was passed to us.
	 */
	if (test_bit(CONFIG_SUPPORT_HW_CRYPTO, &rt2x00dev->flags))
284
		rt2x00crypto_tx_insert_iv(entry->skb, header_length);
285

286
287
288
289
290
	/*
	 * 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);
291
292

	/*
293
	 * Determine if the frame has been successfully transmitted.
294
	 */
295
	success =
296
	    test_bit(TXDONE_SUCCESS, &txdesc->flags) ||
297
	    test_bit(TXDONE_UNKNOWN, &txdesc->flags);
298
299
300
301
302
303

	/*
	 * Update TX statistics.
	 */
	rt2x00dev->link.qual.tx_success += success;
	rt2x00dev->link.qual.tx_failed += !success;
304

305
306
	rate_idx = skbdesc->tx_rate_idx;
	rate_flags = skbdesc->tx_rate_flags;
307
308
	retry_rates = test_bit(TXDONE_FALLBACK, &txdesc->flags) ?
	    (txdesc->retry + 1) : 1;
309

310
311
312
	/*
	 * Initialize TX status
	 */
313
314
	memset(&tx_info->status, 0, sizeof(tx_info->status));
	tx_info->status.ack_signal = 0;
315
316
317
318

	/*
	 * Frame was send with retries, hardware tried
	 * different rates to send out the frame, at each
319
320
	 * retry it lowered the rate 1 step except when the
	 * lowest rate was used.
321
322
323
324
	 */
	for (i = 0; i < retry_rates && i < IEEE80211_TX_MAX_RATES; i++) {
		tx_info->status.rates[i].idx = rate_idx - i;
		tx_info->status.rates[i].flags = rate_flags;
325
326
327
328
329
330
331
332
333
334

		if (rate_idx - i == 0) {
			/*
			 * The lowest rate (index 0) was used until the
			 * number of max retries was reached.
			 */
			tx_info->status.rates[i].count = retry_rates - i;
			i++;
			break;
		}
335
336
		tx_info->status.rates[i].count = 1;
	}
337
	if (i < (IEEE80211_TX_MAX_RATES - 1))
338
		tx_info->status.rates[i].idx = -1; /* terminate */
339

340
	if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK)) {
341
		if (success)
342
			tx_info->flags |= IEEE80211_TX_STAT_ACK;
343
		else
344
			rt2x00dev->low_level_stats.dot11ACKFailureCount++;
345
346
	}

347
348
349
350
351
352
353
354
355
	/*
	 * Every single frame has it's own tx status, hence report
	 * every frame as ampdu of size 1.
	 *
	 * TODO: if we can find out how many frames were aggregated
	 * by the hw we could provide the real ampdu_len to mac80211
	 * which would allow the rc algorithm to better decide on
	 * which rates are suitable.
	 */
356
357
	if (test_bit(TXDONE_AMPDU, &txdesc->flags) ||
	    tx_info->flags & IEEE80211_TX_CTL_AMPDU) {
358
359
360
		tx_info->flags |= IEEE80211_TX_STAT_AMPDU;
		tx_info->status.ampdu_len = 1;
		tx_info->status.ampdu_ack_len = success ? 1 : 0;
361
362
363

		if (!success)
			tx_info->flags |= IEEE80211_TX_STAT_AMPDU_NO_BACK;
364
365
	}

366
	if (rate_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
367
		if (success)
368
			rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
369
		else
370
			rt2x00dev->low_level_stats.dot11RTSFailureCount++;
371
372
373
	}

	/*
374
375
376
377
	 * Only send the status report to mac80211 when it's a frame
	 * that originated in mac80211. If this was a extra frame coming
	 * through a mac80211 library call (RTS/CTS) then we should not
	 * send the status report back.
378
	 */
379
380
381
382
383
384
	if (!(skbdesc_flags & SKBDESC_NOT_MAC80211)) {
		if (test_bit(DRIVER_REQUIRE_TASKLET_CONTEXT, &rt2x00dev->flags))
			ieee80211_tx_status(rt2x00dev->hw, entry->skb);
		else
			ieee80211_tx_status_ni(rt2x00dev->hw, entry->skb);
	} else
385
		dev_kfree_skb_any(entry->skb);
Ivo van Doorn's avatar
Ivo van Doorn committed
386
387
388
389

	/*
	 * Make this entry available for reuse.
	 */
390
	entry->skb = NULL;
Ivo van Doorn's avatar
Ivo van Doorn committed
391
392
	entry->flags = 0;

393
	rt2x00dev->ops->lib->clear_entry(entry);
Ivo van Doorn's avatar
Ivo van Doorn committed
394
395
396
397
398
399
400
401
402

	rt2x00queue_index_inc(entry->queue, Q_INDEX_DONE);

	/*
	 * If the data queue was below the threshold before the txdone
	 * handler we must make sure the packet queue in the mac80211 stack
	 * is reenabled when the txdone handler has finished.
	 */
	if (!rt2x00queue_threshold(entry->queue))
403
		rt2x00queue_unpause_queue(entry->queue);
404
405
}
EXPORT_SYMBOL_GPL(rt2x00lib_txdone);
406
407
408
409
410
411
412
413
414
415
416
417

void rt2x00lib_txdone_noinfo(struct queue_entry *entry, u32 status)
{
	struct txdone_entry_desc txdesc;

	txdesc.flags = 0;
	__set_bit(status, &txdesc.flags);
	txdesc.retry = 0;

	rt2x00lib_txdone(entry, &txdesc);
}
EXPORT_SYMBOL_GPL(rt2x00lib_txdone_noinfo);
418

419
420
421
422
423
424
static int rt2x00lib_rxdone_read_signal(struct rt2x00_dev *rt2x00dev,
					struct rxdone_entry_desc *rxdesc)
{
	struct ieee80211_supported_band *sband;
	const struct rt2x00_rate *rate;
	unsigned int i;
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
	int signal = rxdesc->signal;
	int type = (rxdesc->dev_flags & RXDONE_SIGNAL_MASK);

	switch (rxdesc->rate_mode) {
	case RATE_MODE_CCK:
	case RATE_MODE_OFDM:
		/*
		 * For non-HT rates the MCS value needs to contain the
		 * actually used rate modulation (CCK or OFDM).
		 */
		if (rxdesc->dev_flags & RXDONE_SIGNAL_MCS)
			signal = RATE_MCS(rxdesc->rate_mode, signal);

		sband = &rt2x00dev->bands[rt2x00dev->curr_band];
		for (i = 0; i < sband->n_bitrates; i++) {
			rate = rt2x00_get_rate(sband->bitrates[i].hw_value);
			if (((type == RXDONE_SIGNAL_PLCP) &&
			     (rate->plcp == signal)) ||
			    ((type == RXDONE_SIGNAL_BITRATE) &&
			      (rate->bitrate == signal)) ||
			    ((type == RXDONE_SIGNAL_MCS) &&
			      (rate->mcs == signal))) {
				return i;
			}
449
		}
450
451
452
453
454
455
456
457
		break;
	case RATE_MODE_HT_MIX:
	case RATE_MODE_HT_GREENFIELD:
		if (signal >= 0 && signal <= 76)
			return signal;
		break;
	default:
		break;
458
459
460
	}

	WARNING(rt2x00dev, "Frame received with unrecognized signal, "
461
462
		"mode=0x%.4x, signal=0x%.4x, type=%d.\n",
		rxdesc->rate_mode, signal, type);
463
464
465
	return 0;
}

466
void rt2x00lib_rxdone(struct queue_entry *entry)
467
{
468
	struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
469
470
	struct rxdone_entry_desc rxdesc;
	struct sk_buff *skb;
471
	struct ieee80211_rx_status *rx_status;
472
	unsigned int header_length;
473
	int rate_idx;
474

475
476
477
478
	if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) ||
	    !test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
		goto submit_entry;

479
480
481
	if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags))
		goto submit_entry;

482
483
484
485
	/*
	 * Allocate a new sk_buffer. If no new buffer available, drop the
	 * received frame and reuse the existing buffer.
	 */
486
	skb = rt2x00queue_alloc_rxskb(entry);
487
	if (!skb)
488
		goto submit_entry;
489
490
491
492

	/*
	 * Unmap the skb.
	 */
493
	rt2x00queue_unmap_skb(entry);
494
495
496
497
498
499

	/*
	 * Extract the RXD details.
	 */
	memset(&rxdesc, 0, sizeof(rxdesc));
	rt2x00dev->ops->lib->fill_rxdone(entry, &rxdesc);
500

501
502
	/*
	 * The data behind the ieee80211 header must be
503
	 * aligned on a 4 byte boundary.
504
	 */
505
	header_length = ieee80211_get_hdrlen_from_skb(entry->skb);
506

507
508
509
	/*
	 * Hardware might have stripped the IV/EIV/ICV data,
	 * in that case it is possible that the data was
510
	 * provided separately (through hardware descriptor)
511
512
	 * in which case we should reinsert the data into the frame.
	 */
513
	if ((rxdesc.dev_flags & RXDONE_CRYPTO_IV) &&
514
	    (rxdesc.flags & RX_FLAG_IV_STRIPPED))
515
		rt2x00crypto_rx_insert_iv(entry->skb, header_length,
516
					  &rxdesc);
517
518
519
	else if (header_length &&
		 (rxdesc.size > header_length) &&
		 (rxdesc.dev_flags & RXDONE_L2PAD))
520
		rt2x00queue_remove_l2pad(entry->skb, header_length);
521

522
523
524
	/* Trim buffer to correct size */
	skb_trim(entry->skb, rxdesc.size);

525
	/*
526
	 * Translate the signal to the correct bitrate index.
527
	 */
528
529
530
	rate_idx = rt2x00lib_rxdone_read_signal(rt2x00dev, &rxdesc);
	if (rxdesc.rate_mode == RATE_MODE_HT_MIX ||
	    rxdesc.rate_mode == RATE_MODE_HT_GREENFIELD)
531
		rxdesc.flags |= RX_FLAG_HT;
532

533
	/*
534
	 * Update extra components
535
	 */
536
537
	rt2x00link_update_stats(rt2x00dev, entry->skb, &rxdesc);
	rt2x00debug_update_crypto(rt2x00dev, &rxdesc);
538
	rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_RXDONE, entry->skb);
539

540
541
542
543
544
	/*
	 * Initialize RX status information, and send frame
	 * to mac80211.
	 */
	rx_status = IEEE80211_SKB_RXCB(entry->skb);
545
	rx_status->mactime = rxdesc.timestamp;
546
547
	rx_status->band = rt2x00dev->curr_band;
	rx_status->freq = rt2x00dev->curr_freq;
548
	rx_status->rate_idx = rate_idx;
549
550
	rx_status->signal = rxdesc.rssi;
	rx_status->flag = rxdesc.flags;
551
	rx_status->antenna = rt2x00dev->link.ant.active.rx;
552

553
	ieee80211_rx_ni(rt2x00dev->hw, entry->skb);
554
555
556
557
558

	/*
	 * Replace the skb with the freshly allocated one.
	 */
	entry->skb = skb;
Ivo van Doorn's avatar
Ivo van Doorn committed
559

560
submit_entry:
561
	entry->flags = 0;
562
	rt2x00queue_index_inc(entry->queue, Q_INDEX_DONE);
563
	if (test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) &&
564
	    test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
565
		rt2x00dev->ops->lib->clear_entry(entry);
566
567
568
569
570
571
}
EXPORT_SYMBOL_GPL(rt2x00lib_rxdone);

/*
 * Driver initialization handlers.
 */
572
573
const struct rt2x00_rate rt2x00_supported_rates[12] = {
	{
Ivo van Doorn's avatar
Ivo van Doorn committed
574
		.flags = DEV_RATE_CCK,
575
		.bitrate = 10,
576
		.ratemask = BIT(0),
577
		.plcp = 0x00,
578
		.mcs = RATE_MCS(RATE_MODE_CCK, 0),
579
580
	},
	{
Ivo van Doorn's avatar
Ivo van Doorn committed
581
		.flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
582
		.bitrate = 20,
583
		.ratemask = BIT(1),
584
		.plcp = 0x01,
585
		.mcs = RATE_MCS(RATE_MODE_CCK, 1),
586
587
	},
	{
Ivo van Doorn's avatar
Ivo van Doorn committed
588
		.flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
589
		.bitrate = 55,
590
		.ratemask = BIT(2),
591
		.plcp = 0x02,
592
		.mcs = RATE_MCS(RATE_MODE_CCK, 2),
593
594
	},
	{
Ivo van Doorn's avatar
Ivo van Doorn committed
595
		.flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
596
		.bitrate = 110,
597
		.ratemask = BIT(3),
598
		.plcp = 0x03,
599
		.mcs = RATE_MCS(RATE_MODE_CCK, 3),
600
601
	},
	{
Ivo van Doorn's avatar
Ivo van Doorn committed
602
		.flags = DEV_RATE_OFDM,
603
		.bitrate = 60,
604
		.ratemask = BIT(4),
605
		.plcp = 0x0b,
606
		.mcs = RATE_MCS(RATE_MODE_OFDM, 0),
607
608
609
610
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 90,
611
		.ratemask = BIT(5),
612
		.plcp = 0x0f,
613
		.mcs = RATE_MCS(RATE_MODE_OFDM, 1),
614
615
	},
	{
Ivo van Doorn's avatar
Ivo van Doorn committed
616
		.flags = DEV_RATE_OFDM,
617
		.bitrate = 120,
618
		.ratemask = BIT(6),
619
		.plcp = 0x0a,
620
		.mcs = RATE_MCS(RATE_MODE_OFDM, 2),
621
622
623
624
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 180,
625
		.ratemask = BIT(7),
626
		.plcp = 0x0e,
627
		.mcs = RATE_MCS(RATE_MODE_OFDM, 3),
628
629
	},
	{
Ivo van Doorn's avatar
Ivo van Doorn committed
630
		.flags = DEV_RATE_OFDM,
631
		.bitrate = 240,
632
		.ratemask = BIT(8),
633
		.plcp = 0x09,
634
		.mcs = RATE_MCS(RATE_MODE_OFDM, 4),
635
636
637
638
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 360,
639
		.ratemask = BIT(9),
640
		.plcp = 0x0d,
641
		.mcs = RATE_MCS(RATE_MODE_OFDM, 5),
642
643
644
645
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 480,
646
		.ratemask = BIT(10),
647
		.plcp = 0x08,
648
		.mcs = RATE_MCS(RATE_MODE_OFDM, 6),
649
650
651
652
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 540,
653
		.ratemask = BIT(11),
654
		.plcp = 0x0c,
655
		.mcs = RATE_MCS(RATE_MODE_OFDM, 7),
656
657
658
	},
};

659
660
661
662
static void rt2x00lib_channel(struct ieee80211_channel *entry,
			      const int channel, const int tx_power,
			      const int value)
{
663
664
665
666
	/* XXX: this assumption about the band is wrong for 802.11j */
	entry->band = channel <= 14 ? IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
	entry->center_freq = ieee80211_channel_to_frequency(channel,
							    entry->band);
667
668
669
	entry->hw_value = value;
	entry->max_power = tx_power;
	entry->max_antenna_gain = 0xff;
670
671
672
}

static void rt2x00lib_rate(struct ieee80211_rate *entry,
673
			   const u16 index, const struct rt2x00_rate *rate)
674
{
675
676
	entry->flags = 0;
	entry->bitrate = rate->bitrate;
677
	entry->hw_value = index;
678
	entry->hw_value_short = index;
679

680
	if (rate->flags & DEV_RATE_SHORT_PREAMBLE)
681
		entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
682
683
684
685
686
687
688
689
}

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;
690
	unsigned int num_rates;
691
692
	unsigned int i;

693
694
695
696
697
	num_rates = 0;
	if (spec->supported_rates & SUPPORT_RATE_CCK)
		num_rates += 4;
	if (spec->supported_rates & SUPPORT_RATE_OFDM)
		num_rates += 8;
698
699
700

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

703
	rates = kzalloc(sizeof(*rates) * num_rates, GFP_KERNEL);
704
705
706
707
708
709
	if (!rates)
		goto exit_free_channels;

	/*
	 * Initialize Rate list.
	 */
710
	for (i = 0; i < num_rates; i++)
711
		rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i));
712
713
714
715
716
717

	/*
	 * Initialize Channel list.
	 */
	for (i = 0; i < spec->num_channels; i++) {
		rt2x00lib_channel(&channels[i],
718
				  spec->channels[i].channel,
719
				  spec->channels_info[i].max_power, i);
720
721
722
	}

	/*
723
	 * Intitialize 802.11b, 802.11g
724
	 * Rates: CCK, OFDM.
725
	 * Channels: 2.4 GHz
726
	 */
727
	if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
728
729
730
731
732
733
		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];
734
735
		memcpy(&rt2x00dev->bands[IEEE80211_BAND_2GHZ].ht_cap,
		       &spec->ht, sizeof(spec->ht));
736
737
738
739
740
741
742
	}

	/*
	 * Intitialize 802.11a
	 * Rates: OFDM.
	 * Channels: OFDM, UNII, HiperLAN2.
	 */
743
	if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
744
745
746
747
748
749
750
751
		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];
752
753
		memcpy(&rt2x00dev->bands[IEEE80211_BAND_5GHZ].ht_cap,
		       &spec->ht, sizeof(spec->ht));
754
755
756
757
	}

	return 0;

758
 exit_free_channels:
759
760
761
762
763
764
765
	kfree(channels);
	ERROR(rt2x00dev, "Allocation ieee80211 modes failed.\n");
	return -ENOMEM;
}

static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
{
766
	if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
767
768
		ieee80211_unregister_hw(rt2x00dev->hw);

769
770
771
772
773
	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;
774
	}
775
776

	kfree(rt2x00dev->spec.channels_info);
777
778
779
780
781
782
783
}

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

784
785
786
	if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
		return 0;

787
788
789
790
791
792
793
	/*
	 * Initialize HW modes.
	 */
	status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
	if (status)
		return status;

794
795
796
797
798
	/*
	 * Initialize HW fields.
	 */
	rt2x00dev->hw->queues = rt2x00dev->ops->tx_queues;

799
800
801
	/*
	 * Initialize extra TX headroom required.
	 */
802
803
804
805
806
807
808
809
810
811
812
	rt2x00dev->hw->extra_tx_headroom =
		max_t(unsigned int, IEEE80211_TX_STATUS_HEADROOM,
		      rt2x00dev->ops->extra_tx_headroom);

	/*
	 * Take TX headroom required for alignment into account.
	 */
	if (test_bit(DRIVER_REQUIRE_L2PAD, &rt2x00dev->flags))
		rt2x00dev->hw->extra_tx_headroom += RT2X00_L2PAD_SIZE;
	else if (test_bit(DRIVER_REQUIRE_DMA, &rt2x00dev->flags))
		rt2x00dev->hw->extra_tx_headroom += RT2X00_ALIGN_SIZE;
813

814
815
816
	/*
	 * Allocate tx status FIFO for driver use.
	 */
817
	if (test_bit(DRIVER_REQUIRE_TXSTATUS_FIFO, &rt2x00dev->flags)) {
818
		/*
819
820
821
822
823
		 * Allocate the txstatus fifo. In the worst case the tx
		 * status fifo has to hold the tx status of all entries
		 * in all tx queues. Hence, calculate the kfifo size as
		 * tx_queues * entry_num and round up to the nearest
		 * power of 2.
824
		 */
825
826
827
828
829
830
		int kfifo_size =
			roundup_pow_of_two(rt2x00dev->ops->tx_queues *
					   rt2x00dev->ops->tx->entry_num *
					   sizeof(u32));

		status = kfifo_alloc(&rt2x00dev->txstatus_fifo, kfifo_size,
831
832
833
834
835
				     GFP_KERNEL);
		if (status)
			return status;
	}

836
837
838
839
840
841
842
843
844
845
846
847
848
	/*
	 * Initialize tasklets if used by the driver. Tasklets are
	 * disabled until the interrupts are turned on. The driver
	 * has to handle that.
	 */
#define RT2X00_TASKLET_INIT(taskletname) \
	if (rt2x00dev->ops->lib->taskletname) { \
		tasklet_init(&rt2x00dev->taskletname, \
			     rt2x00dev->ops->lib->taskletname, \
			     (unsigned long)rt2x00dev); \
		tasklet_disable(&rt2x00dev->taskletname); \
	}

849
	RT2X00_TASKLET_INIT(txstatus_tasklet);
850
851
852
853
854
855
856
	RT2X00_TASKLET_INIT(pretbtt_tasklet);
	RT2X00_TASKLET_INIT(tbtt_tasklet);
	RT2X00_TASKLET_INIT(rxdone_tasklet);
	RT2X00_TASKLET_INIT(autowake_tasklet);

#undef RT2X00_TASKLET_INIT

857
858
859
860
	/*
	 * Register HW.
	 */
	status = ieee80211_register_hw(rt2x00dev->hw);
861
	if (status)
862
863
		return status;

864
	set_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags);
865
866
867
868
869
870
871

	return 0;
}

/*
 * Initialization/uninitialization handlers.
 */
872
static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
873
{
874
	if (!test_and_clear_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags))
875
876
877
		return;

	/*
878
	 * Unregister extra components.
879
880
881
882
883
884
885
886
887
	 */
	rt2x00rfkill_unregister(rt2x00dev);

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

	/*
888
	 * Free allocated queue entries.
889
	 */
890
	rt2x00queue_uninitialize(rt2x00dev);
891
892
}

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

897
	if (test_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags))
898
899
900
		return 0;

	/*
901
	 * Allocate all queue entries.
902
	 */
903
904
	status = rt2x00queue_initialize(rt2x00dev);
	if (status)
905
906
907
908
909
910
		return status;

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

916
	set_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags);
917
918

	/*
919
	 * Register the extra components.
920
	 */
921
	rt2x00rfkill_register(rt2x00dev);
922
923
924
925

	return 0;
}

926
927
928
929
int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
{
	int retval;

930
	if (test_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
931
932
933
934
935
936
		return 0;

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

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

948
949
950
951
	rt2x00dev->intf_ap_count = 0;
	rt2x00dev->intf_sta_count = 0;
	rt2x00dev->intf_associated = 0;

952
953
	/* Enable the radio */
	retval = rt2x00lib_enable_radio(rt2x00dev);
954
	if (retval)
955
956
		return retval;

957
	set_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags);
958
959
960
961
962
963

	return 0;
}

void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
{
964
	if (!test_and_clear_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
965
966
967
968
969
970
971
972
		return;

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

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

978
979
980
981
982
983
984
/*
 * driver allocation handlers.
 */
int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
{
	int retval = -ENOMEM;

985
	spin_lock_init(&rt2x00dev->irqmask_lock);
986
987
	mutex_init(&rt2x00dev->csr_mutex);

988
989
	set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);

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

996
997
998
999
1000
1001
1002
1003
1004
	/*
	 * Determine which operating modes are supported, all modes
	 * which require beaconing, depend on the availability of
	 * beacon entries.
	 */
	rt2x00dev->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
	if (rt2x00dev->ops->bcn->entry_num > 0)
		rt2x00dev->hw->wiphy->interface_modes |=
		    BIT(NL80211_IFTYPE_ADHOC) |
Andrey Yurovsky's avatar
Andrey Yurovsky committed
1005
		    BIT(NL80211_IFTYPE_AP) |
Ivo van Doorn's avatar
Ivo van Doorn committed
1006
1007
		    BIT(NL80211_IFTYPE_MESH_POINT) |
		    BIT(NL80211_IFTYPE_WDS);
1008

1009
	/*
1010
	 * Initialize work.
1011
	 */
1012
1013
1014
1015
1016
1017
1018
	rt2x00dev->workqueue =
	    alloc_ordered_workqueue(wiphy_name(rt2x00dev->hw->wiphy), 0);
	if (!rt2x00dev->workqueue) {
		retval = -ENOMEM;
		goto exit;
	}

1019
1020
	INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);

1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
	/*
	 * 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;
	}

	/*
1031
	 * Allocate queue array.
1032
	 */
1033
	retval = rt2x00queue_allocate(rt2x00dev);
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
	if (retval)
		goto exit;

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

1046
	/*
1047
	 * Register extra components.
1048
	 */
1049
	rt2x00link_register(rt2x00dev);
1050
	rt2x00leds_register(rt2x00dev);
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063
	rt2x00debug_register(rt2x00dev);

	return 0;

exit:
	rt2x00lib_remove_dev(rt2x00dev);

	return retval;
}
EXPORT_SYMBOL_GPL(rt2x00lib_probe_dev);

void rt2x00lib_remove_dev(struct rt2x00_dev *rt2x00dev)
{
1064
	clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
1065

1066
1067
1068
1069
1070
	/*
	 * Disable radio.
	 */
	rt2x00lib_disable_radio(rt2x00dev);