rt2x00dev.c 31.9 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 147 148
static void rt2x00lib_autowakeup(struct work_struct *work)
{
	struct rt2x00_dev *rt2x00dev =
	    container_of(work, struct rt2x00_dev, autowakeup_work.work);

Stanislaw Gruszka's avatar
Stanislaw Gruszka committed
149 150 151
	if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
		return;

152 153 154 155 156
	if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_AWAKE))
		ERROR(rt2x00dev, "Device failed to wakeup.\n");
	clear_bit(CONFIG_POWERSAVING, &rt2x00dev->flags);
}

157 158 159
/*
 * Interrupt context handlers.
 */
160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
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);
	}
}

182 183
static void rt2x00lib_beaconupdate_iter(void *data, u8 *mac,
					struct ieee80211_vif *vif)
184
{
185
	struct rt2x00_dev *rt2x00dev = data;
186

187
	if (vif->type != NL80211_IFTYPE_AP &&
Andrey Yurovsky's avatar
Andrey Yurovsky committed
188
	    vif->type != NL80211_IFTYPE_ADHOC &&
189 190
	    vif->type != NL80211_IFTYPE_MESH_POINT &&
	    vif->type != NL80211_IFTYPE_WDS)
191 192
		return;

193 194 195 196 197 198 199
	/*
	 * 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);
200 201 202 203
}

void rt2x00lib_beacondone(struct rt2x00_dev *rt2x00dev)
{
204
	if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
205 206
		return;

207
	/* send buffered bc/mc frames out for every bssid */
208 209 210
	ieee80211_iterate_active_interfaces_atomic(rt2x00dev->hw,
						   rt2x00lib_bc_buffer_iter,
						   rt2x00dev);
211 212 213 214 215
	/*
	 * Devices with pre tbtt interrupt don't need to update the beacon
	 * here as they will fetch the next beacon directly prior to
	 * transmission.
	 */
216
	if (test_bit(CAPABILITY_PRE_TBTT_INTERRUPT, &rt2x00dev->cap_flags))
217
		return;
218 219

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

226 227 228 229 230 231
void rt2x00lib_pretbtt(struct rt2x00_dev *rt2x00dev)
{
	if (!test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
		return;

	/* fetch next beacon */
232 233 234
	ieee80211_iterate_active_interfaces_atomic(rt2x00dev->hw,
						   rt2x00lib_beaconupdate_iter,
						   rt2x00dev);
235 236 237
}
EXPORT_SYMBOL_GPL(rt2x00lib_pretbtt);

238 239 240
void rt2x00lib_dmastart(struct queue_entry *entry)
{
	set_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
241
	rt2x00queue_index_inc(entry, Q_INDEX);
242 243 244
}
EXPORT_SYMBOL_GPL(rt2x00lib_dmastart);

245 246
void rt2x00lib_dmadone(struct queue_entry *entry)
{
247
	set_bit(ENTRY_DATA_STATUS_PENDING, &entry->flags);
248
	clear_bit(ENTRY_OWNER_DEVICE_DATA, &entry->flags);
249
	rt2x00queue_index_inc(entry, Q_INDEX_DMA_DONE);
250 251 252
}
EXPORT_SYMBOL_GPL(rt2x00lib_dmadone);

253 254
void rt2x00lib_txdone(struct queue_entry *entry,
		      struct txdone_entry_desc *txdesc)
255
{
256
	struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
257
	struct ieee80211_tx_info *tx_info = IEEE80211_SKB_CB(entry->skb);
258
	struct skb_frame_desc *skbdesc = get_skb_frame_desc(entry->skb);
259
	unsigned int header_length, i;
260
	u8 rate_idx, rate_flags, retry_rates;
261
	u8 skbdesc_flags = skbdesc->flags;
262
	bool success;
263

264 265 266
	/*
	 * Unmap the skb.
	 */
267
	rt2x00queue_unmap_skb(entry);
268 269 270 271 272 273 274 275 276 277 278

	/*
	 * 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;

279 280 281 282 283
	/*
	 * Determine the length of 802.11 header.
	 */
	header_length = ieee80211_get_hdrlen_from_skb(entry->skb);

284 285 286
	/*
	 * Remove L2 padding which was added during
	 */
287
	if (test_bit(REQUIRE_L2PAD, &rt2x00dev->cap_flags))
288
		rt2x00queue_remove_l2pad(entry->skb, header_length);
289

290 291 292
	/*
	 * If the IV/EIV data was stripped from the frame before it was
	 * passed to the hardware, we should now reinsert it again because
293
	 * mac80211 will expect the same data to be present it the
294 295
	 * frame as it was passed to us.
	 */
296
	if (test_bit(CAPABILITY_HW_CRYPTO, &rt2x00dev->cap_flags))
297
		rt2x00crypto_tx_insert_iv(entry->skb, header_length);
298

299 300 301 302 303
	/*
	 * 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);
304 305

	/*
306
	 * Determine if the frame has been successfully transmitted.
307
	 */
308
	success =
309
	    test_bit(TXDONE_SUCCESS, &txdesc->flags) ||
310
	    test_bit(TXDONE_UNKNOWN, &txdesc->flags);
311 312 313 314 315 316

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

318 319
	rate_idx = skbdesc->tx_rate_idx;
	rate_flags = skbdesc->tx_rate_flags;
320 321
	retry_rates = test_bit(TXDONE_FALLBACK, &txdesc->flags) ?
	    (txdesc->retry + 1) : 1;
322

323 324 325
	/*
	 * Initialize TX status
	 */
326 327
	memset(&tx_info->status, 0, sizeof(tx_info->status));
	tx_info->status.ack_signal = 0;
328 329 330 331

	/*
	 * Frame was send with retries, hardware tried
	 * different rates to send out the frame, at each
332 333
	 * retry it lowered the rate 1 step except when the
	 * lowest rate was used.
334 335 336 337
	 */
	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;
338 339 340 341 342 343 344 345 346 347

		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;
		}
348 349
		tx_info->status.rates[i].count = 1;
	}
350
	if (i < (IEEE80211_TX_MAX_RATES - 1))
351
		tx_info->status.rates[i].idx = -1; /* terminate */
352

353
	if (!(tx_info->flags & IEEE80211_TX_CTL_NO_ACK)) {
354
		if (success)
355
			tx_info->flags |= IEEE80211_TX_STAT_ACK;
356
		else
357
			rt2x00dev->low_level_stats.dot11ACKFailureCount++;
358 359
	}

360 361 362 363 364 365 366 367 368
	/*
	 * 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.
	 */
369 370
	if (test_bit(TXDONE_AMPDU, &txdesc->flags) ||
	    tx_info->flags & IEEE80211_TX_CTL_AMPDU) {
371 372 373
		tx_info->flags |= IEEE80211_TX_STAT_AMPDU;
		tx_info->status.ampdu_len = 1;
		tx_info->status.ampdu_ack_len = success ? 1 : 0;
374 375 376

		if (!success)
			tx_info->flags |= IEEE80211_TX_STAT_AMPDU_NO_BACK;
377 378
	}

379
	if (rate_flags & IEEE80211_TX_RC_USE_RTS_CTS) {
380
		if (success)
381
			rt2x00dev->low_level_stats.dot11RTSSuccessCount++;
382
		else
383
			rt2x00dev->low_level_stats.dot11RTSFailureCount++;
384 385 386
	}

	/*
387 388 389 390
	 * 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.
391
	 */
392
	if (!(skbdesc_flags & SKBDESC_NOT_MAC80211)) {
393
		if (test_bit(REQUIRE_TASKLET_CONTEXT, &rt2x00dev->cap_flags))
394 395 396 397
			ieee80211_tx_status(rt2x00dev->hw, entry->skb);
		else
			ieee80211_tx_status_ni(rt2x00dev->hw, entry->skb);
	} else
398
		dev_kfree_skb_any(entry->skb);
399 400 401 402

	/*
	 * Make this entry available for reuse.
	 */
403
	entry->skb = NULL;
404 405
	entry->flags = 0;

406
	rt2x00dev->ops->lib->clear_entry(entry);
407

408
	rt2x00queue_index_inc(entry, Q_INDEX_DONE);
409 410 411 412 413 414 415

	/*
	 * 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))
416
		rt2x00queue_unpause_queue(entry->queue);
417 418
}
EXPORT_SYMBOL_GPL(rt2x00lib_txdone);
419 420 421 422 423 424 425 426 427 428 429 430

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);
431

432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502
static u8 *rt2x00lib_find_ie(u8 *data, unsigned int len, u8 ie)
{
	struct ieee80211_mgmt *mgmt = (void *)data;
	u8 *pos, *end;

	pos = (u8 *)mgmt->u.beacon.variable;
	end = data + len;
	while (pos < end) {
		if (pos + 2 + pos[1] > end)
			return NULL;

		if (pos[0] == ie)
			return pos;

		pos += 2 + pos[1];
	}

	return NULL;
}

static void rt2x00lib_rxdone_check_ps(struct rt2x00_dev *rt2x00dev,
				      struct sk_buff *skb,
				      struct rxdone_entry_desc *rxdesc)
{
	struct ieee80211_hdr *hdr = (void *) skb->data;
	struct ieee80211_tim_ie *tim_ie;
	u8 *tim;
	u8 tim_len;
	bool cam;

	/* If this is not a beacon, or if mac80211 has no powersaving
	 * configured, or if the device is already in powersaving mode
	 * we can exit now. */
	if (likely(!ieee80211_is_beacon(hdr->frame_control) ||
		   !(rt2x00dev->hw->conf.flags & IEEE80211_CONF_PS)))
		return;

	/* min. beacon length + FCS_LEN */
	if (skb->len <= 40 + FCS_LEN)
		return;

	/* and only beacons from the associated BSSID, please */
	if (!(rxdesc->dev_flags & RXDONE_MY_BSS) ||
	    !rt2x00dev->aid)
		return;

	rt2x00dev->last_beacon = jiffies;

	tim = rt2x00lib_find_ie(skb->data, skb->len - FCS_LEN, WLAN_EID_TIM);
	if (!tim)
		return;

	if (tim[1] < sizeof(*tim_ie))
		return;

	tim_len = tim[1];
	tim_ie = (struct ieee80211_tim_ie *) &tim[2];

	/* Check whenever the PHY can be turned off again. */

	/* 1. What about buffered unicast traffic for our AID? */
	cam = ieee80211_check_tim(tim_ie, tim_len, rt2x00dev->aid);

	/* 2. Maybe the AP wants to send multicast/broadcast data? */
	cam |= (tim_ie->bitmap_ctrl & 0x01);

	if (!cam && !test_bit(CONFIG_POWERSAVING, &rt2x00dev->flags))
		rt2x00lib_config(rt2x00dev, &rt2x00dev->hw->conf,
				 IEEE80211_CONF_CHANGE_PS);
}

503 504 505 506 507 508
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;
509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532
	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;
			}
533
		}
534 535 536 537 538 539 540 541
		break;
	case RATE_MODE_HT_MIX:
	case RATE_MODE_HT_GREENFIELD:
		if (signal >= 0 && signal <= 76)
			return signal;
		break;
	default:
		break;
542 543 544
	}

	WARNING(rt2x00dev, "Frame received with unrecognized signal, "
545 546
		"mode=0x%.4x, signal=0x%.4x, type=%d.\n",
		rxdesc->rate_mode, signal, type);
547 548 549
	return 0;
}

550
void rt2x00lib_rxdone(struct queue_entry *entry)
551
{
552
	struct rt2x00_dev *rt2x00dev = entry->queue->rt2x00dev;
553 554
	struct rxdone_entry_desc rxdesc;
	struct sk_buff *skb;
555
	struct ieee80211_rx_status *rx_status;
556
	unsigned int header_length;
557
	int rate_idx;
558

559 560 561 562
	if (!test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) ||
	    !test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
		goto submit_entry;

563 564 565
	if (test_bit(ENTRY_DATA_IO_FAILED, &entry->flags))
		goto submit_entry;

566 567 568 569
	/*
	 * Allocate a new sk_buffer. If no new buffer available, drop the
	 * received frame and reuse the existing buffer.
	 */
570
	skb = rt2x00queue_alloc_rxskb(entry);
571
	if (!skb)
572
		goto submit_entry;
573 574 575 576

	/*
	 * Unmap the skb.
	 */
577
	rt2x00queue_unmap_skb(entry);
578 579 580 581 582 583

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

585 586 587 588 589 590 591 592 593 594 595 596
	/*
	 * Check for valid size in case we get corrupted descriptor from
	 * hardware.
	 */
	if (unlikely(rxdesc.size == 0 ||
		     rxdesc.size > entry->queue->data_size)) {
		WARNING(rt2x00dev, "Wrong frame size %d max %d.\n",
			rxdesc.size, entry->queue->data_size);
		dev_kfree_skb(entry->skb);
		goto renew_skb;
	}

597 598
	/*
	 * The data behind the ieee80211 header must be
599
	 * aligned on a 4 byte boundary.
600
	 */
601
	header_length = ieee80211_get_hdrlen_from_skb(entry->skb);
602

603 604 605
	/*
	 * Hardware might have stripped the IV/EIV/ICV data,
	 * in that case it is possible that the data was
606
	 * provided separately (through hardware descriptor)
607 608
	 * in which case we should reinsert the data into the frame.
	 */
609
	if ((rxdesc.dev_flags & RXDONE_CRYPTO_IV) &&
610
	    (rxdesc.flags & RX_FLAG_IV_STRIPPED))
611
		rt2x00crypto_rx_insert_iv(entry->skb, header_length,
612
					  &rxdesc);
613 614 615
	else if (header_length &&
		 (rxdesc.size > header_length) &&
		 (rxdesc.dev_flags & RXDONE_L2PAD))
616
		rt2x00queue_remove_l2pad(entry->skb, header_length);
617

618 619 620
	/* Trim buffer to correct size */
	skb_trim(entry->skb, rxdesc.size);

621
	/*
622
	 * Translate the signal to the correct bitrate index.
623
	 */
624 625 626
	rate_idx = rt2x00lib_rxdone_read_signal(rt2x00dev, &rxdesc);
	if (rxdesc.rate_mode == RATE_MODE_HT_MIX ||
	    rxdesc.rate_mode == RATE_MODE_HT_GREENFIELD)
627
		rxdesc.flags |= RX_FLAG_HT;
628

629 630 631 632 633 634
	/*
	 * Check if this is a beacon, and more frames have been
	 * buffered while we were in powersaving mode.
	 */
	rt2x00lib_rxdone_check_ps(rt2x00dev, entry->skb, &rxdesc);

635
	/*
636
	 * Update extra components
637
	 */
638 639
	rt2x00link_update_stats(rt2x00dev, entry->skb, &rxdesc);
	rt2x00debug_update_crypto(rt2x00dev, &rxdesc);
640
	rt2x00debug_dump_frame(rt2x00dev, DUMP_FRAME_RXDONE, entry->skb);
641

642 643 644 645 646
	/*
	 * Initialize RX status information, and send frame
	 * to mac80211.
	 */
	rx_status = IEEE80211_SKB_RXCB(entry->skb);
647
	rx_status->mactime = rxdesc.timestamp;
648 649
	rx_status->band = rt2x00dev->curr_band;
	rx_status->freq = rt2x00dev->curr_freq;
650
	rx_status->rate_idx = rate_idx;
651 652
	rx_status->signal = rxdesc.rssi;
	rx_status->flag = rxdesc.flags;
653
	rx_status->antenna = rt2x00dev->link.ant.active.rx;
654

655
	ieee80211_rx_ni(rt2x00dev->hw, entry->skb);
656

657
renew_skb:
658 659 660 661
	/*
	 * Replace the skb with the freshly allocated one.
	 */
	entry->skb = skb;
662

663
submit_entry:
664
	entry->flags = 0;
665
	rt2x00queue_index_inc(entry, Q_INDEX_DONE);
666
	if (test_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags) &&
667
	    test_bit(DEVICE_STATE_ENABLED_RADIO, &rt2x00dev->flags))
668
		rt2x00dev->ops->lib->clear_entry(entry);
669 670 671 672 673 674
}
EXPORT_SYMBOL_GPL(rt2x00lib_rxdone);

/*
 * Driver initialization handlers.
 */
675 676
const struct rt2x00_rate rt2x00_supported_rates[12] = {
	{
677
		.flags = DEV_RATE_CCK,
678
		.bitrate = 10,
679
		.ratemask = BIT(0),
680
		.plcp = 0x00,
681
		.mcs = RATE_MCS(RATE_MODE_CCK, 0),
682 683
	},
	{
684
		.flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
685
		.bitrate = 20,
686
		.ratemask = BIT(1),
687
		.plcp = 0x01,
688
		.mcs = RATE_MCS(RATE_MODE_CCK, 1),
689 690
	},
	{
691
		.flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
692
		.bitrate = 55,
693
		.ratemask = BIT(2),
694
		.plcp = 0x02,
695
		.mcs = RATE_MCS(RATE_MODE_CCK, 2),
696 697
	},
	{
698
		.flags = DEV_RATE_CCK | DEV_RATE_SHORT_PREAMBLE,
699
		.bitrate = 110,
700
		.ratemask = BIT(3),
701
		.plcp = 0x03,
702
		.mcs = RATE_MCS(RATE_MODE_CCK, 3),
703 704
	},
	{
705
		.flags = DEV_RATE_OFDM,
706
		.bitrate = 60,
707
		.ratemask = BIT(4),
708
		.plcp = 0x0b,
709
		.mcs = RATE_MCS(RATE_MODE_OFDM, 0),
710 711 712 713
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 90,
714
		.ratemask = BIT(5),
715
		.plcp = 0x0f,
716
		.mcs = RATE_MCS(RATE_MODE_OFDM, 1),
717 718
	},
	{
719
		.flags = DEV_RATE_OFDM,
720
		.bitrate = 120,
721
		.ratemask = BIT(6),
722
		.plcp = 0x0a,
723
		.mcs = RATE_MCS(RATE_MODE_OFDM, 2),
724 725 726 727
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 180,
728
		.ratemask = BIT(7),
729
		.plcp = 0x0e,
730
		.mcs = RATE_MCS(RATE_MODE_OFDM, 3),
731 732
	},
	{
733
		.flags = DEV_RATE_OFDM,
734
		.bitrate = 240,
735
		.ratemask = BIT(8),
736
		.plcp = 0x09,
737
		.mcs = RATE_MCS(RATE_MODE_OFDM, 4),
738 739 740 741
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 360,
742
		.ratemask = BIT(9),
743
		.plcp = 0x0d,
744
		.mcs = RATE_MCS(RATE_MODE_OFDM, 5),
745 746 747 748
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 480,
749
		.ratemask = BIT(10),
750
		.plcp = 0x08,
751
		.mcs = RATE_MCS(RATE_MODE_OFDM, 6),
752 753 754 755
	},
	{
		.flags = DEV_RATE_OFDM,
		.bitrate = 540,
756
		.ratemask = BIT(11),
757
		.plcp = 0x0c,
758
		.mcs = RATE_MCS(RATE_MODE_OFDM, 7),
759 760 761
	},
};

762 763 764 765
static void rt2x00lib_channel(struct ieee80211_channel *entry,
			      const int channel, const int tx_power,
			      const int value)
{
766 767 768 769
	/* 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);
770 771 772
	entry->hw_value = value;
	entry->max_power = tx_power;
	entry->max_antenna_gain = 0xff;
773 774 775
}

static void rt2x00lib_rate(struct ieee80211_rate *entry,
776
			   const u16 index, const struct rt2x00_rate *rate)
777
{
778 779
	entry->flags = 0;
	entry->bitrate = rate->bitrate;
780
	entry->hw_value = index;
781
	entry->hw_value_short = index;
782

783
	if (rate->flags & DEV_RATE_SHORT_PREAMBLE)
784
		entry->flags |= IEEE80211_RATE_SHORT_PREAMBLE;
785 786 787 788 789 790 791 792
}

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;
793
	unsigned int num_rates;
794 795
	unsigned int i;

796 797 798 799 800
	num_rates = 0;
	if (spec->supported_rates & SUPPORT_RATE_CCK)
		num_rates += 4;
	if (spec->supported_rates & SUPPORT_RATE_OFDM)
		num_rates += 8;
801 802 803

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

806
	rates = kzalloc(sizeof(*rates) * num_rates, GFP_KERNEL);
807 808 809 810 811 812
	if (!rates)
		goto exit_free_channels;

	/*
	 * Initialize Rate list.
	 */
813
	for (i = 0; i < num_rates; i++)
814
		rt2x00lib_rate(&rates[i], i, rt2x00_get_rate(i));
815 816 817 818 819 820

	/*
	 * Initialize Channel list.
	 */
	for (i = 0; i < spec->num_channels; i++) {
		rt2x00lib_channel(&channels[i],
821
				  spec->channels[i].channel,
822
				  spec->channels_info[i].max_power, i);
823 824 825
	}

	/*
826
	 * Intitialize 802.11b, 802.11g
827
	 * Rates: CCK, OFDM.
828
	 * Channels: 2.4 GHz
829
	 */
830
	if (spec->supported_bands & SUPPORT_BAND_2GHZ) {
831 832 833 834 835 836
		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];
837 838
		memcpy(&rt2x00dev->bands[IEEE80211_BAND_2GHZ].ht_cap,
		       &spec->ht, sizeof(spec->ht));
839 840 841 842 843 844 845
	}

	/*
	 * Intitialize 802.11a
	 * Rates: OFDM.
	 * Channels: OFDM, UNII, HiperLAN2.
	 */
846
	if (spec->supported_bands & SUPPORT_BAND_5GHZ) {
847 848 849 850 851 852 853 854
		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];
855 856
		memcpy(&rt2x00dev->bands[IEEE80211_BAND_5GHZ].ht_cap,
		       &spec->ht, sizeof(spec->ht));
857 858 859 860
	}

	return 0;

861
 exit_free_channels:
862 863 864 865 866 867 868
	kfree(channels);
	ERROR(rt2x00dev, "Allocation ieee80211 modes failed.\n");
	return -ENOMEM;
}

static void rt2x00lib_remove_hw(struct rt2x00_dev *rt2x00dev)
{
869
	if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
870 871
		ieee80211_unregister_hw(rt2x00dev->hw);

872 873 874 875 876
	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;
877
	}
878 879

	kfree(rt2x00dev->spec.channels_info);
880 881 882 883 884 885 886
}

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

887 888 889
	if (test_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags))
		return 0;

890 891 892 893 894 895 896
	/*
	 * Initialize HW modes.
	 */
	status = rt2x00lib_probe_hw_modes(rt2x00dev, spec);
	if (status)
		return status;

897 898 899 900 901
	/*
	 * Initialize HW fields.
	 */
	rt2x00dev->hw->queues = rt2x00dev->ops->tx_queues;

902 903 904
	/*
	 * Initialize extra TX headroom required.
	 */
905 906 907 908 909 910 911
	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.
	 */
912
	if (test_bit(REQUIRE_L2PAD, &rt2x00dev->cap_flags))
913
		rt2x00dev->hw->extra_tx_headroom += RT2X00_L2PAD_SIZE;
914
	else if (test_bit(REQUIRE_DMA, &rt2x00dev->cap_flags))
915
		rt2x00dev->hw->extra_tx_headroom += RT2X00_ALIGN_SIZE;
916

917 918 919
	/*
	 * Allocate tx status FIFO for driver use.
	 */
920
	if (test_bit(REQUIRE_TXSTATUS_FIFO, &rt2x00dev->cap_flags)) {
921
		/*
922 923 924 925 926
		 * 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.
927
		 */
928 929 930 931 932 933
		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,
934 935 936 937 938
				     GFP_KERNEL);
		if (status)
			return status;
	}

939 940 941 942 943 944 945 946 947 948 949 950
	/*
	 * 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); \
	}

951
	RT2X00_TASKLET_INIT(txstatus_tasklet);
952 953 954 955 956 957 958
	RT2X00_TASKLET_INIT(pretbtt_tasklet);
	RT2X00_TASKLET_INIT(tbtt_tasklet);
	RT2X00_TASKLET_INIT(rxdone_tasklet);
	RT2X00_TASKLET_INIT(autowake_tasklet);

#undef RT2X00_TASKLET_INIT

959 960 961 962
	/*
	 * Register HW.
	 */
	status = ieee80211_register_hw(rt2x00dev->hw);
963
	if (status)
964 965
		return status;

966
	set_bit(DEVICE_STATE_REGISTERED_HW, &rt2x00dev->flags);
967 968 969 970 971 972 973

	return 0;
}

/*
 * Initialization/uninitialization handlers.
 */
974
static void rt2x00lib_uninitialize(struct rt2x00_dev *rt2x00dev)
975
{
976
	if (!test_and_clear_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags))
977 978 979
		return;

	/*
980
	 * Unregister extra components.
981 982 983 984 985 986 987 988 989
	 */
	rt2x00rfkill_unregister(rt2x00dev);

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

	/*
990
	 * Free allocated queue entries.
991
	 */
992
	rt2x00queue_uninitialize(rt2x00dev);
993 994
}

995
static int rt2x00lib_initialize(struct rt2x00_dev *rt2x00dev)
996 997 998
{
	int status;

999
	if (test_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags))
1000 1001 1002
		return 0;

	/*
1003
	 * Allocate all queue entries.
1004
	 */
1005 1006
	status = rt2x00queue_initialize(rt2x00dev);
	if (status)
1007 1008 1009 1010 1011 1012
		return status;

	/*
	 * Initialize the device.
	 */
	status = rt2x00dev->ops->lib->initialize(rt2x00dev);
1013 1014 1015 1016
	if (status) {
		rt2x00queue_uninitialize(rt2x00dev);
		return status;
	}
1017

1018
	set_bit(DEVICE_STATE_INITIALIZED, &rt2x00dev->flags);
1019 1020

	/*
1021
	 * Register the extra components.
1022
	 */
1023
	rt2x00rfkill_register(rt2x00dev);
1024 1025 1026 1027

	return 0;
}

1028 1029 1030 1031
int rt2x00lib_start(struct rt2x00_dev *rt2x00dev)
{
	int retval;

1032
	if (test_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
1033 1034 1035 1036 1037 1038
		return 0;

	/*
	 * If this is the first interface which is added,
	 * we should load the firmware now.
	 */
1039 1040 1041
	retval = rt2x00lib_load_firmware(rt2x00dev);
	if (retval)
		return retval;
1042 1043 1044 1045 1046 1047 1048 1049

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

1050 1051 1052 1053
	rt2x00dev->intf_ap_count = 0;
	rt2x00dev->intf_sta_count = 0;
	rt2x00dev->intf_associated = 0;

1054 1055
	/* Enable the radio */
	retval = rt2x00lib_enable_radio(rt2x00dev);
1056
	if (retval)
1057 1058
		return retval;

1059
	set_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags);
1060 1061 1062 1063 1064 1065

	return 0;
}

void rt2x00lib_stop(struct rt2x00_dev *rt2x00dev)
{
1066
	if (!test_and_clear_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
1067 1068 1069 1070 1071 1072 1073 1074
		return;

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

1075 1076 1077
	rt2x00dev->intf_ap_count = 0;
	rt2x00dev->intf_sta_count = 0;
	rt2x00dev->intf_associated = 0;
1078 1079
}

1080 1081 1082 1083 1084 1085 1086
/*
 * driver allocation handlers.
 */
int rt2x00lib_probe_dev(struct rt2x00_dev *rt2x00dev)
{
	int retval = -ENOMEM;

1087
	spin_lock_init(&rt2x00dev->irqmask_lock);
1088 1089
	mutex_init(&rt2x00dev->csr_mutex);

1090 1091
	set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);

1092 1093 1094 1095 1096 1097
	/*
	 * Make room for rt2x00_intf inside the per-interface
	 * structure ieee80211_vif.
	 */
	rt2x00dev->hw->vif_data_size = sizeof(struct rt2x00_intf);

1098 1099 1100 1101 1102 1103 1104 1105 1106
	/*
	 * 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
1107
		    BIT(NL80211_IFTYPE_AP) |
1108 1109
		    BIT(NL80211_IFTYPE_MESH_POINT) |
		    BIT(NL80211_IFTYPE_WDS);
1110

1111
	/*
1112
	 * Initialize work.
1113
	 */
1114 1115 1116 1117 1118 1119 1120
	rt2x00dev->workqueue =
	    alloc_ordered_workqueue(wiphy_name(rt2x00dev->hw->wiphy), 0);
	if (!rt2x00dev->workqueue) {
		retval = -ENOMEM;
		goto exit;
	}

1121
	INIT_WORK(&rt2x00dev->intf_work, rt2x00lib_intf_scheduled);
1122
	INIT_DELAYED_WORK(&rt2x00dev->autowakeup_work, rt2x00lib_autowakeup);
1123

1124 1125 1126 1127 1128 1129 1130 1131 1132 1133
	/*
	 * 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;
	}

	/*
1134
	 * Allocate queue array.
1135
	 */
1136
	retval = rt2x00queue_allocate(rt2x00dev);
1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148
	if (retval)
		goto exit;

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

1149
	/*
1150
	 * Register extra components.
1151
	 */
1152
	rt2x00link_register(rt2x00dev);
1153
	rt2x00leds_register(rt2x00dev);
1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166
	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)
{
1167
	clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
1168

1169 1170 1171 1172 1173
	/*
	 * Disable radio.
	 */
	rt2x00lib_disable_radio(rt2x00dev);

1174 1175 1176 1177
	/*
	 * Stop all work.
	 */
	cancel_work_sync(&rt2x00dev->intf_work);
Stanislaw Gruszka's avatar
Stanislaw Gruszka committed
1178
	cancel_delayed_work_sync(&rt2x00dev->autowakeup_work);
1179
	if (rt2x00_is_usb(rt2x00dev)) {
1180
		del_timer_sync(&rt2x00dev->txstatus_timer);
1181 1182 1183
		cancel_work_sync(&rt2x00dev->rxdone_work);
		cancel_work_sync(&rt2x00dev->txdone_work);
	}
1184
	destroy_workqueue(rt2x00dev->workqueue);
1185

1186 1187 1188 1189 1190 1191 1192 1193 1194
	/*
	 * Free the tx status fifo.
	 */
	kfifo_free(&rt2x00dev->txstatus_fifo);

	/*
	 * Kill the tx status tasklet.
	 */
	tasklet_kill(&rt2x00dev->txstatus_tasklet);
1195 1196 1197 1198
	tasklet_kill(&rt2x00dev->pretbtt_tasklet);
	tasklet_kill(&rt2x00dev->tbtt_tasklet);
	tasklet_kill(&rt2x00dev->rxdone_tasklet);
	tasklet_kill(&rt2x00dev->autowake_tasklet);
1199

1200 1201 1202 1203 1204 1205
	/*
	 * Uninitialize device.
	 */
	rt2x00lib_uninitialize(rt2x00dev);

	/*
1206
	 * Free extra components
1207 1208
	 */
	rt2x00debug_deregister(rt2x00dev);
1209 1210
	rt2x00leds_unregister(rt2x00dev);

1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221
	/*
	 * Free ieee80211_hw memory.
	 */
	rt2x00lib_remove_hw(rt2x00dev);

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

	/*
1222
	 * Free queue structures.
1223
	 */
1224
	rt2x00queue_free(rt2x00dev);
1225 1226 1227 1228 1229 1230 1231 1232 1233 1234
}
EXPORT_SYMBOL_GPL(rt2x00lib_remove_dev);

/*
 * Device state handlers
 */
#ifdef CONFIG_PM
int rt2x00lib_suspend(struct rt2x00_dev *rt2x00dev, pm_message_t state)
{
	NOTICE(rt2x00dev, "Going to sleep.\n");
1235 1236

	/*
1237
	 * Prevent mac80211 from accessing driver while suspended.
1238
	 */
1239 1240
	if (!test_and_clear_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags))
		return 0;
1241 1242

	/*
1243
	 * Cleanup as much as possible.
1244 1245
	 */
	rt2x00lib_uninitialize(rt2x00dev);
1246 1247 1248 1249

	/*
	 * Suspend/disable extra components.
	 */
1250
	rt2x00leds_suspend(rt2x00dev);
1251 1252 1253
	rt2x00debug_deregister(rt2x00dev);

	/*
1254 1255 1256 1257 1258 1259 1260 1261 1262
	 * 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.
1263
	 */
1264
	if (rt2x00dev->ops->lib->set_device_state(rt2x00dev, STATE_SLEEP))
1265 1266
		WARNING(rt2x00dev, "Device failed to enter sleep state, "
			"continue suspending.\n");
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276

	return 0;
}
EXPORT_SYMBOL_GPL(rt2x00lib_suspend);

int rt2x00lib_resume(struct rt2x00_dev *rt2x00dev)
{
	NOTICE(rt2x00dev, "Waking up.\n");

	/*
1277
	 * Restore/enable extra components.
1278 1279
	 */
	rt2x00debug_register(rt2x00dev);
1280
	rt2x00leds_resume(rt2x00dev);
1281

1282 1283 1284
	/*
	 * We are ready again to receive requests from mac80211.
	 */
1285
	set_bit(DEVICE_STATE_PRESENT, &rt2x00dev->flags);
1286

1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298
	return 0;
}
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");