4965-mac.c 175.6 KB
Newer Older
1 2 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 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52
/******************************************************************************
 *
 * Copyright(c) 2003 - 2011 Intel Corporation. All rights reserved.
 *
 * Portions of this file are derived from the ipw3945 project, as well
 * as portions of the ieee80211 subsystem header files.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * 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.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110, USA
 *
 * The full GNU General Public License is included in this distribution in the
 * file called LICENSE.
 *
 * Contact Information:
 *  Intel Linux Wireless <ilw@linux.intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 *****************************************************************************/

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/pci.h>
#include <linux/pci-aspm.h>
#include <linux/slab.h>
#include <linux/dma-mapping.h>
#include <linux/delay.h>
#include <linux/sched.h>
#include <linux/skbuff.h>
#include <linux/netdevice.h>
#include <linux/firmware.h>
#include <linux/etherdevice.h>
#include <linux/if_arp.h>

#include <net/mac80211.h>

#include <asm/div64.h>

#define DRV_NAME        "iwl4965"

53
#include "common.h"
54
#include "4965.h"
55 56 57 58 59 60 61 62 63 64 65 66

/******************************************************************************
 *
 * module boiler plate
 *
 ******************************************************************************/

/*
 * module name, copyright, version, etc.
 */
#define DRV_DESCRIPTION	"Intel(R) Wireless WiFi 4965 driver for Linux"

67
#ifdef CONFIG_IWLEGACY_DEBUG
68 69 70 71 72 73 74 75 76 77 78 79 80
#define VD "d"
#else
#define VD
#endif

#define DRV_VERSION     IWLWIFI_VERSION VD

MODULE_DESCRIPTION(DRV_DESCRIPTION);
MODULE_VERSION(DRV_VERSION);
MODULE_AUTHOR(DRV_COPYRIGHT " " DRV_AUTHOR);
MODULE_LICENSE("GPL");
MODULE_ALIAS("iwl4965");

81 82
void
il4965_check_abort_status(struct il_priv *il, u8 frame_count, u32 status)
83 84 85
{
	if (frame_count == 1 && status == TX_STATUS_FAIL_RFKILL_FLUSH) {
		IL_ERR("Tx flush command to flush out all frames\n");
S
Stanislaw Gruszka 已提交
86
		if (!test_bit(S_EXIT_PENDING, &il->status))
87 88 89 90 91 92 93 94 95 96 97 98 99
			queue_work(il->workqueue, &il->tx_flush);
	}
}

/*
 * EEPROM
 */
struct il_mod_params il4965_mod_params = {
	.amsdu_size_8K = 1,
	.restart_fw = 1,
	/* the rest are 0 by default */
};

100 101
void
il4965_rx_queue_reset(struct il_priv *il, struct il_rx_queue *rxq)
102 103 104 105 106 107 108 109 110 111 112 113
{
	unsigned long flags;
	int i;
	spin_lock_irqsave(&rxq->lock, flags);
	INIT_LIST_HEAD(&rxq->rx_free);
	INIT_LIST_HEAD(&rxq->rx_used);
	/* Fill the rx_used queue with _all_ of the Rx buffers */
	for (i = 0; i < RX_FREE_BUFFERS + RX_QUEUE_SIZE; i++) {
		/* In the reset function, these buffers may have been allocated
		 * to an SKB, so we need to unmap and free potential storage */
		if (rxq->pool[i].page != NULL) {
			pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
114 115
				       PAGE_SIZE << il->hw_params.rx_page_order,
				       PCI_DMA_FROMDEVICE);
116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
			__il_free_pages(il, rxq->pool[i].page);
			rxq->pool[i].page = NULL;
		}
		list_add_tail(&rxq->pool[i].list, &rxq->rx_used);
	}

	for (i = 0; i < RX_QUEUE_SIZE; i++)
		rxq->queue[i] = NULL;

	/* Set us so that we have processed and used all buffers, but have
	 * not restocked the Rx queue with fresh buffers */
	rxq->read = rxq->write = 0;
	rxq->write_actual = 0;
	rxq->free_count = 0;
	spin_unlock_irqrestore(&rxq->lock, flags);
}

133 134
int
il4965_rx_init(struct il_priv *il, struct il_rx_queue *rxq)
135 136
{
	u32 rb_size;
137
	const u32 rfdnlog = RX_QUEUE_SIZE_LOG;	/* 256 RBDs */
138 139 140
	u32 rb_timeout = 0;

	if (il->cfg->mod_params->amsdu_size_8K)
141
		rb_size = FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_8K;
142
	else
143
		rb_size = FH49_RCSR_RX_CONFIG_REG_VAL_RB_SIZE_4K;
144 145

	/* Stop Rx DMA */
146
	il_wr(il, FH49_MEM_RCSR_CHNL0_CONFIG_REG, 0);
147 148

	/* Reset driver's Rx queue write idx */
149
	il_wr(il, FH49_RSCSR_CHNL0_RBDCB_WPTR_REG, 0);
150 151

	/* Tell device where to find RBD circular buffer in DRAM */
152
	il_wr(il, FH49_RSCSR_CHNL0_RBDCB_BASE_REG, (u32) (rxq->bd_dma >> 8));
153 154

	/* Tell device where in DRAM to update its Rx status */
155
	il_wr(il, FH49_RSCSR_CHNL0_STTS_WPTR_REG, rxq->rb_stts_dma >> 4);
156 157 158 159 160 161 162

	/* Enable Rx DMA
	 * Direct rx interrupts to hosts
	 * Rx buffer size 4 or 8k
	 * RB timeout 0x10
	 * 256 RBDs
	 */
163
	il_wr(il, FH49_MEM_RCSR_CHNL0_CONFIG_REG,
164 165
	      FH49_RCSR_RX_CONFIG_CHNL_EN_ENABLE_VAL |
	      FH49_RCSR_CHNL0_RX_CONFIG_IRQ_DEST_INT_HOST_VAL |
S
Stanislaw Gruszka 已提交
166 167 168 169
	      FH49_RCSR_CHNL0_RX_CONFIG_SINGLE_FRAME_MSK |
	      rb_size |
	      (rb_timeout << FH49_RCSR_RX_CONFIG_REG_IRQ_RBTH_POS) |
	      (rfdnlog << FH49_RCSR_RX_CONFIG_RBDCB_SIZE_POS));
170 171 172 173 174 175 176

	/* Set interrupt coalescing timer to default (2048 usecs) */
	il_write8(il, CSR_INT_COALESCING, IL_HOST_INT_TIMEOUT_DEF);

	return 0;
}

177 178
static void
il4965_set_pwr_vmain(struct il_priv *il)
179 180 181 182 183 184 185 186 187 188 189 190
{
/*
 * (for documentation purposes)
 * to set power to V_AUX, do:

		if (pci_pme_capable(il->pci_dev, PCI_D3cold))
			il_set_bits_mask_prph(il, APMG_PS_CTRL_REG,
					       APMG_PS_CTRL_VAL_PWR_SRC_VAUX,
					       ~APMG_PS_CTRL_MSK_PWR_SRC);
 */

	il_set_bits_mask_prph(il, APMG_PS_CTRL_REG,
191 192
			      APMG_PS_CTRL_VAL_PWR_SRC_VMAIN,
			      ~APMG_PS_CTRL_MSK_PWR_SRC);
193 194
}

195 196
int
il4965_hw_nic_init(struct il_priv *il)
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
{
	unsigned long flags;
	struct il_rx_queue *rxq = &il->rxq;
	int ret;

	/* nic_init */
	spin_lock_irqsave(&il->lock, flags);
	il->cfg->ops->lib->apm_ops.init(il);

	/* Set interrupt coalescing calibration timer to default (512 usecs) */
	il_write8(il, CSR_INT_COALESCING, IL_HOST_INT_CALIB_TIMEOUT_DEF);

	spin_unlock_irqrestore(&il->lock, flags);

	il4965_set_pwr_vmain(il);

	il->cfg->ops->lib->apm_ops.config(il);

	/* Allocate the RX queue, or reset if it is already allocated */
	if (!rxq->bd) {
		ret = il_rx_queue_alloc(il);
		if (ret) {
			IL_ERR("Unable to initialize Rx queue\n");
			return -ENOMEM;
		}
	} else
		il4965_rx_queue_reset(il, rxq);

	il4965_rx_replenish(il);

	il4965_rx_init(il, rxq);

	spin_lock_irqsave(&il->lock, flags);

	rxq->need_update = 1;
	il_rx_queue_update_write_ptr(il, rxq);

	spin_unlock_irqrestore(&il->lock, flags);

	/* Allocate or reset and init all Tx and Command queues */
	if (!il->txq) {
		ret = il4965_txq_ctx_alloc(il);
		if (ret)
			return ret;
	} else
		il4965_txq_ctx_reset(il);

S
Stanislaw Gruszka 已提交
244
	set_bit(S_INIT, &il->status);
245 246 247 248 249 250 251

	return 0;
}

/**
 * il4965_dma_addr2rbd_ptr - convert a DMA address to a uCode read buffer ptr
 */
252 253
static inline __le32
il4965_dma_addr2rbd_ptr(struct il_priv *il, dma_addr_t dma_addr)
254
{
255
	return cpu_to_le32((u32) (dma_addr >> 8));
256 257 258 259 260 261 262 263 264 265 266 267 268
}

/**
 * il4965_rx_queue_restock - refill RX queue from pre-allocated pool
 *
 * If there are slots in the RX queue that need to be restocked,
 * and we have free pre-allocated buffers, fill the ranks as much
 * as we can, pulling from rx_free.
 *
 * This moves the 'write' idx forward to catch up with 'processed', and
 * also updates the memory address in the firmware to reference the new
 * target buffer.
 */
269 270
void
il4965_rx_queue_restock(struct il_priv *il)
271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288
{
	struct il_rx_queue *rxq = &il->rxq;
	struct list_head *element;
	struct il_rx_buf *rxb;
	unsigned long flags;

	spin_lock_irqsave(&rxq->lock, flags);
	while (il_rx_queue_space(rxq) > 0 && rxq->free_count) {
		/* The overwritten rxb must be a used one */
		rxb = rxq->queue[rxq->write];
		BUG_ON(rxb && rxb->page);

		/* Get next free Rx buffer, remove from free list */
		element = rxq->rx_free.next;
		rxb = list_entry(element, struct il_rx_buf, list);
		list_del(element);

		/* Point to Rx buffer via next RBD in circular buffer */
289 290
		rxq->bd[rxq->write] =
		    il4965_dma_addr2rbd_ptr(il, rxb->page_dma);
291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
		rxq->queue[rxq->write] = rxb;
		rxq->write = (rxq->write + 1) & RX_QUEUE_MASK;
		rxq->free_count--;
	}
	spin_unlock_irqrestore(&rxq->lock, flags);
	/* If the pre-allocated buffer pool is dropping low, schedule to
	 * refill it */
	if (rxq->free_count <= RX_LOW_WATERMARK)
		queue_work(il->workqueue, &il->rx_replenish);

	/* If we've added more space for the firmware to place data, tell it.
	 * Increment device's write pointer in multiples of 8. */
	if (rxq->write_actual != (rxq->write & ~0x7)) {
		spin_lock_irqsave(&rxq->lock, flags);
		rxq->need_update = 1;
		spin_unlock_irqrestore(&rxq->lock, flags);
		il_rx_queue_update_write_ptr(il, rxq);
	}
}

/**
 * il4965_rx_replenish - Move all used packet from rx_used to rx_free
 *
 * When moving to rx_free an SKB is allocated for the slot.
 *
 * Also restock the Rx queue via il_rx_queue_restock.
 * This is called as a scheduled work item (except for during initialization)
 */
319 320
static void
il4965_rx_allocate(struct il_priv *il, gfp_t priority)
321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
{
	struct il_rx_queue *rxq = &il->rxq;
	struct list_head *element;
	struct il_rx_buf *rxb;
	struct page *page;
	unsigned long flags;
	gfp_t gfp_mask = priority;

	while (1) {
		spin_lock_irqsave(&rxq->lock, flags);
		if (list_empty(&rxq->rx_used)) {
			spin_unlock_irqrestore(&rxq->lock, flags);
			return;
		}
		spin_unlock_irqrestore(&rxq->lock, flags);

		if (rxq->free_count > RX_LOW_WATERMARK)
			gfp_mask |= __GFP_NOWARN;

		if (il->hw_params.rx_page_order > 0)
			gfp_mask |= __GFP_COMP;

		/* Alloc a new receive buffer */
		page = alloc_pages(gfp_mask, il->hw_params.rx_page_order);
		if (!page) {
			if (net_ratelimit())
347 348
				D_INFO("alloc_pages failed, " "order: %d\n",
				       il->hw_params.rx_page_order);
349 350 351

			if (rxq->free_count <= RX_LOW_WATERMARK &&
			    net_ratelimit())
352 353 354 355 356
				IL_ERR("Failed to alloc_pages with %s. "
				       "Only %u free buffers remaining.\n",
				       priority ==
				       GFP_ATOMIC ? "GFP_ATOMIC" : "GFP_KERNEL",
				       rxq->free_count);
357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
			/* We don't reschedule replenish work here -- we will
			 * call the restock method and if it still needs
			 * more buffers it will schedule replenish */
			return;
		}

		spin_lock_irqsave(&rxq->lock, flags);

		if (list_empty(&rxq->rx_used)) {
			spin_unlock_irqrestore(&rxq->lock, flags);
			__free_pages(page, il->hw_params.rx_page_order);
			return;
		}
		element = rxq->rx_used.next;
		rxb = list_entry(element, struct il_rx_buf, list);
		list_del(element);

		spin_unlock_irqrestore(&rxq->lock, flags);

		BUG_ON(rxb->page);
		rxb->page = page;
		/* Get physical address of the RB */
379 380 381 382
		rxb->page_dma =
		    pci_map_page(il->pci_dev, page, 0,
				 PAGE_SIZE << il->hw_params.rx_page_order,
				 PCI_DMA_FROMDEVICE);
383 384 385 386 387 388 389 390 391 392 393 394 395 396 397
		/* dma address must be no more than 36 bits */
		BUG_ON(rxb->page_dma & ~DMA_BIT_MASK(36));
		/* and also 256 byte aligned! */
		BUG_ON(rxb->page_dma & DMA_BIT_MASK(8));

		spin_lock_irqsave(&rxq->lock, flags);

		list_add_tail(&rxb->list, &rxq->rx_free);
		rxq->free_count++;
		il->alloc_rxb_page++;

		spin_unlock_irqrestore(&rxq->lock, flags);
	}
}

398 399
void
il4965_rx_replenish(struct il_priv *il)
400 401 402 403 404 405 406 407 408 409
{
	unsigned long flags;

	il4965_rx_allocate(il, GFP_KERNEL);

	spin_lock_irqsave(&il->lock, flags);
	il4965_rx_queue_restock(il);
	spin_unlock_irqrestore(&il->lock, flags);
}

410 411
void
il4965_rx_replenish_now(struct il_priv *il)
412 413 414 415 416 417 418 419 420 421 422
{
	il4965_rx_allocate(il, GFP_ATOMIC);

	il4965_rx_queue_restock(il);
}

/* Assumes that the skb field of the buffers in 'pool' is kept accurate.
 * If an SKB has been detached, the POOL needs to have its SKB set to NULL
 * This free routine walks the list of POOL entries and if SKB is set to
 * non NULL it is unmapped and freed
 */
423 424
void
il4965_rx_queue_free(struct il_priv *il, struct il_rx_queue *rxq)
425 426 427 428 429
{
	int i;
	for (i = 0; i < RX_QUEUE_SIZE + RX_FREE_BUFFERS; i++) {
		if (rxq->pool[i].page != NULL) {
			pci_unmap_page(il->pci_dev, rxq->pool[i].page_dma,
430 431
				       PAGE_SIZE << il->hw_params.rx_page_order,
				       PCI_DMA_FROMDEVICE);
432 433 434 435 436 437 438 439 440 441
			__il_free_pages(il, rxq->pool[i].page);
			rxq->pool[i].page = NULL;
		}
	}

	dma_free_coherent(&il->pci_dev->dev, 4 * RX_QUEUE_SIZE, rxq->bd,
			  rxq->bd_dma);
	dma_free_coherent(&il->pci_dev->dev, sizeof(struct il_rb_status),
			  rxq->rb_stts, rxq->rb_stts_dma);
	rxq->bd = NULL;
442
	rxq->rb_stts = NULL;
443 444
}

445 446
int
il4965_rxq_stop(struct il_priv *il)
447 448 449
{

	/* stop Rx DMA */
450 451
	il_wr(il, FH49_MEM_RCSR_CHNL0_CONFIG_REG, 0);
	il_poll_bit(il, FH49_MEM_RSSR_RX_STATUS_REG,
452
		    FH49_RSSR_CHNL0_RX_STATUS_CHNL_IDLE, 1000);
453 454 455 456

	return 0;
}

457 458
int
il4965_hwrate_to_mac80211_idx(u32 rate_n_flags, enum ieee80211_band band)
459 460 461 462 463 464 465 466
{
	int idx = 0;
	int band_offset = 0;

	/* HT rate format: mac80211 wants an MCS number, which is just LSB */
	if (rate_n_flags & RATE_MCS_HT_MSK) {
		idx = (rate_n_flags & 0xff);
		return idx;
467
		/* Legacy rate format, search for match in table */
468 469 470 471 472 473 474 475 476 477 478
	} else {
		if (band == IEEE80211_BAND_5GHZ)
			band_offset = IL_FIRST_OFDM_RATE;
		for (idx = band_offset; idx < RATE_COUNT_LEGACY; idx++)
			if (il_rates[idx].plcp == (rate_n_flags & 0xFF))
				return idx - band_offset;
	}

	return -1;
}

479 480
static int
il4965_calc_rssi(struct il_priv *il, struct il_rx_phy_res *rx_resp)
481 482 483 484 485
{
	/* data from PHY/DSP regarding signal strength, etc.,
	 *   contents are always there, not configurable by host.  */
	struct il4965_rx_non_cfg_phy *ncphy =
	    (struct il4965_rx_non_cfg_phy *)rx_resp->non_cfg_phy_buf;
486 487 488
	u32 agc =
	    (le16_to_cpu(ncphy->agc_info) & IL49_AGC_DB_MASK) >>
	    IL49_AGC_DB_POS;
489 490 491

	u32 valid_antennae =
	    (le16_to_cpu(rx_resp->phy_flags) & IL49_RX_PHY_FLAGS_ANTENNAE_MASK)
492
	    >> IL49_RX_PHY_FLAGS_ANTENNAE_OFFSET;
493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513
	u8 max_rssi = 0;
	u32 i;

	/* Find max rssi among 3 possible receivers.
	 * These values are measured by the digital signal processor (DSP).
	 * They should stay fairly constant even as the signal strength varies,
	 *   if the radio's automatic gain control (AGC) is working right.
	 * AGC value (see below) will provide the "interesting" info. */
	for (i = 0; i < 3; i++)
		if (valid_antennae & (1 << i))
			max_rssi = max(ncphy->rssi_info[i << 1], max_rssi);

	D_STATS("Rssi In A %d B %d C %d Max %d AGC dB %d\n",
		ncphy->rssi_info[0], ncphy->rssi_info[2], ncphy->rssi_info[4],
		max_rssi, agc);

	/* dBm = max_rssi dB - agc dB - constant.
	 * Higher AGC (higher radio gain) means lower signal. */
	return max_rssi - agc - IL4965_RSSI_OFFSET;
}

514 515
static u32
il4965_translate_rx_status(struct il_priv *il, u32 decrypt_in)
516 517 518 519
{
	u32 decrypt_out = 0;

	if ((decrypt_in & RX_RES_STATUS_STATION_FOUND) ==
520 521 522 523
	    RX_RES_STATUS_STATION_FOUND)
		decrypt_out |=
		    (RX_RES_STATUS_STATION_FOUND |
		     RX_RES_STATUS_NO_STATION_INFO_MISMATCH);
524 525 526 527 528

	decrypt_out |= (decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK);

	/* packet was not encrypted */
	if ((decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK) ==
529
	    RX_RES_STATUS_SEC_TYPE_NONE)
530 531 532 533
		return decrypt_out;

	/* packet was encrypted with unknown alg */
	if ((decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK) ==
534
	    RX_RES_STATUS_SEC_TYPE_ERR)
535 536 537 538
		return decrypt_out;

	/* decryption was not done in HW */
	if ((decrypt_in & RX_MPDU_RES_STATUS_DEC_DONE_MSK) !=
539
	    RX_MPDU_RES_STATUS_DEC_DONE_MSK)
540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568
		return decrypt_out;

	switch (decrypt_in & RX_RES_STATUS_SEC_TYPE_MSK) {

	case RX_RES_STATUS_SEC_TYPE_CCMP:
		/* alg is CCM: check MIC only */
		if (!(decrypt_in & RX_MPDU_RES_STATUS_MIC_OK))
			/* Bad MIC */
			decrypt_out |= RX_RES_STATUS_BAD_ICV_MIC;
		else
			decrypt_out |= RX_RES_STATUS_DECRYPT_OK;

		break;

	case RX_RES_STATUS_SEC_TYPE_TKIP:
		if (!(decrypt_in & RX_MPDU_RES_STATUS_TTAK_OK)) {
			/* Bad TTAK */
			decrypt_out |= RX_RES_STATUS_BAD_KEY_TTAK;
			break;
		}
		/* fall through if TTAK OK */
	default:
		if (!(decrypt_in & RX_MPDU_RES_STATUS_ICV_OK))
			decrypt_out |= RX_RES_STATUS_BAD_ICV_MIC;
		else
			decrypt_out |= RX_RES_STATUS_DECRYPT_OK;
		break;
	}

569
	D_RX("decrypt_in:0x%x  decrypt_out = 0x%x\n", decrypt_in, decrypt_out);
570 571 572 573

	return decrypt_out;
}

574 575 576 577
static void
il4965_pass_packet_to_mac80211(struct il_priv *il, struct ieee80211_hdr *hdr,
			       u16 len, u32 ampdu_status, struct il_rx_buf *rxb,
			       struct ieee80211_rx_status *stats)
578 579 580 581 582 583
{
	struct sk_buff *skb;
	__le16 fc = hdr->frame_control;

	/* We only process data packets if the interface is open */
	if (unlikely(!il->is_open)) {
584
		D_DROP("Dropping packet while interface is not open.\n");
585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
		return;
	}

	/* In case of HW accelerated crypto and bad decryption, drop */
	if (!il->cfg->mod_params->sw_crypto &&
	    il_set_decrypted_flag(il, hdr, ampdu_status, stats))
		return;

	skb = dev_alloc_skb(128);
	if (!skb) {
		IL_ERR("dev_alloc_skb failed\n");
		return;
	}

	skb_add_rx_frag(skb, 0, rxb->page, (void *)hdr - rxb_addr(rxb), len);

	il_update_stats(il, false, fc, len);
	memcpy(IEEE80211_SKB_RXCB(skb), stats, sizeof(*stats));

	ieee80211_rx(il->hw, skb);
	il->alloc_rxb_page--;
	rxb->page = NULL;
}

609 610
/* Called for N_RX (legacy ABG frames), or
 * N_RX_MPDU (HT high-throughput N frames). */
611 612
void
il4965_hdl_rx(struct il_priv *il, struct il_rx_buf *rxb)
613 614 615 616 617 618 619 620 621 622 623 624
{
	struct ieee80211_hdr *header;
	struct ieee80211_rx_status rx_status;
	struct il_rx_pkt *pkt = rxb_addr(rxb);
	struct il_rx_phy_res *phy_res;
	__le32 rx_pkt_status;
	struct il_rx_mpdu_res_start *amsdu;
	u32 len;
	u32 ampdu_status;
	u32 rate_n_flags;

	/**
625 626 627
	 * N_RX and N_RX_MPDU are handled differently.
	 *	N_RX: physical layer info is in this buffer
	 *	N_RX_MPDU: physical layer info was sent in separate
628 629 630 631 632
	 *		command and cached in il->last_phy_res
	 *
	 * Here we set up local variables depending on which command is
	 * received.
	 */
633
	if (pkt->hdr.cmd == N_RX) {
634
		phy_res = (struct il_rx_phy_res *)pkt->u.raw;
635 636 637
		header =
		    (struct ieee80211_hdr *)(pkt->u.raw + sizeof(*phy_res) +
					     phy_res->cfg_phy_cnt);
638 639

		len = le16_to_cpu(phy_res->byte_count);
640 641 642
		rx_pkt_status =
		    *(__le32 *) (pkt->u.raw + sizeof(*phy_res) +
				 phy_res->cfg_phy_cnt + len);
643 644 645 646 647 648 649 650 651 652
		ampdu_status = le32_to_cpu(rx_pkt_status);
	} else {
		if (!il->_4965.last_phy_res_valid) {
			IL_ERR("MPDU frame without cached PHY data\n");
			return;
		}
		phy_res = &il->_4965.last_phy_res;
		amsdu = (struct il_rx_mpdu_res_start *)pkt->u.raw;
		header = (struct ieee80211_hdr *)(pkt->u.raw + sizeof(*amsdu));
		len = le16_to_cpu(amsdu->byte_count);
653 654 655
		rx_pkt_status = *(__le32 *) (pkt->u.raw + sizeof(*amsdu) + len);
		ampdu_status =
		    il4965_translate_rx_status(il, le32_to_cpu(rx_pkt_status));
656 657 658 659
	}

	if ((unlikely(phy_res->cfg_phy_cnt > 20))) {
		D_DROP("dsp size out of range [0,20]: %d/n",
660
		       phy_res->cfg_phy_cnt);
661 662 663 664 665
		return;
	}

	if (!(rx_pkt_status & RX_RES_STATUS_NO_CRC32_ERROR) ||
	    !(rx_pkt_status & RX_RES_STATUS_NO_RXE_OVERFLOW)) {
666
		D_RX("Bad CRC or FIFO: 0x%08X.\n", le32_to_cpu(rx_pkt_status));
667 668 669 670 671 672 673 674
		return;
	}

	/* This will be used in several places later */
	rate_n_flags = le32_to_cpu(phy_res->rate_n_flags);

	/* rx_status carries information about the packet to mac80211 */
	rx_status.mactime = le64_to_cpu(phy_res->timestamp);
675 676 677 678
	rx_status.band =
	    (phy_res->
	     phy_flags & RX_RES_PHY_FLAGS_BAND_24_MSK) ? IEEE80211_BAND_2GHZ :
	    IEEE80211_BAND_5GHZ;
679
	rx_status.freq =
680 681
	    ieee80211_channel_to_frequency(le16_to_cpu(phy_res->channel),
					   rx_status.band);
682
	rx_status.rate_idx =
683
	    il4965_hwrate_to_mac80211_idx(rate_n_flags, rx_status.band);
684 685 686 687
	rx_status.flag = 0;

	/* TSF isn't reliable. In order to allow smooth user experience,
	 * this W/A doesn't propagate it to the mac80211 */
688
	/*rx_status.flag |= RX_FLAG_MACTIME_MPDU; */
689 690 691 692 693 694 695

	il->ucode_beacon_time = le32_to_cpu(phy_res->beacon_time_stamp);

	/* Find max signal strength (dBm) among 3 antenna/receiver chains */
	rx_status.signal = il4965_calc_rssi(il, phy_res);

	il_dbg_log_rx_data_frame(il, len, header);
696 697
	D_STATS("Rssi %d, TSF %llu\n", rx_status.signal,
		(unsigned long long)rx_status.mactime);
698 699 700 701 702 703 704 705 706 707 708 709 710 711 712

	/*
	 * "antenna number"
	 *
	 * It seems that the antenna field in the phy flags value
	 * is actually a bit field. This is undefined by radiotap,
	 * it wants an actual antenna number but I always get "7"
	 * for most legacy frames I receive indicating that the
	 * same frame was received on all three RX chains.
	 *
	 * I think this field should be removed in favor of a
	 * new 802.11n radiotap field "RX chains" that is defined
	 * as a bitmask.
	 */
	rx_status.antenna =
713 714
	    (le16_to_cpu(phy_res->phy_flags) & RX_RES_PHY_FLAGS_ANTENNA_MSK) >>
	    RX_RES_PHY_FLAGS_ANTENNA_POS;
715 716 717 718 719 720 721 722 723 724 725 726 727

	/* set the preamble flag if appropriate */
	if (phy_res->phy_flags & RX_RES_PHY_FLAGS_SHORT_PREAMBLE_MSK)
		rx_status.flag |= RX_FLAG_SHORTPRE;

	/* Set up the HT phy flags */
	if (rate_n_flags & RATE_MCS_HT_MSK)
		rx_status.flag |= RX_FLAG_HT;
	if (rate_n_flags & RATE_MCS_HT40_MSK)
		rx_status.flag |= RX_FLAG_40MHZ;
	if (rate_n_flags & RATE_MCS_SGI_MSK)
		rx_status.flag |= RX_FLAG_SHORT_GI;

728 729
	il4965_pass_packet_to_mac80211(il, header, len, ampdu_status, rxb,
				       &rx_status);
730 731
}

732
/* Cache phy data (Rx signal strength, etc) for HT frame (N_RX_PHY).
S
Stanislaw Gruszka 已提交
733
 * This will be used later in il_hdl_rx() for N_RX_MPDU. */
734 735
void
il4965_hdl_rx_phy(struct il_priv *il, struct il_rx_buf *rxb)
736 737 738 739 740 741 742
{
	struct il_rx_pkt *pkt = rxb_addr(rxb);
	il->_4965.last_phy_res_valid = true;
	memcpy(&il->_4965.last_phy_res, pkt->u.raw,
	       sizeof(struct il_rx_phy_res));
}

743 744 745 746
static int
il4965_get_channels_for_scan(struct il_priv *il, struct ieee80211_vif *vif,
			     enum ieee80211_band band, u8 is_active,
			     u8 n_probes, struct il_scan_channel *scan_ch)
747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776
{
	struct ieee80211_channel *chan;
	const struct ieee80211_supported_band *sband;
	const struct il_channel_info *ch_info;
	u16 passive_dwell = 0;
	u16 active_dwell = 0;
	int added, i;
	u16 channel;

	sband = il_get_hw_mode(il, band);
	if (!sband)
		return 0;

	active_dwell = il_get_active_dwell_time(il, band, n_probes);
	passive_dwell = il_get_passive_dwell_time(il, band, vif);

	if (passive_dwell <= active_dwell)
		passive_dwell = active_dwell + 1;

	for (i = 0, added = 0; i < il->scan_request->n_channels; i++) {
		chan = il->scan_request->channels[i];

		if (chan->band != band)
			continue;

		channel = chan->hw_value;
		scan_ch->channel = cpu_to_le16(channel);

		ch_info = il_get_channel_info(il, band, channel);
		if (!il_is_channel_valid(ch_info)) {
777 778
			D_SCAN("Channel %d is INVALID for this band.\n",
			       channel);
779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
			continue;
		}

		if (!is_active || il_is_channel_passive(ch_info) ||
		    (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN))
			scan_ch->type = SCAN_CHANNEL_TYPE_PASSIVE;
		else
			scan_ch->type = SCAN_CHANNEL_TYPE_ACTIVE;

		if (n_probes)
			scan_ch->type |= IL_SCAN_PROBE_MASK(n_probes);

		scan_ch->active_dwell = cpu_to_le16(active_dwell);
		scan_ch->passive_dwell = cpu_to_le16(passive_dwell);

		/* Set txpower levels to defaults */
		scan_ch->dsp_atten = 110;

		/* NOTE: if we were doing 6Mb OFDM for scans we'd use
		 * power level:
		 * scan_ch->tx_gain = ((1 << 5) | (2 << 3)) | 3;
		 */
		if (band == IEEE80211_BAND_5GHZ)
			scan_ch->tx_gain = ((1 << 5) | (3 << 3)) | 3;
		else
			scan_ch->tx_gain = ((1 << 5) | (5 << 3));

806 807 808 809 810 811 812
		D_SCAN("Scanning ch=%d prob=0x%X [%s %d]\n", channel,
		       le32_to_cpu(scan_ch->type),
		       (scan_ch->
			type & SCAN_CHANNEL_TYPE_ACTIVE) ? "ACTIVE" : "PASSIVE",
		       (scan_ch->
			type & SCAN_CHANNEL_TYPE_ACTIVE) ? active_dwell :
		       passive_dwell);
813 814 815 816 817 818 819 820 821

		scan_ch++;
		added++;
	}

	D_SCAN("total channels to scan %d\n", added);
	return added;
}

822 823 824 825 826 827 828 829 830 831 832 833 834 835 836
static void
il4965_toggle_tx_ant(struct il_priv *il, u8 *ant, u8 valid)
{
	int i;
	u8 ind = *ant;

	for (i = 0; i < RATE_ANT_NUM - 1; i++) {
		ind = (ind + 1) < RATE_ANT_NUM ? ind + 1 : 0;
		if (valid & BIT(ind)) {
			*ant = ind;
			return;
		}
	}
}

837 838
int
il4965_request_scan(struct il_priv *il, struct ieee80211_vif *vif)
839 840
{
	struct il_host_cmd cmd = {
841
		.id = C_SCAN,
842 843 844 845 846 847 848 849 850 851 852 853 854
		.len = sizeof(struct il_scan_cmd),
		.flags = CMD_SIZE_HUGE,
	};
	struct il_scan_cmd *scan;
	struct il_rxon_context *ctx = &il->ctx;
	u32 rate_flags = 0;
	u16 cmd_len;
	u16 rx_chain = 0;
	enum ieee80211_band band;
	u8 n_probes = 0;
	u8 rx_ant = il->hw_params.valid_rx_ant;
	u8 rate;
	bool is_active = false;
855
	int chan_mod;
856 857 858 859 860 861
	u8 active_chains;
	u8 scan_tx_antennas = il->hw_params.valid_tx_ant;
	int ret;

	lockdep_assert_held(&il->mutex);

862
	ctx = il_rxon_ctx_from_vif(vif);
863 864

	if (!il->scan_cmd) {
865 866 867
		il->scan_cmd =
		    kmalloc(sizeof(struct il_scan_cmd) + IL_MAX_SCAN_SIZE,
			    GFP_KERNEL);
868
		if (!il->scan_cmd) {
869
			D_SCAN("fail to allocate memory for scan\n");
870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893
			return -ENOMEM;
		}
	}
	scan = il->scan_cmd;
	memset(scan, 0, sizeof(struct il_scan_cmd) + IL_MAX_SCAN_SIZE);

	scan->quiet_plcp_th = IL_PLCP_QUIET_THRESH;
	scan->quiet_time = IL_ACTIVE_QUIET_TIME;

	if (il_is_any_associated(il)) {
		u16 interval;
		u32 extra;
		u32 suspend_time = 100;
		u32 scan_suspend_time = 100;

		D_INFO("Scanning while associated...\n");
		interval = vif->bss_conf.beacon_int;

		scan->suspend_time = 0;
		scan->max_out_time = cpu_to_le32(200 * 1024);
		if (!interval)
			interval = suspend_time;

		extra = (suspend_time / interval) << 22;
894 895
		scan_suspend_time =
		    (extra | ((suspend_time % interval) * 1024));
896 897
		scan->suspend_time = cpu_to_le32(scan_suspend_time);
		D_SCAN("suspend_time 0x%X beacon interval %d\n",
898
		       scan_suspend_time, interval);
899 900 901 902 903 904 905 906 907 908 909
	}

	if (il->scan_request->n_ssids) {
		int i, p = 0;
		D_SCAN("Kicking off active scan\n");
		for (i = 0; i < il->scan_request->n_ssids; i++) {
			/* always does wildcard anyway */
			if (!il->scan_request->ssids[i].ssid_len)
				continue;
			scan->direct_scan[p].id = WLAN_EID_SSID;
			scan->direct_scan[p].len =
910
			    il->scan_request->ssids[i].ssid_len;
911 912 913 914 915 916 917 918 919 920 921
			memcpy(scan->direct_scan[p].ssid,
			       il->scan_request->ssids[i].ssid,
			       il->scan_request->ssids[i].ssid_len);
			n_probes++;
			p++;
		}
		is_active = true;
	} else
		D_SCAN("Start passive scan.\n");

	scan->tx_cmd.tx_flags = TX_CMD_FLG_SEQ_CTL_MSK;
922
	scan->tx_cmd.sta_id = il->hw_params.bcast_id;
923 924 925 926 927
	scan->tx_cmd.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;

	switch (il->scan_band) {
	case IEEE80211_BAND_2GHZ:
		scan->flags = RXON_FLG_BAND_24G_MSK | RXON_FLG_AUTO_DETECT_MSK;
928
		chan_mod =
929
		    le32_to_cpu(il->active.flags & RXON_FLG_CHANNEL_MODE_MSK) >>
930
		    RXON_FLG_CHANNEL_MODE_POS;
931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962
		if (chan_mod == CHANNEL_MODE_PURE_40) {
			rate = RATE_6M_PLCP;
		} else {
			rate = RATE_1M_PLCP;
			rate_flags = RATE_MCS_CCK_MSK;
		}
		break;
	case IEEE80211_BAND_5GHZ:
		rate = RATE_6M_PLCP;
		break;
	default:
		IL_WARN("Invalid scan band\n");
		return -EIO;
	}

	/*
	 * If active scanning is requested but a certain channel is
	 * marked passive, we can do active scanning if we detect
	 * transmissions.
	 *
	 * There is an issue with some firmware versions that triggers
	 * a sysassert on a "good CRC threshold" of zero (== disabled),
	 * on a radar channel even though this means that we should NOT
	 * send probes.
	 *
	 * The "good CRC threshold" is the number of frames that we
	 * need to receive during our dwell time on a channel before
	 * sending out probes -- setting this to a huge value will
	 * mean we never reach it, but at the same time work around
	 * the aforementioned issue. Thus use IL_GOOD_CRC_TH_NEVER
	 * here instead of IL_GOOD_CRC_TH_DISABLED.
	 */
963 964
	scan->good_CRC_th =
	    is_active ? IL_GOOD_CRC_TH_DEFAULT : IL_GOOD_CRC_TH_NEVER;
965 966 967 968 969 970

	band = il->scan_band;

	if (il->cfg->scan_rx_antennas[band])
		rx_ant = il->cfg->scan_rx_antennas[band];

971
	il4965_toggle_tx_ant(il, &il->scan_tx_ant[band], scan_tx_antennas);
972 973
	rate_flags |= BIT(il->scan_tx_ant[band]) << RATE_MCS_ANT_POS;
	scan->tx_cmd.rate_n_flags = cpu_to_le32(rate | rate_flags);
974 975

	/* In power save mode use one chain, otherwise use all chains */
S
Stanislaw Gruszka 已提交
976
	if (test_bit(S_POWER_PMI, &il->status)) {
977
		/* rx_ant has been set to all valid chains previously */
978 979
		active_chains =
		    rx_ant & ((u8) (il->chain_noise_data.active_chains));
980 981 982 983
		if (!active_chains)
			active_chains = rx_ant;

		D_SCAN("chain_noise_data.active_chains: %u\n",
984
		       il->chain_noise_data.active_chains);
985 986 987 988 989 990 991 992 993 994 995

		rx_ant = il4965_first_antenna(active_chains);
	}

	/* MIMO is not used here, but value is required */
	rx_chain |= il->hw_params.valid_rx_ant << RXON_RX_CHAIN_VALID_POS;
	rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_MIMO_SEL_POS;
	rx_chain |= rx_ant << RXON_RX_CHAIN_FORCE_SEL_POS;
	rx_chain |= 0x1 << RXON_RX_CHAIN_DRIVER_FORCE_POS;
	scan->rx_chain = cpu_to_le16(rx_chain);

996 997 998 999 1000
	cmd_len =
	    il_fill_probe_req(il, (struct ieee80211_mgmt *)scan->data,
			      vif->addr, il->scan_request->ie,
			      il->scan_request->ie_len,
			      IL_MAX_SCAN_SIZE - sizeof(*scan));
1001 1002
	scan->tx_cmd.len = cpu_to_le16(cmd_len);

1003 1004
	scan->filter_flags |=
	    (RXON_FILTER_ACCEPT_GRP_MSK | RXON_FILTER_BCON_AWARE_MSK);
1005

1006 1007 1008
	scan->channel_count =
	    il4965_get_channels_for_scan(il, vif, band, is_active, n_probes,
					 (void *)&scan->data[cmd_len]);
1009 1010 1011 1012 1013
	if (scan->channel_count == 0) {
		D_SCAN("channel count %d\n", scan->channel_count);
		return -EIO;
	}

1014 1015
	cmd.len +=
	    le16_to_cpu(scan->tx_cmd.len) +
1016 1017 1018 1019
	    scan->channel_count * sizeof(struct il_scan_channel);
	cmd.data = scan;
	scan->len = cpu_to_le16(cmd.len);

S
Stanislaw Gruszka 已提交
1020
	set_bit(S_SCAN_HW, &il->status);
1021 1022 1023

	ret = il_send_cmd_sync(il, &cmd);
	if (ret)
S
Stanislaw Gruszka 已提交
1024
		clear_bit(S_SCAN_HW, &il->status);
1025 1026 1027 1028

	return ret;
}

1029 1030 1031
int
il4965_manage_ibss_station(struct il_priv *il, struct ieee80211_vif *vif,
			   bool add)
1032 1033 1034 1035 1036 1037 1038 1039
{
	struct il_vif_priv *vif_priv = (void *)vif->drv_priv;

	if (add)
		return il4965_add_bssid_station(il, vif_priv->ctx,
						vif->bss_conf.bssid,
						&vif_priv->ibss_bssid_sta_id);
	return il_remove_station(il, vif_priv->ibss_bssid_sta_id,
1040
				 vif->bss_conf.bssid);
1041 1042
}

1043 1044
void
il4965_free_tfds_in_queue(struct il_priv *il, int sta_id, int tid, int freed)
1045 1046 1047 1048 1049 1050 1051
{
	lockdep_assert_held(&il->sta_lock);

	if (il->stations[sta_id].tid[tid].tfds_in_queue >= freed)
		il->stations[sta_id].tid[tid].tfds_in_queue -= freed;
	else {
		D_TX("free more than tfds_in_queue (%u:%d)\n",
1052
		     il->stations[sta_id].tid[tid].tfds_in_queue, freed);
1053 1054 1055 1056 1057 1058
		il->stations[sta_id].tid[tid].tfds_in_queue = 0;
	}
}

#define IL_TX_QUEUE_MSK	0xfffff

1059 1060
static bool
il4965_is_single_rx_stream(struct il_priv *il)
1061 1062
{
	return il->current_ht_config.smps == IEEE80211_SMPS_STATIC ||
1063
	    il->current_ht_config.single_chain_sufficient;
1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
}

#define IL_NUM_RX_CHAINS_MULTIPLE	3
#define IL_NUM_RX_CHAINS_SINGLE	2
#define IL_NUM_IDLE_CHAINS_DUAL	2
#define IL_NUM_IDLE_CHAINS_SINGLE	1

/*
 * Determine how many receiver/antenna chains to use.
 *
 * More provides better reception via diversity.  Fewer saves power
 * at the expense of throughput, but only when not in powersave to
 * start with.
 *
 * MIMO (dual stream) requires at least 2, but works better with 3.
 * This does not determine *which* chains to use, just how many.
 */
1081 1082
static int
il4965_get_active_rx_chain_count(struct il_priv *il)
1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
{
	/* # of Rx chains to use when expecting MIMO. */
	if (il4965_is_single_rx_stream(il))
		return IL_NUM_RX_CHAINS_SINGLE;
	else
		return IL_NUM_RX_CHAINS_MULTIPLE;
}

/*
 * When we are in power saving mode, unless device support spatial
 * multiplexing power save, use the active count for rx chain count.
 */
static int
il4965_get_idle_rx_chain_count(struct il_priv *il, int active_cnt)
{
	/* # Rx chains when idling, depending on SMPS mode */
	switch (il->current_ht_config.smps) {
	case IEEE80211_SMPS_STATIC:
	case IEEE80211_SMPS_DYNAMIC:
		return IL_NUM_IDLE_CHAINS_SINGLE;
	case IEEE80211_SMPS_OFF:
		return active_cnt;
	default:
1106
		WARN(1, "invalid SMPS mode %d", il->current_ht_config.smps);
1107 1108 1109 1110 1111
		return active_cnt;
	}
}

/* up to 4 chains */
1112 1113
static u8
il4965_count_chain_bitmap(u32 chain_bitmap)
1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
{
	u8 res;
	res = (chain_bitmap & BIT(0)) >> 0;
	res += (chain_bitmap & BIT(1)) >> 1;
	res += (chain_bitmap & BIT(2)) >> 2;
	res += (chain_bitmap & BIT(3)) >> 3;
	return res;
}

/**
 * il4965_set_rxon_chain - Set up Rx chain usage in "staging" RXON image
 *
 * Selects how many and which Rx receivers/antennas/chains to use.
 * This should not be used for scan command ... it puts data in wrong place.
 */
1129 1130
void
il4965_set_rxon_chain(struct il_priv *il, struct il_rxon_context *ctx)
1131 1132
{
	bool is_single = il4965_is_single_rx_stream(il);
S
Stanislaw Gruszka 已提交
1133
	bool is_cam = !test_bit(S_POWER_PMI, &il->status);
1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
	u8 idle_rx_cnt, active_rx_cnt, valid_rx_cnt;
	u32 active_chains;
	u16 rx_chain;

	/* Tell uCode which antennas are actually connected.
	 * Before first association, we assume all antennas are connected.
	 * Just after first association, il4965_chain_noise_calibration()
	 *    checks which antennas actually *are* connected. */
	if (il->chain_noise_data.active_chains)
		active_chains = il->chain_noise_data.active_chains;
	else
		active_chains = il->hw_params.valid_rx_ant;

	rx_chain = active_chains << RXON_RX_CHAIN_VALID_POS;

	/* How many receivers should we use? */
	active_rx_cnt = il4965_get_active_rx_chain_count(il);
	idle_rx_cnt = il4965_get_idle_rx_chain_count(il, active_rx_cnt);

	/* correct rx chain count according hw settings
	 * and chain noise calibration
	 */
	valid_rx_cnt = il4965_count_chain_bitmap(active_chains);
	if (valid_rx_cnt < active_rx_cnt)
		active_rx_cnt = valid_rx_cnt;

	if (valid_rx_cnt < idle_rx_cnt)
		idle_rx_cnt = valid_rx_cnt;

	rx_chain |= active_rx_cnt << RXON_RX_CHAIN_MIMO_CNT_POS;
1164
	rx_chain |= idle_rx_cnt << RXON_RX_CHAIN_CNT_POS;
1165

1166
	il->staging.rx_chain = cpu_to_le16(rx_chain);
1167 1168

	if (!is_single && active_rx_cnt >= IL_NUM_RX_CHAINS_SINGLE && is_cam)
1169
		il->staging.rx_chain |= RXON_RX_CHAIN_MIMO_FORCE_MSK;
1170
	else
1171
		il->staging.rx_chain &= ~RXON_RX_CHAIN_MIMO_FORCE_MSK;
1172

1173
	D_ASSOC("rx_chain=0x%X active=%d idle=%d\n", il->staging.rx_chain,
1174
		active_rx_cnt, idle_rx_cnt);
1175 1176 1177 1178 1179

	WARN_ON(active_rx_cnt == 0 || idle_rx_cnt == 0 ||
		active_rx_cnt < idle_rx_cnt);
}

1180 1181
static const char *
il4965_get_fh_string(int cmd)
1182 1183
{
	switch (cmd) {
1184 1185 1186 1187 1188 1189 1190 1191 1192
		IL_CMD(FH49_RSCSR_CHNL0_STTS_WPTR_REG);
		IL_CMD(FH49_RSCSR_CHNL0_RBDCB_BASE_REG);
		IL_CMD(FH49_RSCSR_CHNL0_WPTR);
		IL_CMD(FH49_MEM_RCSR_CHNL0_CONFIG_REG);
		IL_CMD(FH49_MEM_RSSR_SHARED_CTRL_REG);
		IL_CMD(FH49_MEM_RSSR_RX_STATUS_REG);
		IL_CMD(FH49_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV);
		IL_CMD(FH49_TSSR_TX_STATUS_REG);
		IL_CMD(FH49_TSSR_TX_ERROR_REG);
1193 1194 1195 1196 1197
	default:
		return "UNKNOWN";
	}
}

1198 1199
int
il4965_dump_fh(struct il_priv *il, char **buf, bool display)
1200 1201 1202 1203 1204 1205 1206
{
	int i;
#ifdef CONFIG_IWLEGACY_DEBUG
	int pos = 0;
	size_t bufsz = 0;
#endif
	static const u32 fh_tbl[] = {
1207 1208 1209 1210 1211 1212 1213 1214 1215
		FH49_RSCSR_CHNL0_STTS_WPTR_REG,
		FH49_RSCSR_CHNL0_RBDCB_BASE_REG,
		FH49_RSCSR_CHNL0_WPTR,
		FH49_MEM_RCSR_CHNL0_CONFIG_REG,
		FH49_MEM_RSSR_SHARED_CTRL_REG,
		FH49_MEM_RSSR_RX_STATUS_REG,
		FH49_MEM_RSSR_RX_ENABLE_ERR_IRQ2DRV,
		FH49_TSSR_TX_STATUS_REG,
		FH49_TSSR_TX_ERROR_REG
1216 1217 1218 1219 1220 1221 1222
	};
#ifdef CONFIG_IWLEGACY_DEBUG
	if (display) {
		bufsz = ARRAY_SIZE(fh_tbl) * 48 + 40;
		*buf = kmalloc(bufsz, GFP_KERNEL);
		if (!*buf)
			return -ENOMEM;
1223 1224
		pos +=
		    scnprintf(*buf + pos, bufsz - pos, "FH register values:\n");
1225
		for (i = 0; i < ARRAY_SIZE(fh_tbl); i++) {
1226 1227 1228
			pos +=
			    scnprintf(*buf + pos, bufsz - pos,
				      "  %34s: 0X%08x\n",
S
Stanislaw Gruszka 已提交
1229 1230
				      il4965_get_fh_string(fh_tbl[i]),
				      il_rd(il, fh_tbl[i]));
1231 1232 1233 1234 1235
		}
		return pos;
	}
#endif
	IL_ERR("FH register values:\n");
1236 1237 1238
	for (i = 0; i < ARRAY_SIZE(fh_tbl); i++) {
		IL_ERR("  %34s: 0X%08x\n", il4965_get_fh_string(fh_tbl[i]),
		       il_rd(il, fh_tbl[i]));
1239 1240 1241
	}
	return 0;
}
1242

1243 1244
void
il4965_hdl_missed_beacon(struct il_priv *il, struct il_rx_buf *rxb)
1245 1246 1247 1248 1249 1250 1251
{
	struct il_rx_pkt *pkt = rxb_addr(rxb);
	struct il_missed_beacon_notif *missed_beacon;

	missed_beacon = &pkt->u.missed_beacon;
	if (le32_to_cpu(missed_beacon->consecutive_missed_beacons) >
	    il->missed_beacon_threshold) {
1252 1253 1254 1255 1256
		D_CALIB("missed bcn cnsq %d totl %d rcd %d expctd %d\n",
			le32_to_cpu(missed_beacon->consecutive_missed_beacons),
			le32_to_cpu(missed_beacon->total_missed_becons),
			le32_to_cpu(missed_beacon->num_recvd_beacons),
			le32_to_cpu(missed_beacon->num_expected_beacons));
S
Stanislaw Gruszka 已提交
1257
		if (!test_bit(S_SCANNING, &il->status))
1258 1259 1260 1261 1262 1263 1264
			il4965_init_sensitivity(il);
	}
}

/* Calculate noise level, based on measurements during network silence just
 *   before arriving beacon.  This measurement can be done only if we know
 *   exactly when to expect beacons, therefore only when we're associated. */
1265 1266
static void
il4965_rx_calc_noise(struct il_priv *il)
1267 1268 1269 1270 1271 1272 1273 1274 1275
{
	struct stats_rx_non_phy *rx_info;
	int num_active_rx = 0;
	int total_silence = 0;
	int bcn_silence_a, bcn_silence_b, bcn_silence_c;
	int last_rx_noise;

	rx_info = &(il->_4965.stats.rx.general);
	bcn_silence_a =
1276
	    le32_to_cpu(rx_info->beacon_silence_rssi_a) & IN_BAND_FILTER;
1277
	bcn_silence_b =
1278
	    le32_to_cpu(rx_info->beacon_silence_rssi_b) & IN_BAND_FILTER;
1279
	bcn_silence_c =
1280
	    le32_to_cpu(rx_info->beacon_silence_rssi_c) & IN_BAND_FILTER;
1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300

	if (bcn_silence_a) {
		total_silence += bcn_silence_a;
		num_active_rx++;
	}
	if (bcn_silence_b) {
		total_silence += bcn_silence_b;
		num_active_rx++;
	}
	if (bcn_silence_c) {
		total_silence += bcn_silence_c;
		num_active_rx++;
	}

	/* Average among active antennas */
	if (num_active_rx)
		last_rx_noise = (total_silence / num_active_rx) - 107;
	else
		last_rx_noise = IL_NOISE_MEAS_NOT_AVAILABLE;

1301 1302
	D_CALIB("inband silence a %u, b %u, c %u, dBm %d\n", bcn_silence_a,
		bcn_silence_b, bcn_silence_c, last_rx_noise);
1303 1304 1305 1306 1307 1308 1309 1310
}

#ifdef CONFIG_IWLEGACY_DEBUGFS
/*
 *  based on the assumption of all stats counter are in DWORD
 *  FIXME: This function is for debugging, do not deal with
 *  the case of counters roll-over.
 */
1311 1312
static void
il4965_accumulative_stats(struct il_priv *il, __le32 * stats)
1313 1314 1315 1316 1317 1318 1319 1320
{
	int i, size;
	__le32 *prev_stats;
	u32 *accum_stats;
	u32 *delta, *max_delta;
	struct stats_general_common *general, *accum_general;
	struct stats_tx *tx, *accum_tx;

S
Stanislaw Gruszka 已提交
1321 1322
	prev_stats = (__le32 *) &il->_4965.stats;
	accum_stats = (u32 *) &il->_4965.accum_stats;
1323 1324 1325 1326 1327
	size = sizeof(struct il_notif_stats);
	general = &il->_4965.stats.general.common;
	accum_general = &il->_4965.accum_stats.general.common;
	tx = &il->_4965.stats.tx;
	accum_tx = &il->_4965.accum_stats.tx;
S
Stanislaw Gruszka 已提交
1328 1329
	delta = (u32 *) &il->_4965.delta_stats;
	max_delta = (u32 *) &il->_4965.max_delta;
1330 1331

	for (i = sizeof(__le32); i < size;
1332 1333 1334
	     i +=
	     sizeof(__le32), stats++, prev_stats++, delta++, max_delta++,
	     accum_stats++) {
1335
		if (le32_to_cpu(*stats) > le32_to_cpu(*prev_stats)) {
1336 1337
			*delta =
			    (le32_to_cpu(*stats) - le32_to_cpu(*prev_stats));
1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351
			*accum_stats += *delta;
			if (*delta > *max_delta)
				*max_delta = *delta;
		}
	}

	/* reset accumulative stats for "no-counter" type stats */
	accum_general->temperature = general->temperature;
	accum_general->ttl_timestamp = general->ttl_timestamp;
}
#endif

#define REG_RECALIB_PERIOD (60)

1352 1353
void
il4965_hdl_stats(struct il_priv *il, struct il_rx_buf *rxb)
1354 1355 1356 1357
{
	int change;
	struct il_rx_pkt *pkt = rxb_addr(rxb);

1358 1359 1360 1361 1362 1363 1364 1365 1366
	D_RX("Statistics notification received (%d vs %d).\n",
	     (int)sizeof(struct il_notif_stats),
	     le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK);

	change =
	    ((il->_4965.stats.general.common.temperature !=
	      pkt->u.stats.general.common.temperature) ||
	     ((il->_4965.stats.flag & STATS_REPLY_FLG_HT40_MODE_MSK) !=
	      (pkt->u.stats.flag & STATS_REPLY_FLG_HT40_MODE_MSK)));
1367
#ifdef CONFIG_IWLEGACY_DEBUGFS
S
Stanislaw Gruszka 已提交
1368
	il4965_accumulative_stats(il, (__le32 *) &pkt->u.stats);
1369 1370 1371
#endif

	/* TODO: reading some of stats is unneeded */
1372
	memcpy(&il->_4965.stats, &pkt->u.stats, sizeof(il->_4965.stats));
1373

S
Stanislaw Gruszka 已提交
1374
	set_bit(S_STATS, &il->status);
1375 1376 1377 1378 1379

	/* Reschedule the stats timer to occur in
	 * REG_RECALIB_PERIOD seconds to ensure we get a
	 * thermal update even if the uCode doesn't give
	 * us one */
1380 1381
	mod_timer(&il->stats_periodic,
		  jiffies + msecs_to_jiffies(REG_RECALIB_PERIOD * 1000));
1382

S
Stanislaw Gruszka 已提交
1383
	if (unlikely(!test_bit(S_SCANNING, &il->status)) &&
1384
	    (pkt->hdr.cmd == N_STATS)) {
1385 1386 1387 1388 1389 1390 1391
		il4965_rx_calc_noise(il);
		queue_work(il->workqueue, &il->run_time_calib_work);
	}
	if (il->cfg->ops->lib->temp_ops.temperature && change)
		il->cfg->ops->lib->temp_ops.temperature(il);
}

1392 1393
void
il4965_hdl_c_stats(struct il_priv *il, struct il_rx_buf *rxb)
1394 1395 1396
{
	struct il_rx_pkt *pkt = rxb_addr(rxb);

S
Stanislaw Gruszka 已提交
1397
	if (le32_to_cpu(pkt->u.stats.flag) & UCODE_STATS_CLEAR_MSK) {
1398 1399
#ifdef CONFIG_IWLEGACY_DEBUGFS
		memset(&il->_4965.accum_stats, 0,
1400
		       sizeof(struct il_notif_stats));
1401
		memset(&il->_4965.delta_stats, 0,
1402 1403
		       sizeof(struct il_notif_stats));
		memset(&il->_4965.max_delta, 0, sizeof(struct il_notif_stats));
1404 1405 1406
#endif
		D_RX("Statistics have been cleared\n");
	}
1407
	il4965_hdl_stats(il, rxb);
1408 1409
}

1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432

/*
 * mac80211 queues, ACs, hardware queues, FIFOs.
 *
 * Cf. http://wireless.kernel.org/en/developers/Documentation/mac80211/queues
 *
 * Mac80211 uses the following numbers, which we get as from it
 * by way of skb_get_queue_mapping(skb):
 *
 *     VO      0
 *     VI      1
 *     BE      2
 *     BK      3
 *
 *
 * Regular (not A-MPDU) frames are put into hardware queues corresponding
 * to the FIFOs, see comments in iwl-prph.h. Aggregated frames get their
 * own queue per aggregation session (RA/TID combination), such queues are
 * set up to map into FIFOs too, for which we need an AC->FIFO mapping. In
 * order to map frames to the right queue, we also need an AC->hw queue
 * mapping. This is implemented here.
 *
 * Due to the way hw queues are set up (by the hw specific modules like
1433
 * 4965.c), the AC->hw queue mapping is the identity
1434 1435 1436
 * mapping.
 */

1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447
static const u8 tid_to_ac[] = {
	IEEE80211_AC_BE,
	IEEE80211_AC_BK,
	IEEE80211_AC_BK,
	IEEE80211_AC_BE,
	IEEE80211_AC_VI,
	IEEE80211_AC_VI,
	IEEE80211_AC_VO,
	IEEE80211_AC_VO
};

1448 1449
static inline int
il4965_get_ac_from_tid(u16 tid)
1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
{
	if (likely(tid < ARRAY_SIZE(tid_to_ac)))
		return tid_to_ac[tid];

	/* no support for TIDs 8-15 yet */
	return -EINVAL;
}

static inline int
il4965_get_fifo_from_tid(struct il_rxon_context *ctx, u16 tid)
{
	if (likely(tid < ARRAY_SIZE(tid_to_ac)))
		return ctx->ac_to_fifo[tid_to_ac[tid]];

	/* no support for TIDs 8-15 yet */
	return -EINVAL;
}

/*
1469
 * handle build C_TX command notification.
1470
 */
1471 1472 1473 1474 1475
static void
il4965_tx_cmd_build_basic(struct il_priv *il, struct sk_buff *skb,
			  struct il_tx_cmd *tx_cmd,
			  struct ieee80211_tx_info *info,
			  struct ieee80211_hdr *hdr, u8 std_id)
1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524
{
	__le16 fc = hdr->frame_control;
	__le32 tx_flags = tx_cmd->tx_flags;

	tx_cmd->stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
	if (!(info->flags & IEEE80211_TX_CTL_NO_ACK)) {
		tx_flags |= TX_CMD_FLG_ACK_MSK;
		if (ieee80211_is_mgmt(fc))
			tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
		if (ieee80211_is_probe_resp(fc) &&
		    !(le16_to_cpu(hdr->seq_ctrl) & 0xf))
			tx_flags |= TX_CMD_FLG_TSF_MSK;
	} else {
		tx_flags &= (~TX_CMD_FLG_ACK_MSK);
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
	}

	if (ieee80211_is_back_req(fc))
		tx_flags |= TX_CMD_FLG_ACK_MSK | TX_CMD_FLG_IMM_BA_RSP_MASK;

	tx_cmd->sta_id = std_id;
	if (ieee80211_has_morefrags(fc))
		tx_flags |= TX_CMD_FLG_MORE_FRAG_MSK;

	if (ieee80211_is_data_qos(fc)) {
		u8 *qc = ieee80211_get_qos_ctl(hdr);
		tx_cmd->tid_tspec = qc[0] & 0xf;
		tx_flags &= ~TX_CMD_FLG_SEQ_CTL_MSK;
	} else {
		tx_flags |= TX_CMD_FLG_SEQ_CTL_MSK;
	}

	il_tx_cmd_protection(il, info, fc, &tx_flags);

	tx_flags &= ~(TX_CMD_FLG_ANT_SEL_MSK);
	if (ieee80211_is_mgmt(fc)) {
		if (ieee80211_is_assoc_req(fc) || ieee80211_is_reassoc_req(fc))
			tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(3);
		else
			tx_cmd->timeout.pm_frame_timeout = cpu_to_le16(2);
	} else {
		tx_cmd->timeout.pm_frame_timeout = 0;
	}

	tx_cmd->driver_txop = 0;
	tx_cmd->tx_flags = tx_flags;
	tx_cmd->next_frame_len = 0;
}

1525 1526 1527
static void
il4965_tx_cmd_build_rate(struct il_priv *il, struct il_tx_cmd *tx_cmd,
			 struct ieee80211_tx_info *info, __le16 fc)
1528
{
1529
	const u8 rts_retry_limit = 60;
1530 1531 1532 1533 1534
	u32 rate_flags;
	int rate_idx;
	u8 data_retry_limit;
	u8 rate_plcp;

1535
	/* Set retry limit on DATA packets and Probe Responses */
1536 1537 1538 1539 1540 1541
	if (ieee80211_is_probe_resp(fc))
		data_retry_limit = 3;
	else
		data_retry_limit = IL4965_DEFAULT_TX_RETRY;
	tx_cmd->data_retry_limit = data_retry_limit;
	/* Set retry limit on RTS packets */
1542
	tx_cmd->rts_retry_limit = min(data_retry_limit, rts_retry_limit);
1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558

	/* DATA packets will use the uCode station table for rate/antenna
	 * selection */
	if (ieee80211_is_data(fc)) {
		tx_cmd->initial_rate_idx = 0;
		tx_cmd->tx_flags |= TX_CMD_FLG_STA_RATE_MSK;
		return;
	}

	/**
	 * If the current TX rate stored in mac80211 has the MCS bit set, it's
	 * not really a TX rate.  Thus, we use the lowest supported rate for
	 * this band.  Also use the lowest supported rate if the stored rate
	 * idx is invalid.
	 */
	rate_idx = info->control.rates[0].idx;
1559 1560 1561 1562 1563
	if ((info->control.rates[0].flags & IEEE80211_TX_RC_MCS) || rate_idx < 0
	    || rate_idx > RATE_COUNT_LEGACY)
		rate_idx =
		    rate_lowest_index(&il->bands[info->band],
				      info->control.sta);
1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576
	/* For 5 GHZ band, remap mac80211 rate indices into driver indices */
	if (info->band == IEEE80211_BAND_5GHZ)
		rate_idx += IL_FIRST_OFDM_RATE;
	/* Get PLCP rate for tx_cmd->rate_n_flags */
	rate_plcp = il_rates[rate_idx].plcp;
	/* Zero out flags for this packet */
	rate_flags = 0;

	/* Set CCK flag as needed */
	if (rate_idx >= IL_FIRST_CCK_RATE && rate_idx <= IL_LAST_CCK_RATE)
		rate_flags |= RATE_MCS_CCK_MSK;

	/* Set up antennas */
1577
	il4965_toggle_tx_ant(il, &il->mgmt_tx_ant, il->hw_params.valid_tx_ant);
1578
	rate_flags |= BIT(il->mgmt_tx_ant) << RATE_MCS_ANT_POS;
1579 1580

	/* Set the rate in the TX cmd */
1581
	tx_cmd->rate_n_flags = cpu_to_le32(rate_plcp | rate_flags);
1582 1583
}

1584 1585 1586 1587
static void
il4965_tx_cmd_build_hwcrypto(struct il_priv *il, struct ieee80211_tx_info *info,
			     struct il_tx_cmd *tx_cmd, struct sk_buff *skb_frag,
			     int sta_id)
1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609
{
	struct ieee80211_key_conf *keyconf = info->control.hw_key;

	switch (keyconf->cipher) {
	case WLAN_CIPHER_SUITE_CCMP:
		tx_cmd->sec_ctl = TX_CMD_SEC_CCM;
		memcpy(tx_cmd->key, keyconf->key, keyconf->keylen);
		if (info->flags & IEEE80211_TX_CTL_AMPDU)
			tx_cmd->tx_flags |= TX_CMD_FLG_AGG_CCMP_MSK;
		D_TX("tx_cmd with AES hwcrypto\n");
		break;

	case WLAN_CIPHER_SUITE_TKIP:
		tx_cmd->sec_ctl = TX_CMD_SEC_TKIP;
		ieee80211_get_tkip_p2k(keyconf, skb_frag, tx_cmd->key);
		D_TX("tx_cmd with tkip hwcrypto\n");
		break;

	case WLAN_CIPHER_SUITE_WEP104:
		tx_cmd->sec_ctl |= TX_CMD_SEC_KEY128;
		/* fall through */
	case WLAN_CIPHER_SUITE_WEP40:
1610 1611 1612
		tx_cmd->sec_ctl |=
		    (TX_CMD_SEC_WEP | (keyconf->keyidx & TX_CMD_SEC_MSK) <<
		     TX_CMD_SEC_SHIFT);
1613 1614 1615

		memcpy(&tx_cmd->key[3], keyconf->key, keyconf->keylen);

1616 1617
		D_TX("Configuring packet for WEP encryption " "with key %d\n",
		     keyconf->keyidx);
1618 1619 1620 1621 1622 1623 1624 1625 1626
		break;

	default:
		IL_ERR("Unknown encode cipher %x\n", keyconf->cipher);
		break;
	}
}

/*
1627
 * start C_TX command process
1628
 */
1629 1630
int
il4965_tx_skb(struct il_priv *il, struct sk_buff *skb)
1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677 1678 1679 1680
{
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
	struct ieee80211_sta *sta = info->control.sta;
	struct il_station_priv *sta_priv = NULL;
	struct il_tx_queue *txq;
	struct il_queue *q;
	struct il_device_cmd *out_cmd;
	struct il_cmd_meta *out_meta;
	struct il_tx_cmd *tx_cmd;
	struct il_rxon_context *ctx = &il->ctx;
	int txq_id;
	dma_addr_t phys_addr;
	dma_addr_t txcmd_phys;
	dma_addr_t scratch_phys;
	u16 len, firstlen, secondlen;
	u16 seq_number = 0;
	__le16 fc;
	u8 hdr_len;
	u8 sta_id;
	u8 wait_write_ptr = 0;
	u8 tid = 0;
	u8 *qc = NULL;
	unsigned long flags;
	bool is_agg = false;

	if (info->control.vif)
		ctx = il_rxon_ctx_from_vif(info->control.vif);

	spin_lock_irqsave(&il->lock, flags);
	if (il_is_rfkill(il)) {
		D_DROP("Dropping - RF KILL\n");
		goto drop_unlock;
	}

	fc = hdr->frame_control;

#ifdef CONFIG_IWLEGACY_DEBUG
	if (ieee80211_is_auth(fc))
		D_TX("Sending AUTH frame\n");
	else if (ieee80211_is_assoc_req(fc))
		D_TX("Sending ASSOC frame\n");
	else if (ieee80211_is_reassoc_req(fc))
		D_TX("Sending REASSOC frame\n");
#endif

	hdr_len = ieee80211_hdrlen(fc);

	/* For management frames use broadcast id to do not break aggregation */
	if (!ieee80211_is_data(fc))
1681
		sta_id = il->hw_params.bcast_id;
1682 1683 1684 1685 1686
	else {
		/* Find idx into station table for destination station */
		sta_id = il_sta_id_or_broadcast(il, ctx, info->control.sta);

		if (sta_id == IL_INVALID_STATION) {
1687
			D_DROP("Dropping - INVALID STATION: %pM\n", hdr->addr1);
1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720
			goto drop_unlock;
		}
	}

	D_TX("station Id %d\n", sta_id);

	if (sta)
		sta_priv = (void *)sta->drv_priv;

	if (sta_priv && sta_priv->asleep &&
	    (info->flags & IEEE80211_TX_CTL_POLL_RESPONSE)) {
		/*
		 * This sends an asynchronous command to the device,
		 * but we can rely on it being processed before the
		 * next frame is processed -- and the next frame to
		 * this station is the one that will consume this
		 * counter.
		 * For now set the counter to just 1 since we do not
		 * support uAPSD yet.
		 */
		il4965_sta_modify_sleep_tx_count(il, sta_id, 1);
	}

	/*
	 * Send this frame after DTIM -- there's a special queue
	 * reserved for this for contexts that support AP mode.
	 */
	if (info->flags & IEEE80211_TX_CTL_SEND_AFTER_DTIM) {
		txq_id = ctx->mcast_queue;
		/*
		 * The microcode will clear the more data
		 * bit in the last frame it transmits.
		 */
1721
		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_MOREDATA);
1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736
	} else
		txq_id = ctx->ac_to_queue[skb_get_queue_mapping(skb)];

	/* irqs already disabled/saved above when locking il->lock */
	spin_lock(&il->sta_lock);

	if (ieee80211_is_data_qos(fc)) {
		qc = ieee80211_get_qos_ctl(hdr);
		tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
		if (WARN_ON_ONCE(tid >= MAX_TID_COUNT)) {
			spin_unlock(&il->sta_lock);
			goto drop_unlock;
		}
		seq_number = il->stations[sta_id].tid[tid].seq_number;
		seq_number &= IEEE80211_SCTL_SEQ;
1737 1738
		hdr->seq_ctrl =
		    hdr->seq_ctrl & cpu_to_le16(IEEE80211_SCTL_FRAG);
1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782
		hdr->seq_ctrl |= cpu_to_le16(seq_number);
		seq_number += 0x10;
		/* aggregation is on for this <sta,tid> */
		if (info->flags & IEEE80211_TX_CTL_AMPDU &&
		    il->stations[sta_id].tid[tid].agg.state == IL_AGG_ON) {
			txq_id = il->stations[sta_id].tid[tid].agg.txq_id;
			is_agg = true;
		}
	}

	txq = &il->txq[txq_id];
	q = &txq->q;

	if (unlikely(il_queue_space(q) < q->high_mark)) {
		spin_unlock(&il->sta_lock);
		goto drop_unlock;
	}

	if (ieee80211_is_data_qos(fc)) {
		il->stations[sta_id].tid[tid].tfds_in_queue++;
		if (!ieee80211_has_morefrags(fc))
			il->stations[sta_id].tid[tid].seq_number = seq_number;
	}

	spin_unlock(&il->sta_lock);

	/* Set up driver data for this TFD */
	memset(&(txq->txb[q->write_ptr]), 0, sizeof(struct il_tx_info));
	txq->txb[q->write_ptr].skb = skb;
	txq->txb[q->write_ptr].ctx = ctx;

	/* Set up first empty entry in queue's array of Tx/cmd buffers */
	out_cmd = txq->cmd[q->write_ptr];
	out_meta = &txq->meta[q->write_ptr];
	tx_cmd = &out_cmd->cmd.tx;
	memset(&out_cmd->hdr, 0, sizeof(out_cmd->hdr));
	memset(tx_cmd, 0, sizeof(struct il_tx_cmd));

	/*
	 * Set up the Tx-command (not MAC!) header.
	 * Store the chosen Tx queue and TFD idx within the sequence field;
	 * after Tx, uCode's Tx response will return this value so driver can
	 * locate the frame within the tx queue and do post-tx processing.
	 */
1783
	out_cmd->hdr.cmd = C_TX;
1784 1785 1786
	out_cmd->hdr.sequence =
	    cpu_to_le16((u16)
			(QUEUE_TO_SEQ(txq_id) | IDX_TO_SEQ(q->write_ptr)));
1787 1788 1789 1790 1791

	/* Copy MAC header from skb into command buffer */
	memcpy(tx_cmd->hdr, hdr, hdr_len);

	/* Total # bytes to be transmitted */
1792
	len = (u16) skb->len;
1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813
	tx_cmd->len = cpu_to_le16(len);

	if (info->control.hw_key)
		il4965_tx_cmd_build_hwcrypto(il, info, tx_cmd, skb, sta_id);

	/* TODO need this for burst mode later on */
	il4965_tx_cmd_build_basic(il, skb, tx_cmd, info, hdr, sta_id);
	il_dbg_log_tx_data_frame(il, len, hdr);

	il4965_tx_cmd_build_rate(il, tx_cmd, info, fc);

	il_update_stats(il, true, fc, len);
	/*
	 * Use the first empty entry in this queue's command buffer array
	 * to contain the Tx command and MAC header concatenated together
	 * (payload data will be in another buffer).
	 * Size of this varies, due to varying MAC header length.
	 * If end is not dword aligned, we'll have 2 extra bytes at the end
	 * of the MAC header (device reads on dword boundaries).
	 * We'll tell device about this padding later.
	 */
1814
	len = sizeof(struct il_tx_cmd) + sizeof(struct il_cmd_header) + hdr_len;
1815 1816 1817 1818 1819 1820 1821 1822
	firstlen = (len + 3) & ~3;

	/* Tell NIC about any 2-byte padding after MAC header */
	if (firstlen != len)
		tx_cmd->tx_flags |= TX_CMD_FLG_MH_PAD_MSK;

	/* Physical address of this Tx command's header (not MAC header!),
	 * within command buffer array. */
1823 1824 1825
	txcmd_phys =
	    pci_map_single(il->pci_dev, &out_cmd->hdr, firstlen,
			   PCI_DMA_BIDIRECTIONAL);
1826 1827 1828 1829
	dma_unmap_addr_set(out_meta, mapping, txcmd_phys);
	dma_unmap_len_set(out_meta, len, firstlen);
	/* Add buffer containing Tx command and MAC(!) header to TFD's
	 * first entry */
1830 1831
	il->cfg->ops->lib->txq_attach_buf_to_tfd(il, txq, txcmd_phys, firstlen,
						 1, 0);
1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843

	if (!ieee80211_has_morefrags(hdr->frame_control)) {
		txq->need_update = 1;
	} else {
		wait_write_ptr = 1;
		txq->need_update = 0;
	}

	/* Set up TFD's 2nd entry to point directly to remainder of skb,
	 * if any (802.11 null frames have no payload). */
	secondlen = skb->len - hdr_len;
	if (secondlen > 0) {
1844 1845 1846 1847 1848
		phys_addr =
		    pci_map_single(il->pci_dev, skb->data + hdr_len, secondlen,
				   PCI_DMA_TODEVICE);
		il->cfg->ops->lib->txq_attach_buf_to_tfd(il, txq, phys_addr,
							 secondlen, 0, 0);
1849 1850
	}

1851 1852 1853
	scratch_phys =
	    txcmd_phys + sizeof(struct il_cmd_header) +
	    offsetof(struct il_tx_cmd, scratch);
1854 1855

	/* take back ownership of DMA buffer to enable update */
1856 1857
	pci_dma_sync_single_for_cpu(il->pci_dev, txcmd_phys, firstlen,
				    PCI_DMA_BIDIRECTIONAL);
1858 1859 1860
	tx_cmd->dram_lsb_ptr = cpu_to_le32(scratch_phys);
	tx_cmd->dram_msb_ptr = il_get_dma_hi_addr(scratch_phys);

1861
	D_TX("sequence nr = 0X%x\n", le16_to_cpu(out_cmd->hdr.sequence));
1862
	D_TX("tx_flags = 0X%x\n", le32_to_cpu(tx_cmd->tx_flags));
1863 1864
	il_print_hex_dump(il, IL_DL_TX, (u8 *) tx_cmd, sizeof(*tx_cmd));
	il_print_hex_dump(il, IL_DL_TX, (u8 *) tx_cmd->hdr, hdr_len);
1865 1866 1867 1868

	/* Set up entry for this TFD in Tx byte-count array */
	if (info->flags & IEEE80211_TX_CTL_AMPDU)
		il->cfg->ops->lib->txq_update_byte_cnt_tbl(il, txq,
1869 1870
							   le16_to_cpu(tx_cmd->
								       len));
1871

1872 1873
	pci_dma_sync_single_for_device(il->pci_dev, txcmd_phys, firstlen,
				       PCI_DMA_BIDIRECTIONAL);
1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914

	/* Tell device the write idx *just past* this latest filled TFD */
	q->write_ptr = il_queue_inc_wrap(q->write_ptr, q->n_bd);
	il_txq_update_write_ptr(il, txq);
	spin_unlock_irqrestore(&il->lock, flags);

	/*
	 * At this point the frame is "transmitted" successfully
	 * and we will get a TX status notification eventually,
	 * regardless of the value of ret. "ret" only indicates
	 * whether or not we should update the write pointer.
	 */

	/*
	 * Avoid atomic ops if it isn't an associated client.
	 * Also, if this is a packet for aggregation, don't
	 * increase the counter because the ucode will stop
	 * aggregation queues when their respective station
	 * goes to sleep.
	 */
	if (sta_priv && sta_priv->client && !is_agg)
		atomic_inc(&sta_priv->pending_frames);

	if (il_queue_space(q) < q->high_mark && il->mac80211_registered) {
		if (wait_write_ptr) {
			spin_lock_irqsave(&il->lock, flags);
			txq->need_update = 1;
			il_txq_update_write_ptr(il, txq);
			spin_unlock_irqrestore(&il->lock, flags);
		} else {
			il_stop_queue(il, txq);
		}
	}

	return 0;

drop_unlock:
	spin_unlock_irqrestore(&il->lock, flags);
	return -1;
}

1915 1916
static inline int
il4965_alloc_dma_ptr(struct il_priv *il, struct il_dma_ptr *ptr, size_t size)
1917
{
1918 1919
	ptr->addr =
	    dma_alloc_coherent(&il->pci_dev->dev, size, &ptr->dma, GFP_KERNEL);
1920 1921 1922 1923 1924 1925
	if (!ptr->addr)
		return -ENOMEM;
	ptr->size = size;
	return 0;
}

1926 1927
static inline void
il4965_free_dma_ptr(struct il_priv *il, struct il_dma_ptr *ptr)
1928 1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940
{
	if (unlikely(!ptr->addr))
		return;

	dma_free_coherent(&il->pci_dev->dev, ptr->size, ptr->addr, ptr->dma);
	memset(ptr, 0, sizeof(*ptr));
}

/**
 * il4965_hw_txq_ctx_free - Free TXQ Context
 *
 * Destroy all TX DMA queues and structures
 */
1941 1942
void
il4965_hw_txq_ctx_free(struct il_priv *il)
1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965 1966 1967 1968
{
	int txq_id;

	/* Tx queues */
	if (il->txq) {
		for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
			if (txq_id == il->cmd_queue)
				il_cmd_queue_free(il);
			else
				il_tx_queue_free(il, txq_id);
	}
	il4965_free_dma_ptr(il, &il->kw);

	il4965_free_dma_ptr(il, &il->scd_bc_tbls);

	/* free tx queue structure */
	il_txq_mem(il);
}

/**
 * il4965_txq_ctx_alloc - allocate TX queue context
 * Allocate all Tx DMA structures and initialize them
 *
 * @param il
 * @return error code
 */
1969 1970
int
il4965_txq_ctx_alloc(struct il_priv *il)
1971 1972 1973 1974 1975 1976 1977 1978
{
	int ret;
	int txq_id, slots_num;
	unsigned long flags;

	/* Free all tx/cmd queues and keep-warm buffer */
	il4965_hw_txq_ctx_free(il);

1979 1980 1981
	ret =
	    il4965_alloc_dma_ptr(il, &il->scd_bc_tbls,
				 il->hw_params.scd_bc_tbls_size);
1982 1983 1984 1985 1986 1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003
	if (ret) {
		IL_ERR("Scheduler BC Table allocation failed\n");
		goto error_bc_tbls;
	}
	/* Alloc keep-warm buffer */
	ret = il4965_alloc_dma_ptr(il, &il->kw, IL_KW_SIZE);
	if (ret) {
		IL_ERR("Keep Warm allocation failed\n");
		goto error_kw;
	}

	/* allocate tx queue structure */
	ret = il_alloc_txq_mem(il);
	if (ret)
		goto error;

	spin_lock_irqsave(&il->lock, flags);

	/* Turn off all Tx DMA fifos */
	il4965_txq_set_sched(il, 0);

	/* Tell NIC where to find the "keep warm" buffer */
2004
	il_wr(il, FH49_KW_MEM_ADDR_REG, il->kw.dma >> 4);
2005 2006 2007 2008 2009

	spin_unlock_irqrestore(&il->lock, flags);

	/* Alloc and init all Tx queues, including the command queue (#4/#9) */
	for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++) {
2010 2011 2012 2013
		slots_num =
		    (txq_id ==
		     il->cmd_queue) ? TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
		ret = il_tx_queue_init(il, &il->txq[txq_id], slots_num, txq_id);
2014 2015 2016 2017 2018 2019 2020 2021
		if (ret) {
			IL_ERR("Tx %d queue init failed\n", txq_id);
			goto error;
		}
	}

	return ret;

2022
error:
2023 2024
	il4965_hw_txq_ctx_free(il);
	il4965_free_dma_ptr(il, &il->kw);
2025
error_kw:
2026
	il4965_free_dma_ptr(il, &il->scd_bc_tbls);
2027
error_bc_tbls:
2028 2029 2030
	return ret;
}

2031 2032
void
il4965_txq_ctx_reset(struct il_priv *il)
2033 2034 2035 2036 2037 2038 2039 2040 2041 2042
{
	int txq_id, slots_num;
	unsigned long flags;

	spin_lock_irqsave(&il->lock, flags);

	/* Turn off all Tx DMA fifos */
	il4965_txq_set_sched(il, 0);

	/* Tell NIC where to find the "keep warm" buffer */
2043
	il_wr(il, FH49_KW_MEM_ADDR_REG, il->kw.dma >> 4);
2044 2045 2046 2047 2048

	spin_unlock_irqrestore(&il->lock, flags);

	/* Alloc and init all Tx queues, including the command queue (#4) */
	for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++) {
2049 2050 2051
		slots_num =
		    txq_id == il->cmd_queue ? TFD_CMD_SLOTS : TFD_TX_CMD_SLOTS;
		il_tx_queue_reset(il, &il->txq[txq_id], slots_num, txq_id);
2052 2053 2054 2055 2056 2057
	}
}

/**
 * il4965_txq_ctx_stop - Stop all Tx DMA channels
 */
2058 2059
void
il4965_txq_ctx_stop(struct il_priv *il)
2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070
{
	int ch, txq_id;
	unsigned long flags;

	/* Turn off all Tx DMA fifos */
	spin_lock_irqsave(&il->lock, flags);

	il4965_txq_set_sched(il, 0);

	/* Stop each Tx DMA channel, and wait for it to be idle */
	for (ch = 0; ch < il->hw_params.dma_chnl_num; ch++) {
2071 2072 2073 2074
		il_wr(il, FH49_TCSR_CHNL_TX_CONFIG_REG(ch), 0x0);
		if (il_poll_bit
		    (il, FH49_TSSR_TX_STATUS_REG,
		     FH49_TSSR_TX_STATUS_REG_MSK_CHNL_IDLE(ch), 1000))
2075
			IL_ERR("Failing on timeout while stopping"
S
Stanislaw Gruszka 已提交
2076 2077
			       " DMA channel %d [0x%08x]", ch,
			       il_rd(il, FH49_TSSR_TX_STATUS_REG));
2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097
	}
	spin_unlock_irqrestore(&il->lock, flags);

	if (!il->txq)
		return;

	/* Unmap DMA from host system and free skb's */
	for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
		if (txq_id == il->cmd_queue)
			il_cmd_queue_unmap(il);
		else
			il_tx_queue_unmap(il, txq_id);
}

/*
 * Find first available (lowest unused) Tx Queue, mark it "active".
 * Called only when finding queue for aggregation.
 * Should never return anything < 7, because they should already
 * be in use as EDCA AC (0-3), Command (4), reserved (5, 6)
 */
2098 2099
static int
il4965_txq_ctx_activate_free(struct il_priv *il)
2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111
{
	int txq_id;

	for (txq_id = 0; txq_id < il->hw_params.max_txq_num; txq_id++)
		if (!test_and_set_bit(txq_id, &il->txq_ctx_active_msk))
			return txq_id;
	return -1;
}

/**
 * il4965_tx_queue_stop_scheduler - Stop queue, but keep configuration
 */
2112 2113
static void
il4965_tx_queue_stop_scheduler(struct il_priv *il, u16 txq_id)
2114 2115 2116
{
	/* Simply stop the queue, but don't change any configuration;
	 * the SCD_ACT_EN bit is the write-enable mask for the ACTIVE bit. */
2117
	il_wr_prph(il, IL49_SCD_QUEUE_STATUS_BITS(txq_id),
S
Stanislaw Gruszka 已提交
2118 2119
		   (0 << IL49_SCD_QUEUE_STTS_REG_POS_ACTIVE) |
		   (1 << IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACT_EN));
2120 2121 2122 2123 2124
}

/**
 * il4965_tx_queue_set_q2ratid - Map unique receiver/tid combination to a queue
 */
2125 2126
static int
il4965_tx_queue_set_q2ratid(struct il_priv *il, u16 ra_tid, u16 txq_id)
2127 2128 2129 2130 2131 2132 2133
{
	u32 tbl_dw_addr;
	u32 tbl_dw;
	u16 scd_q2ratid;

	scd_q2ratid = ra_tid & IL_SCD_QUEUE_RA_TID_MAP_RATID_MSK;

2134 2135
	tbl_dw_addr =
	    il->scd_base_addr + IL49_SCD_TRANSLATE_TBL_OFFSET_QUEUE(txq_id);
2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154

	tbl_dw = il_read_targ_mem(il, tbl_dw_addr);

	if (txq_id & 0x1)
		tbl_dw = (scd_q2ratid << 16) | (tbl_dw & 0x0000FFFF);
	else
		tbl_dw = scd_q2ratid | (tbl_dw & 0xFFFF0000);

	il_write_targ_mem(il, tbl_dw_addr, tbl_dw);

	return 0;
}

/**
 * il4965_tx_queue_agg_enable - Set up & enable aggregation for selected queue
 *
 * NOTE:  txq_id must be greater than IL49_FIRST_AMPDU_QUEUE,
 *        i.e. it must be one of the higher queues used for aggregation
 */
2155 2156 2157
static int
il4965_txq_agg_enable(struct il_priv *il, int txq_id, int tx_fifo, int sta_id,
		      int tid, u16 ssn_idx)
2158 2159 2160 2161 2162 2163 2164
{
	unsigned long flags;
	u16 ra_tid;
	int ret;

	if ((IL49_FIRST_AMPDU_QUEUE > txq_id) ||
	    (IL49_FIRST_AMPDU_QUEUE +
2165 2166
	     il->cfg->base_params->num_of_ampdu_queues <= txq_id)) {
		IL_WARN("queue number out of range: %d, must be %d to %d\n",
2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198
			txq_id, IL49_FIRST_AMPDU_QUEUE,
			IL49_FIRST_AMPDU_QUEUE +
			il->cfg->base_params->num_of_ampdu_queues - 1);
		return -EINVAL;
	}

	ra_tid = BUILD_RAxTID(sta_id, tid);

	/* Modify device's station table to Tx this TID */
	ret = il4965_sta_tx_modify_enable_tid(il, sta_id, tid);
	if (ret)
		return ret;

	spin_lock_irqsave(&il->lock, flags);

	/* Stop this Tx queue before configuring it */
	il4965_tx_queue_stop_scheduler(il, txq_id);

	/* Map receiver-address / traffic-ID to this queue */
	il4965_tx_queue_set_q2ratid(il, ra_tid, txq_id);

	/* Set this queue as a chain-building queue */
	il_set_bits_prph(il, IL49_SCD_QUEUECHAIN_SEL, (1 << txq_id));

	/* Place first TFD at idx corresponding to start sequence number.
	 * Assumes that ssn_idx is valid (!= 0xFFF) */
	il->txq[txq_id].q.read_ptr = (ssn_idx & 0xff);
	il->txq[txq_id].q.write_ptr = (ssn_idx & 0xff);
	il4965_set_wr_ptrs(il, txq_id, ssn_idx);

	/* Set up Tx win size and frame limit for this queue */
	il_write_targ_mem(il,
2199 2200 2201 2202
			  il->scd_base_addr +
			  IL49_SCD_CONTEXT_QUEUE_OFFSET(txq_id),
			  (SCD_WIN_SIZE << IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_POS)
			  & IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK);
2203

2204 2205 2206 2207 2208 2209
	il_write_targ_mem(il,
			  il->scd_base_addr +
			  IL49_SCD_CONTEXT_QUEUE_OFFSET(txq_id) + sizeof(u32),
			  (SCD_FRAME_LIMIT <<
			   IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS) &
			  IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK);
2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220

	il_set_bits_prph(il, IL49_SCD_INTERRUPT_MASK, (1 << txq_id));

	/* Set up Status area in SRAM, map to Tx DMA/FIFO, activate the queue */
	il4965_tx_queue_set_status(il, &il->txq[txq_id], tx_fifo, 1);

	spin_unlock_irqrestore(&il->lock, flags);

	return 0;
}

2221 2222 2223
int
il4965_tx_agg_start(struct il_priv *il, struct ieee80211_vif *vif,
		    struct ieee80211_sta *sta, u16 tid, u16 * ssn)
2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235
{
	int sta_id;
	int tx_fifo;
	int txq_id;
	int ret;
	unsigned long flags;
	struct il_tid_data *tid_data;

	tx_fifo = il4965_get_fifo_from_tid(il_rxon_ctx_from_vif(vif), tid);
	if (unlikely(tx_fifo < 0))
		return tx_fifo;

2236
	D_HT("%s on ra = %pM tid = %d\n", __func__, sta->addr, tid);
2237 2238 2239 2240 2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260

	sta_id = il_sta_id(sta);
	if (sta_id == IL_INVALID_STATION) {
		IL_ERR("Start AGG on invalid station\n");
		return -ENXIO;
	}
	if (unlikely(tid >= MAX_TID_COUNT))
		return -EINVAL;

	if (il->stations[sta_id].tid[tid].agg.state != IL_AGG_OFF) {
		IL_ERR("Start AGG when state is not IL_AGG_OFF !\n");
		return -ENXIO;
	}

	txq_id = il4965_txq_ctx_activate_free(il);
	if (txq_id == -1) {
		IL_ERR("No free aggregation queue available\n");
		return -ENXIO;
	}

	spin_lock_irqsave(&il->sta_lock, flags);
	tid_data = &il->stations[sta_id].tid[tid];
	*ssn = SEQ_TO_SN(tid_data->seq_number);
	tid_data->agg.txq_id = txq_id;
2261
	il_set_swq_id(&il->txq[txq_id], il4965_get_ac_from_tid(tid), txq_id);
2262 2263
	spin_unlock_irqrestore(&il->sta_lock, flags);

2264
	ret = il4965_txq_agg_enable(il, txq_id, tx_fifo, sta_id, tid, *ssn);
2265 2266 2267 2268 2269 2270 2271 2272 2273 2274
	if (ret)
		return ret;

	spin_lock_irqsave(&il->sta_lock, flags);
	tid_data = &il->stations[sta_id].tid[tid];
	if (tid_data->tfds_in_queue == 0) {
		D_HT("HW queue is empty\n");
		tid_data->agg.state = IL_AGG_ON;
		ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
	} else {
2275 2276
		D_HT("HW queue is NOT empty: %d packets in HW queue\n",
		     tid_data->tfds_in_queue);
2277 2278 2279 2280 2281 2282 2283 2284 2285 2286
		tid_data->agg.state = IL_EMPTYING_HW_QUEUE_ADDBA;
	}
	spin_unlock_irqrestore(&il->sta_lock, flags);
	return ret;
}

/**
 * txq_id must be greater than IL49_FIRST_AMPDU_QUEUE
 * il->lock must be held by the caller
 */
2287 2288
static int
il4965_txq_agg_disable(struct il_priv *il, u16 txq_id, u16 ssn_idx, u8 tx_fifo)
2289 2290 2291
{
	if ((IL49_FIRST_AMPDU_QUEUE > txq_id) ||
	    (IL49_FIRST_AMPDU_QUEUE +
2292 2293
	     il->cfg->base_params->num_of_ampdu_queues <= txq_id)) {
		IL_WARN("queue number out of range: %d, must be %d to %d\n",
2294 2295 2296 2297 2298 2299 2300 2301
			txq_id, IL49_FIRST_AMPDU_QUEUE,
			IL49_FIRST_AMPDU_QUEUE +
			il->cfg->base_params->num_of_ampdu_queues - 1);
		return -EINVAL;
	}

	il4965_tx_queue_stop_scheduler(il, txq_id);

2302
	il_clear_bits_prph(il, IL49_SCD_QUEUECHAIN_SEL, (1 << txq_id));
2303 2304 2305 2306 2307 2308

	il->txq[txq_id].q.read_ptr = (ssn_idx & 0xff);
	il->txq[txq_id].q.write_ptr = (ssn_idx & 0xff);
	/* supposes that ssn_idx is valid (!= 0xFFF) */
	il4965_set_wr_ptrs(il, txq_id, ssn_idx);

2309
	il_clear_bits_prph(il, IL49_SCD_INTERRUPT_MASK, (1 << txq_id));
2310 2311 2312 2313 2314 2315
	il_txq_ctx_deactivate(il, txq_id);
	il4965_tx_queue_set_status(il, &il->txq[txq_id], tx_fifo, 0);

	return 0;
}

2316 2317 2318
int
il4965_tx_agg_stop(struct il_priv *il, struct ieee80211_vif *vif,
		   struct ieee80211_sta *sta, u16 tid)
2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364
{
	int tx_fifo_id, txq_id, sta_id, ssn;
	struct il_tid_data *tid_data;
	int write_ptr, read_ptr;
	unsigned long flags;

	tx_fifo_id = il4965_get_fifo_from_tid(il_rxon_ctx_from_vif(vif), tid);
	if (unlikely(tx_fifo_id < 0))
		return tx_fifo_id;

	sta_id = il_sta_id(sta);

	if (sta_id == IL_INVALID_STATION) {
		IL_ERR("Invalid station for AGG tid %d\n", tid);
		return -ENXIO;
	}

	spin_lock_irqsave(&il->sta_lock, flags);

	tid_data = &il->stations[sta_id].tid[tid];
	ssn = (tid_data->seq_number & IEEE80211_SCTL_SEQ) >> 4;
	txq_id = tid_data->agg.txq_id;

	switch (il->stations[sta_id].tid[tid].agg.state) {
	case IL_EMPTYING_HW_QUEUE_ADDBA:
		/*
		 * This can happen if the peer stops aggregation
		 * again before we've had a chance to drain the
		 * queue we selected previously, i.e. before the
		 * session was really started completely.
		 */
		D_HT("AGG stop before setup done\n");
		goto turn_off;
	case IL_AGG_ON:
		break;
	default:
		IL_WARN("Stopping AGG while state not ON or starting\n");
	}

	write_ptr = il->txq[txq_id].q.write_ptr;
	read_ptr = il->txq[txq_id].q.read_ptr;

	/* The queue is not empty */
	if (write_ptr != read_ptr) {
		D_HT("Stopping a non empty AGG HW QUEUE\n");
		il->stations[sta_id].tid[tid].agg.state =
2365
		    IL_EMPTYING_HW_QUEUE_DELBA;
2366 2367 2368 2369 2370
		spin_unlock_irqrestore(&il->sta_lock, flags);
		return 0;
	}

	D_HT("HW queue is empty\n");
2371
turn_off:
2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392
	il->stations[sta_id].tid[tid].agg.state = IL_AGG_OFF;

	/* do not restore/save irqs */
	spin_unlock(&il->sta_lock);
	spin_lock(&il->lock);

	/*
	 * the only reason this call can fail is queue number out of range,
	 * which can happen if uCode is reloaded and all the station
	 * information are lost. if it is outside the range, there is no need
	 * to deactivate the uCode queue, just return "success" to allow
	 *  mac80211 to clean up it own data.
	 */
	il4965_txq_agg_disable(il, txq_id, ssn, tx_fifo_id);
	spin_unlock_irqrestore(&il->lock, flags);

	ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);

	return 0;
}

2393 2394
int
il4965_txq_check_empty(struct il_priv *il, int sta_id, u8 tid, int txq_id)
2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408
{
	struct il_queue *q = &il->txq[txq_id].q;
	u8 *addr = il->stations[sta_id].sta.sta.addr;
	struct il_tid_data *tid_data = &il->stations[sta_id].tid[tid];
	struct il_rxon_context *ctx;

	ctx = &il->ctx;

	lockdep_assert_held(&il->sta_lock);

	switch (il->stations[sta_id].tid[tid].agg.state) {
	case IL_EMPTYING_HW_QUEUE_DELBA:
		/* We are reclaiming the last packet of the */
		/* aggregated HW queue */
2409
		if (txq_id == tid_data->agg.txq_id &&
2410 2411 2412
		    q->read_ptr == q->write_ptr) {
			u16 ssn = SEQ_TO_SN(tid_data->seq_number);
			int tx_fifo = il4965_get_fifo_from_tid(ctx, tid);
2413
			D_HT("HW queue empty: continue DELBA flow\n");
2414 2415 2416 2417 2418 2419 2420 2421
			il4965_txq_agg_disable(il, txq_id, ssn, tx_fifo);
			tid_data->agg.state = IL_AGG_OFF;
			ieee80211_stop_tx_ba_cb_irqsafe(ctx->vif, addr, tid);
		}
		break;
	case IL_EMPTYING_HW_QUEUE_ADDBA:
		/* We are reclaiming the last packet of the queue */
		if (tid_data->tfds_in_queue == 0) {
2422
			D_HT("HW queue empty: continue ADDBA flow\n");
2423 2424 2425 2426 2427 2428 2429 2430 2431
			tid_data->agg.state = IL_AGG_ON;
			ieee80211_start_tx_ba_cb_irqsafe(ctx->vif, addr, tid);
		}
		break;
	}

	return 0;
}

2432 2433
static void
il4965_non_agg_tx_status(struct il_priv *il, struct il_rxon_context *ctx,
S
Stanislaw Gruszka 已提交
2434
			 const u8 *addr1)
2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450 2451
{
	struct ieee80211_sta *sta;
	struct il_station_priv *sta_priv;

	rcu_read_lock();
	sta = ieee80211_find_sta(ctx->vif, addr1);
	if (sta) {
		sta_priv = (void *)sta->drv_priv;
		/* avoid atomic ops if this isn't a client */
		if (sta_priv->client &&
		    atomic_dec_return(&sta_priv->pending_frames) == 0)
			ieee80211_sta_block_awake(il->hw, sta, false);
	}
	rcu_read_unlock();
}

static void
2452
il4965_tx_status(struct il_priv *il, struct il_tx_info *tx_info, bool is_agg)
2453
{
2454
	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)tx_info->skb->data;
2455 2456 2457 2458 2459 2460 2461

	if (!is_agg)
		il4965_non_agg_tx_status(il, tx_info->ctx, hdr->addr1);

	ieee80211_tx_status_irqsafe(il->hw, tx_info->skb);
}

2462 2463
int
il4965_tx_queue_reclaim(struct il_priv *il, int txq_id, int idx)
2464 2465 2466 2467 2468 2469 2470 2471 2472
{
	struct il_tx_queue *txq = &il->txq[txq_id];
	struct il_queue *q = &txq->q;
	struct il_tx_info *tx_info;
	int nfreed = 0;
	struct ieee80211_hdr *hdr;

	if (idx >= q->n_bd || il_queue_used(q, idx) == 0) {
		IL_ERR("Read idx for DMA queue txq id (%d), idx %d, "
2473 2474
		       "is out of range [0-%d] %d %d.\n", txq_id, idx, q->n_bd,
		       q->write_ptr, q->read_ptr);
2475 2476 2477
		return 0;
	}

2478
	for (idx = il_queue_inc_wrap(idx, q->n_bd); q->read_ptr != idx;
2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504
	     q->read_ptr = il_queue_inc_wrap(q->read_ptr, q->n_bd)) {

		tx_info = &txq->txb[txq->q.read_ptr];

		if (WARN_ON_ONCE(tx_info->skb == NULL))
			continue;

		hdr = (struct ieee80211_hdr *)tx_info->skb->data;
		if (ieee80211_is_data_qos(hdr->frame_control))
			nfreed++;

		il4965_tx_status(il, tx_info,
				 txq_id >= IL4965_FIRST_AMPDU_QUEUE);
		tx_info->skb = NULL;

		il->cfg->ops->lib->txq_free_tfd(il, txq);
	}
	return nfreed;
}

/**
 * il4965_tx_status_reply_compressed_ba - Update tx status from block-ack
 *
 * Go through block-ack's bitmap of ACK'd frames, update driver's record of
 * ACK vs. not.  This gets sent to mac80211, then to rate scaling algo.
 */
2505 2506 2507
static int
il4965_tx_status_reply_compressed_ba(struct il_priv *il, struct il_ht_agg *agg,
				     struct il_compressed_ba_resp *ba_resp)
2508 2509 2510 2511 2512 2513 2514 2515
{
	int i, sh, ack;
	u16 seq_ctl = le16_to_cpu(ba_resp->seq_ctl);
	u16 scd_flow = le16_to_cpu(ba_resp->scd_flow);
	int successes = 0;
	struct ieee80211_tx_info *info;
	u64 bitmap, sent_bitmap;

2516
	if (unlikely(!agg->wait_for_ba)) {
2517 2518 2519 2520 2521 2522 2523
		if (unlikely(ba_resp->bitmap))
			IL_ERR("Received BA when not expected\n");
		return -EINVAL;
	}

	/* Mark that the expected block-ack response arrived */
	agg->wait_for_ba = 0;
2524
	D_TX_REPLY("BA %d %d\n", agg->start_idx, ba_resp->seq_ctl);
2525 2526 2527

	/* Calculate shift to align block-ack bits with our Tx win bits */
	sh = agg->start_idx - SEQ_TO_IDX(seq_ctl >> 4);
2528
	if (sh < 0)		/* tbw something is wrong with indices */
2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548
		sh += 0x100;

	if (agg->frame_count > (64 - sh)) {
		D_TX_REPLY("more frames than bitmap size");
		return -1;
	}

	/* don't use 64-bit values for now */
	bitmap = le64_to_cpu(ba_resp->bitmap) >> sh;

	/* check for success or failure according to the
	 * transmitted bitmap and block-ack bitmap */
	sent_bitmap = bitmap & agg->bitmap;

	/* For each frame attempted in aggregation,
	 * update driver's record of tx frame's status. */
	i = 0;
	while (sent_bitmap) {
		ack = sent_bitmap & 1ULL;
		successes += ack;
2549 2550
		D_TX_REPLY("%s ON i=%d idx=%d raw=%d\n", ack ? "ACK" : "NACK",
			   i, (agg->start_idx + i) & 0xff, agg->start_idx + i);
2551 2552 2553 2554
		sent_bitmap >>= 1;
		++i;
	}

2555
	D_TX_REPLY("Bitmap %llx\n", (unsigned long long)bitmap);
2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570

	info = IEEE80211_SKB_CB(il->txq[scd_flow].txb[agg->start_idx].skb);
	memset(&info->status, 0, sizeof(info->status));
	info->flags |= IEEE80211_TX_STAT_ACK;
	info->flags |= IEEE80211_TX_STAT_AMPDU;
	info->status.ampdu_ack_len = successes;
	info->status.ampdu_len = agg->frame_count;
	il4965_hwrate_to_tx_control(il, agg->rate_n_flags, info);

	return 0;
}

/**
 * translate ucode response to mac80211 tx status control values
 */
2571 2572 2573
void
il4965_hwrate_to_tx_control(struct il_priv *il, u32 rate_n_flags,
			    struct ieee80211_tx_info *info)
2574 2575 2576 2577
{
	struct ieee80211_tx_rate *r = &info->control.rates[0];

	info->antenna_sel_tx =
2578
	    ((rate_n_flags & RATE_MCS_ANT_ABC_MSK) >> RATE_MCS_ANT_POS);
2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592
	if (rate_n_flags & RATE_MCS_HT_MSK)
		r->flags |= IEEE80211_TX_RC_MCS;
	if (rate_n_flags & RATE_MCS_GF_MSK)
		r->flags |= IEEE80211_TX_RC_GREEN_FIELD;
	if (rate_n_flags & RATE_MCS_HT40_MSK)
		r->flags |= IEEE80211_TX_RC_40_MHZ_WIDTH;
	if (rate_n_flags & RATE_MCS_DUP_MSK)
		r->flags |= IEEE80211_TX_RC_DUP_DATA;
	if (rate_n_flags & RATE_MCS_SGI_MSK)
		r->flags |= IEEE80211_TX_RC_SHORT_GI;
	r->idx = il4965_hwrate_to_mac80211_idx(rate_n_flags, info->band);
}

/**
S
Stanislaw Gruszka 已提交
2593
 * il4965_hdl_compressed_ba - Handler for N_COMPRESSED_BA
2594 2595 2596 2597
 *
 * Handles block-acknowledge notification from device, which reports success
 * of frames sent via aggregation.
 */
2598 2599
void
il4965_hdl_compressed_ba(struct il_priv *il, struct il_rx_buf *rxb)
2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617
{
	struct il_rx_pkt *pkt = rxb_addr(rxb);
	struct il_compressed_ba_resp *ba_resp = &pkt->u.compressed_ba;
	struct il_tx_queue *txq = NULL;
	struct il_ht_agg *agg;
	int idx;
	int sta_id;
	int tid;
	unsigned long flags;

	/* "flow" corresponds to Tx queue */
	u16 scd_flow = le16_to_cpu(ba_resp->scd_flow);

	/* "ssn" is start of block-ack Tx win, corresponds to idx
	 * (in Tx queue's circular buffer) of first TFD/frame in win */
	u16 ba_resp_scd_ssn = le16_to_cpu(ba_resp->scd_ssn);

	if (scd_flow >= il->hw_params.max_txq_num) {
2618
		IL_ERR("BUG_ON scd_flow is bigger than number of queues\n");
2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632
		return;
	}

	txq = &il->txq[scd_flow];
	sta_id = ba_resp->sta_id;
	tid = ba_resp->tid;
	agg = &il->stations[sta_id].tid[tid].agg;
	if (unlikely(agg->txq_id != scd_flow)) {
		/*
		 * FIXME: this is a uCode bug which need to be addressed,
		 * log the information and return for now!
		 * since it is possible happen very often and in order
		 * not to fill the syslog, don't enable the logging by default
		 */
2633 2634
		D_TX_REPLY("BA scd_flow %d does not match txq_id %d\n",
			   scd_flow, agg->txq_id);
2635 2636 2637 2638 2639 2640 2641 2642
		return;
	}

	/* Find idx just before block-ack win */
	idx = il_queue_dec_wrap(ba_resp_scd_ssn & 0xff, txq->q.n_bd);

	spin_lock_irqsave(&il->sta_lock, flags);

2643
	D_TX_REPLY("N_COMPRESSED_BA [%d] Received from %pM, " "sta_id = %d\n",
S
Stanislaw Gruszka 已提交
2644
		   agg->wait_for_ba, (u8 *) &ba_resp->sta_addr_lo32,
2645 2646 2647 2648 2649 2650 2651
		   ba_resp->sta_id);
	D_TX_REPLY("TID = %d, SeqCtl = %d, bitmap = 0x%llx," "scd_flow = "
		   "%d, scd_ssn = %d\n", ba_resp->tid, ba_resp->seq_ctl,
		   (unsigned long long)le64_to_cpu(ba_resp->bitmap),
		   ba_resp->scd_flow, ba_resp->scd_ssn);
	D_TX_REPLY("DAT start_idx = %d, bitmap = 0x%llx\n", agg->start_idx,
		   (unsigned long long)agg->bitmap);
2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675

	/* Update driver's record of ACK vs. not for each frame in win */
	il4965_tx_status_reply_compressed_ba(il, agg, ba_resp);

	/* Release all TFDs before the SSN, i.e. all TFDs in front of
	 * block-ack win (we assume that they've been successfully
	 * transmitted ... if not, it's too late anyway). */
	if (txq->q.read_ptr != (ba_resp_scd_ssn & 0xff)) {
		/* calculate mac80211 ampdu sw queue to wake */
		int freed = il4965_tx_queue_reclaim(il, scd_flow, idx);
		il4965_free_tfds_in_queue(il, sta_id, tid, freed);

		if (il_queue_space(&txq->q) > txq->q.low_mark &&
		    il->mac80211_registered &&
		    agg->state != IL_EMPTYING_HW_QUEUE_DELBA)
			il_wake_queue(il, txq);

		il4965_txq_check_empty(il, sta_id, tid, scd_flow);
	}

	spin_unlock_irqrestore(&il->sta_lock, flags);
}

#ifdef CONFIG_IWLEGACY_DEBUG
2676 2677
const char *
il4965_get_tx_fail_reason(u32 status)
2678 2679 2680 2681 2682 2683 2684
{
#define TX_STATUS_FAIL(x) case TX_STATUS_FAIL_ ## x: return #x
#define TX_STATUS_POSTPONE(x) case TX_STATUS_POSTPONE_ ## x: return #x

	switch (status & TX_STATUS_MSK) {
	case TX_STATUS_SUCCESS:
		return "SUCCESS";
2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705
		TX_STATUS_POSTPONE(DELAY);
		TX_STATUS_POSTPONE(FEW_BYTES);
		TX_STATUS_POSTPONE(QUIET_PERIOD);
		TX_STATUS_POSTPONE(CALC_TTAK);
		TX_STATUS_FAIL(INTERNAL_CROSSED_RETRY);
		TX_STATUS_FAIL(SHORT_LIMIT);
		TX_STATUS_FAIL(LONG_LIMIT);
		TX_STATUS_FAIL(FIFO_UNDERRUN);
		TX_STATUS_FAIL(DRAIN_FLOW);
		TX_STATUS_FAIL(RFKILL_FLUSH);
		TX_STATUS_FAIL(LIFE_EXPIRE);
		TX_STATUS_FAIL(DEST_PS);
		TX_STATUS_FAIL(HOST_ABORTED);
		TX_STATUS_FAIL(BT_RETRY);
		TX_STATUS_FAIL(STA_INVALID);
		TX_STATUS_FAIL(FRAG_DROPPED);
		TX_STATUS_FAIL(TID_DISABLE);
		TX_STATUS_FAIL(FIFO_FLUSHED);
		TX_STATUS_FAIL(INSUFFICIENT_CF_POLL);
		TX_STATUS_FAIL(PASSIVE_NO_RX);
		TX_STATUS_FAIL(NO_BEACON_ON_RADAR);
2706 2707 2708 2709 2710 2711 2712 2713 2714
	}

	return "UNKNOWN";

#undef TX_STATUS_FAIL
#undef TX_STATUS_POSTPONE
}
#endif /* CONFIG_IWLEGACY_DEBUG */

2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737
static struct il_link_quality_cmd *
il4965_sta_alloc_lq(struct il_priv *il, u8 sta_id)
{
	int i, r;
	struct il_link_quality_cmd *link_cmd;
	u32 rate_flags = 0;
	__le32 rate_n_flags;

	link_cmd = kzalloc(sizeof(struct il_link_quality_cmd), GFP_KERNEL);
	if (!link_cmd) {
		IL_ERR("Unable to allocate memory for LQ cmd.\n");
		return NULL;
	}
	/* Set up the rate scaling to start at selected rate, fall back
	 * all the way down to 1M in IEEE order, and then spin on 1M */
	if (il->band == IEEE80211_BAND_5GHZ)
		r = RATE_6M_IDX;
	else
		r = RATE_1M_IDX;

	if (r >= IL_FIRST_CCK_RATE && r <= IL_LAST_CCK_RATE)
		rate_flags |= RATE_MCS_CCK_MSK;

2738 2739 2740
	rate_flags |=
	    il4965_first_antenna(il->hw_params.
				 valid_tx_ant) << RATE_MCS_ANT_POS;
2741
	rate_n_flags = cpu_to_le32(il_rates[r].plcp | rate_flags);
2742 2743 2744 2745
	for (i = 0; i < LINK_QUAL_MAX_RETRY_NUM; i++)
		link_cmd->rs_table[i].rate_n_flags = rate_n_flags;

	link_cmd->general_params.single_stream_ant_msk =
2746
	    il4965_first_antenna(il->hw_params.valid_tx_ant);
2747 2748

	link_cmd->general_params.dual_stream_ant_msk =
2749 2750
	    il->hw_params.valid_tx_ant & ~il4965_first_antenna(il->hw_params.
							       valid_tx_ant);
2751 2752 2753 2754
	if (!link_cmd->general_params.dual_stream_ant_msk) {
		link_cmd->general_params.dual_stream_ant_msk = ANT_AB;
	} else if (il4965_num_of_ant(il->hw_params.valid_tx_ant) == 2) {
		link_cmd->general_params.dual_stream_ant_msk =
2755
		    il->hw_params.valid_tx_ant;
2756 2757 2758 2759
	}

	link_cmd->agg_params.agg_dis_start_th = LINK_QUAL_AGG_DISABLE_START_DEF;
	link_cmd->agg_params.agg_time_limit =
2760
	    cpu_to_le16(LINK_QUAL_AGG_TIME_LIMIT_DEF);
2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773

	link_cmd->sta_id = sta_id;

	return link_cmd;
}

/*
 * il4965_add_bssid_station - Add the special IBSS BSSID station
 *
 * Function sleeps.
 */
int
il4965_add_bssid_station(struct il_priv *il, struct il_rxon_context *ctx,
S
Stanislaw Gruszka 已提交
2774
			 const u8 *addr, u8 *sta_id_r)
2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799
{
	int ret;
	u8 sta_id;
	struct il_link_quality_cmd *link_cmd;
	unsigned long flags;

	if (sta_id_r)
		*sta_id_r = IL_INVALID_STATION;

	ret = il_add_station_common(il, ctx, addr, 0, NULL, &sta_id);
	if (ret) {
		IL_ERR("Unable to add station %pM\n", addr);
		return ret;
	}

	if (sta_id_r)
		*sta_id_r = sta_id;

	spin_lock_irqsave(&il->sta_lock, flags);
	il->stations[sta_id].used |= IL_STA_LOCAL;
	spin_unlock_irqrestore(&il->sta_lock, flags);

	/* Set up default rate scaling table in device's station table */
	link_cmd = il4965_sta_alloc_lq(il, sta_id);
	if (!link_cmd) {
2800 2801
		IL_ERR("Unable to initialize rate scaling for station %pM.\n",
		       addr);
2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815
		return -ENOMEM;
	}

	ret = il_send_lq_cmd(il, ctx, link_cmd, CMD_SYNC, true);
	if (ret)
		IL_ERR("Link quality command failed (%d)\n", ret);

	spin_lock_irqsave(&il->sta_lock, flags);
	il->stations[sta_id].lq = link_cmd;
	spin_unlock_irqrestore(&il->sta_lock, flags);

	return 0;
}

2816 2817 2818
static int
il4965_static_wepkey_cmd(struct il_priv *il, struct il_rxon_context *ctx,
			 bool send_if_empty)
2819 2820 2821 2822 2823
{
	int i, not_empty = 0;
	u8 buff[sizeof(struct il_wep_cmd) +
		sizeof(struct il_wep_key) * WEP_KEYS_MAX];
	struct il_wep_cmd *wep_cmd = (struct il_wep_cmd *)buff;
2824
	size_t cmd_size = sizeof(struct il_wep_cmd);
2825
	struct il_host_cmd cmd = {
2826
		.id = C_WEPKEY,
2827 2828 2829 2830 2831 2832
		.data = wep_cmd,
		.flags = CMD_SYNC,
	};

	might_sleep();

2833 2834
	memset(wep_cmd, 0,
	       cmd_size + (sizeof(struct il_wep_key) * WEP_KEYS_MAX));
2835

2836
	for (i = 0; i < WEP_KEYS_MAX; i++) {
2837 2838 2839 2840 2841 2842 2843 2844 2845 2846
		wep_cmd->key[i].key_idx = i;
		if (ctx->wep_keys[i].key_size) {
			wep_cmd->key[i].key_offset = i;
			not_empty = 1;
		} else {
			wep_cmd->key[i].key_offset = WEP_INVALID_OFFSET;
		}

		wep_cmd->key[i].key_size = ctx->wep_keys[i].key_size;
		memcpy(&wep_cmd->key[i].key[3], ctx->wep_keys[i].key,
2847
		       ctx->wep_keys[i].key_size);
2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862
	}

	wep_cmd->global_key_type = WEP_KEY_WEP_TYPE;
	wep_cmd->num_keys = WEP_KEYS_MAX;

	cmd_size += sizeof(struct il_wep_key) * WEP_KEYS_MAX;

	cmd.len = cmd_size;

	if (not_empty || send_if_empty)
		return il_send_cmd(il, &cmd);
	else
		return 0;
}

2863 2864
int
il4965_restore_default_wep_keys(struct il_priv *il, struct il_rxon_context *ctx)
2865 2866 2867 2868 2869 2870
{
	lockdep_assert_held(&il->mutex);

	return il4965_static_wepkey_cmd(il, ctx, false);
}

2871 2872 2873
int
il4965_remove_default_wep_key(struct il_priv *il, struct il_rxon_context *ctx,
			      struct ieee80211_key_conf *keyconf)
2874 2875 2876 2877 2878
{
	int ret;

	lockdep_assert_held(&il->mutex);

2879
	D_WEP("Removing default WEP key: idx=%d\n", keyconf->keyidx);
2880 2881 2882

	memset(&ctx->wep_keys[keyconf->keyidx], 0, sizeof(ctx->wep_keys[0]));
	if (il_is_rfkill(il)) {
2883
		D_WEP("Not sending C_WEPKEY command due to RFKILL.\n");
2884 2885 2886 2887
		/* but keys in device are clear anyway so return success */
		return 0;
	}
	ret = il4965_static_wepkey_cmd(il, ctx, 1);
2888
	D_WEP("Remove default WEP key: idx=%d ret=%d\n", keyconf->keyidx, ret);
2889 2890 2891 2892

	return ret;
}

2893 2894 2895
int
il4965_set_default_wep_key(struct il_priv *il, struct il_rxon_context *ctx,
			   struct ieee80211_key_conf *keyconf)
2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908
{
	int ret;

	lockdep_assert_held(&il->mutex);

	if (keyconf->keylen != WEP_KEY_LEN_128 &&
	    keyconf->keylen != WEP_KEY_LEN_64) {
		D_WEP("Bad WEP key length %d\n", keyconf->keylen);
		return -EINVAL;
	}

	keyconf->flags &= ~IEEE80211_KEY_FLAG_GENERATE_IV;
	keyconf->hw_key_idx = HW_KEY_DEFAULT;
2909
	il->stations[IL_AP_ID].keyinfo.cipher = keyconf->cipher;
2910 2911 2912

	ctx->wep_keys[keyconf->keyidx].key_size = keyconf->keylen;
	memcpy(&ctx->wep_keys[keyconf->keyidx].key, &keyconf->key,
2913
	       keyconf->keylen);
2914 2915

	ret = il4965_static_wepkey_cmd(il, ctx, false);
2916 2917
	D_WEP("Set default WEP key: len=%d idx=%d ret=%d\n", keyconf->keylen,
	      keyconf->keyidx, ret);
2918 2919 2920 2921

	return ret;
}

2922 2923 2924
static int
il4965_set_wep_dynamic_key_info(struct il_priv *il, struct il_rxon_context *ctx,
				struct ieee80211_key_conf *keyconf, u8 sta_id)
2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940
{
	unsigned long flags;
	__le16 key_flags = 0;
	struct il_addsta_cmd sta_cmd;

	lockdep_assert_held(&il->mutex);

	keyconf->flags &= ~IEEE80211_KEY_FLAG_GENERATE_IV;

	key_flags |= (STA_KEY_FLG_WEP | STA_KEY_FLG_MAP_KEY_MSK);
	key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
	key_flags &= ~STA_KEY_FLG_INVALID;

	if (keyconf->keylen == WEP_KEY_LEN_128)
		key_flags |= STA_KEY_FLG_KEY_SIZE_MSK;

2941
	if (sta_id == il->hw_params.bcast_id)
2942 2943 2944 2945 2946 2947 2948 2949
		key_flags |= STA_KEY_MULTICAST_MSK;

	spin_lock_irqsave(&il->sta_lock, flags);

	il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
	il->stations[sta_id].keyinfo.keylen = keyconf->keylen;
	il->stations[sta_id].keyinfo.keyidx = keyconf->keyidx;

2950
	memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
2951

2952 2953
	memcpy(&il->stations[sta_id].sta.key.key[3], keyconf->key,
	       keyconf->keylen);
2954

2955 2956
	if ((il->stations[sta_id].sta.key.
	     key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
2957
		il->stations[sta_id].sta.key.key_offset =
2958
		    il_get_free_ucode_key_idx(il);
2959 2960 2961 2962
	/* else, we are overriding an existing key => no need to allocated room
	 * in uCode. */

	WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
2963
	     "no space for a new key");
2964 2965 2966 2967 2968 2969

	il->stations[sta_id].sta.key.key_flags = key_flags;
	il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;

	memcpy(&sta_cmd, &il->stations[sta_id].sta,
2970
	       sizeof(struct il_addsta_cmd));
2971 2972 2973 2974 2975
	spin_unlock_irqrestore(&il->sta_lock, flags);

	return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
}

2976 2977 2978 2979
static int
il4965_set_ccmp_dynamic_key_info(struct il_priv *il,
				 struct il_rxon_context *ctx,
				 struct ieee80211_key_conf *keyconf, u8 sta_id)
2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990
{
	unsigned long flags;
	__le16 key_flags = 0;
	struct il_addsta_cmd sta_cmd;

	lockdep_assert_held(&il->mutex);

	key_flags |= (STA_KEY_FLG_CCMP | STA_KEY_FLG_MAP_KEY_MSK);
	key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
	key_flags &= ~STA_KEY_FLG_INVALID;

2991
	if (sta_id == il->hw_params.bcast_id)
2992 2993 2994 2995 2996 2997 2998 2999
		key_flags |= STA_KEY_MULTICAST_MSK;

	keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;

	spin_lock_irqsave(&il->sta_lock, flags);
	il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
	il->stations[sta_id].keyinfo.keylen = keyconf->keylen;

3000
	memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, keyconf->keylen);
3001

3002
	memcpy(il->stations[sta_id].sta.key.key, keyconf->key, keyconf->keylen);
3003

3004 3005
	if ((il->stations[sta_id].sta.key.
	     key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
3006
		il->stations[sta_id].sta.key.key_offset =
3007
		    il_get_free_ucode_key_idx(il);
3008 3009 3010 3011
	/* else, we are overriding an existing key => no need to allocated room
	 * in uCode. */

	WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
3012
	     "no space for a new key");
3013 3014 3015 3016 3017 3018

	il->stations[sta_id].sta.key.key_flags = key_flags;
	il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;

	memcpy(&sta_cmd, &il->stations[sta_id].sta,
3019
	       sizeof(struct il_addsta_cmd));
3020 3021 3022 3023 3024
	spin_unlock_irqrestore(&il->sta_lock, flags);

	return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
}

3025 3026 3027 3028
static int
il4965_set_tkip_dynamic_key_info(struct il_priv *il,
				 struct il_rxon_context *ctx,
				 struct ieee80211_key_conf *keyconf, u8 sta_id)
3029 3030 3031 3032 3033 3034 3035 3036 3037
{
	unsigned long flags;
	int ret = 0;
	__le16 key_flags = 0;

	key_flags |= (STA_KEY_FLG_TKIP | STA_KEY_FLG_MAP_KEY_MSK);
	key_flags |= cpu_to_le16(keyconf->keyidx << STA_KEY_FLG_KEYID_POS);
	key_flags &= ~STA_KEY_FLG_INVALID;

3038
	if (sta_id == il->hw_params.bcast_id)
3039 3040 3041 3042 3043 3044 3045 3046 3047 3048
		key_flags |= STA_KEY_MULTICAST_MSK;

	keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
	keyconf->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;

	spin_lock_irqsave(&il->sta_lock, flags);

	il->stations[sta_id].keyinfo.cipher = keyconf->cipher;
	il->stations[sta_id].keyinfo.keylen = 16;

3049 3050
	if ((il->stations[sta_id].sta.key.
	     key_flags & STA_KEY_FLG_ENCRYPT_MSK) == STA_KEY_FLG_NO_ENC)
3051
		il->stations[sta_id].sta.key.key_offset =
3052
		    il_get_free_ucode_key_idx(il);
3053 3054 3055 3056
	/* else, we are overriding an existing key => no need to allocated room
	 * in uCode. */

	WARN(il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET,
3057
	     "no space for a new key");
3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070

	il->stations[sta_id].sta.key.key_flags = key_flags;

	/* This copy is acutally not needed: we get the key with each TX */
	memcpy(il->stations[sta_id].keyinfo.key, keyconf->key, 16);

	memcpy(il->stations[sta_id].sta.key.key, keyconf->key, 16);

	spin_unlock_irqrestore(&il->sta_lock, flags);

	return ret;
}

3071 3072 3073 3074
void
il4965_update_tkip_key(struct il_priv *il, struct il_rxon_context *ctx,
		       struct ieee80211_key_conf *keyconf,
		       struct ieee80211_sta *sta, u32 iv32, u16 * phase1key)
3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095
{
	u8 sta_id;
	unsigned long flags;
	int i;

	if (il_scan_cancel(il)) {
		/* cancel scan failed, just live w/ bad key and rely
		   briefly on SW decryption */
		return;
	}

	sta_id = il_sta_id_or_broadcast(il, ctx, sta);
	if (sta_id == IL_INVALID_STATION)
		return;

	spin_lock_irqsave(&il->sta_lock, flags);

	il->stations[sta_id].sta.key.tkip_rx_tsc_byte2 = (u8) iv32;

	for (i = 0; i < 5; i++)
		il->stations[sta_id].sta.key.tkip_rx_ttak[i] =
3096
		    cpu_to_le16(phase1key[i]);
3097 3098 3099 3100 3101 3102 3103 3104 3105 3106

	il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;

	il_send_add_sta(il, &il->stations[sta_id].sta, CMD_ASYNC);

	spin_unlock_irqrestore(&il->sta_lock, flags);

}

3107 3108 3109
int
il4965_remove_dynamic_key(struct il_priv *il, struct il_rxon_context *ctx,
			  struct ieee80211_key_conf *keyconf, u8 sta_id)
3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122 3123
{
	unsigned long flags;
	u16 key_flags;
	u8 keyidx;
	struct il_addsta_cmd sta_cmd;

	lockdep_assert_held(&il->mutex);

	ctx->key_mapping_keys--;

	spin_lock_irqsave(&il->sta_lock, flags);
	key_flags = le16_to_cpu(il->stations[sta_id].sta.key.key_flags);
	keyidx = (key_flags >> STA_KEY_FLG_KEYID_POS) & 0x3;

3124
	D_WEP("Remove dynamic key: idx=%d sta=%d\n", keyconf->keyidx, sta_id);
3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136

	if (keyconf->keyidx != keyidx) {
		/* We need to remove a key with idx different that the one
		 * in the uCode. This means that the key we need to remove has
		 * been replaced by another one with different idx.
		 * Don't do anything and return ok
		 */
		spin_unlock_irqrestore(&il->sta_lock, flags);
		return 0;
	}

	if (il->stations[sta_id].sta.key.key_offset == WEP_INVALID_OFFSET) {
3137 3138
		IL_WARN("Removing wrong key %d 0x%x\n", keyconf->keyidx,
			key_flags);
3139 3140 3141 3142
		spin_unlock_irqrestore(&il->sta_lock, flags);
		return 0;
	}

3143 3144
	if (!test_and_clear_bit
	    (il->stations[sta_id].sta.key.key_offset, &il->ucode_key_table))
3145
		IL_ERR("idx %d not used in uCode key table.\n",
3146 3147 3148
		       il->stations[sta_id].sta.key.key_offset);
	memset(&il->stations[sta_id].keyinfo, 0, sizeof(struct il_hw_key));
	memset(&il->stations[sta_id].sta.key, 0, sizeof(struct il4965_keyinfo));
3149
	il->stations[sta_id].sta.key.key_flags =
3150
	    STA_KEY_FLG_NO_ENC | STA_KEY_FLG_INVALID;
3151 3152 3153 3154 3155
	il->stations[sta_id].sta.key.key_offset = WEP_INVALID_OFFSET;
	il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_KEY_MASK;
	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;

	if (il_is_rfkill(il)) {
3156 3157
		D_WEP
		    ("Not sending C_ADD_STA command because RFKILL enabled.\n");
3158 3159 3160 3161
		spin_unlock_irqrestore(&il->sta_lock, flags);
		return 0;
	}
	memcpy(&sta_cmd, &il->stations[sta_id].sta,
3162
	       sizeof(struct il_addsta_cmd));
3163 3164 3165 3166 3167
	spin_unlock_irqrestore(&il->sta_lock, flags);

	return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
}

3168 3169 3170
int
il4965_set_dynamic_key(struct il_priv *il, struct il_rxon_context *ctx,
		       struct ieee80211_key_conf *keyconf, u8 sta_id)
3171 3172 3173 3174 3175 3176 3177 3178 3179 3180
{
	int ret;

	lockdep_assert_held(&il->mutex);

	ctx->key_mapping_keys++;
	keyconf->hw_key_idx = HW_KEY_DYNAMIC;

	switch (keyconf->cipher) {
	case WLAN_CIPHER_SUITE_CCMP:
3181 3182
		ret =
		    il4965_set_ccmp_dynamic_key_info(il, ctx, keyconf, sta_id);
3183 3184
		break;
	case WLAN_CIPHER_SUITE_TKIP:
3185 3186
		ret =
		    il4965_set_tkip_dynamic_key_info(il, ctx, keyconf, sta_id);
3187 3188 3189
		break;
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_WEP104:
3190
		ret = il4965_set_wep_dynamic_key_info(il, ctx, keyconf, sta_id);
3191 3192
		break;
	default:
3193 3194
		IL_ERR("Unknown alg: %s cipher = %x\n", __func__,
		       keyconf->cipher);
3195 3196 3197
		ret = -EINVAL;
	}

3198 3199
	D_WEP("Set dynamic key: cipher=%x len=%d idx=%d sta=%d ret=%d\n",
	      keyconf->cipher, keyconf->keylen, keyconf->keyidx, sta_id, ret);
3200 3201 3202 3203 3204 3205 3206 3207 3208 3209 3210

	return ret;
}

/**
 * il4965_alloc_bcast_station - add broadcast station into driver's station table.
 *
 * This adds the broadcast station into the driver's station table
 * and marks it driver active, so that it will be restored to the
 * device at the next best time.
 */
3211 3212
int
il4965_alloc_bcast_station(struct il_priv *il, struct il_rxon_context *ctx)
3213 3214 3215 3216 3217 3218
{
	struct il_link_quality_cmd *link_cmd;
	unsigned long flags;
	u8 sta_id;

	spin_lock_irqsave(&il->sta_lock, flags);
3219
	sta_id = il_prep_station(il, ctx, il_bcast_addr, false, NULL);
3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232
	if (sta_id == IL_INVALID_STATION) {
		IL_ERR("Unable to prepare broadcast station\n");
		spin_unlock_irqrestore(&il->sta_lock, flags);

		return -EINVAL;
	}

	il->stations[sta_id].used |= IL_STA_DRIVER_ACTIVE;
	il->stations[sta_id].used |= IL_STA_BCAST;
	spin_unlock_irqrestore(&il->sta_lock, flags);

	link_cmd = il4965_sta_alloc_lq(il, sta_id);
	if (!link_cmd) {
3233 3234
		IL_ERR
		    ("Unable to initialize rate scaling for bcast station.\n");
3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248 3249 3250
		return -ENOMEM;
	}

	spin_lock_irqsave(&il->sta_lock, flags);
	il->stations[sta_id].lq = link_cmd;
	spin_unlock_irqrestore(&il->sta_lock, flags);

	return 0;
}

/**
 * il4965_update_bcast_station - update broadcast station's LQ command
 *
 * Only used by iwl4965. Placed here to have all bcast station management
 * code together.
 */
3251 3252
static int
il4965_update_bcast_station(struct il_priv *il, struct il_rxon_context *ctx)
3253 3254 3255
{
	unsigned long flags;
	struct il_link_quality_cmd *link_cmd;
3256
	u8 sta_id = il->hw_params.bcast_id;
3257 3258 3259

	link_cmd = il4965_sta_alloc_lq(il, sta_id);
	if (!link_cmd) {
S
Stanislaw Gruszka 已提交
3260
		IL_ERR("Unable to initialize rate scaling for bcast sta.\n");
3261 3262 3263 3264 3265 3266 3267
		return -ENOMEM;
	}

	spin_lock_irqsave(&il->sta_lock, flags);
	if (il->stations[sta_id].lq)
		kfree(il->stations[sta_id].lq);
	else
S
Stanislaw Gruszka 已提交
3268
		D_INFO("Bcast sta rate scaling has not been initialized.\n");
3269 3270 3271 3272 3273 3274
	il->stations[sta_id].lq = link_cmd;
	spin_unlock_irqrestore(&il->sta_lock, flags);

	return 0;
}

3275 3276
int
il4965_update_bcast_stations(struct il_priv *il)
3277 3278 3279 3280 3281 3282 3283
{
	return il4965_update_bcast_station(il, &il->ctx);
}

/**
 * il4965_sta_tx_modify_enable_tid - Enable Tx for this TID in station table
 */
3284 3285
int
il4965_sta_tx_modify_enable_tid(struct il_priv *il, int sta_id, int tid)
3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297
{
	unsigned long flags;
	struct il_addsta_cmd sta_cmd;

	lockdep_assert_held(&il->mutex);

	/* Remove "disable" flag, to enable Tx for this TID */
	spin_lock_irqsave(&il->sta_lock, flags);
	il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_TID_DISABLE_TX;
	il->stations[sta_id].sta.tid_disable_tx &= cpu_to_le16(~(1 << tid));
	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
	memcpy(&sta_cmd, &il->stations[sta_id].sta,
3298
	       sizeof(struct il_addsta_cmd));
3299 3300 3301 3302 3303
	spin_unlock_irqrestore(&il->sta_lock, flags);

	return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
}

3304 3305 3306
int
il4965_sta_rx_agg_start(struct il_priv *il, struct ieee80211_sta *sta, int tid,
			u16 ssn)
3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320
{
	unsigned long flags;
	int sta_id;
	struct il_addsta_cmd sta_cmd;

	lockdep_assert_held(&il->mutex);

	sta_id = il_sta_id(sta);
	if (sta_id == IL_INVALID_STATION)
		return -ENXIO;

	spin_lock_irqsave(&il->sta_lock, flags);
	il->stations[sta_id].sta.station_flags_msk = 0;
	il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_ADDBA_TID_MSK;
3321
	il->stations[sta_id].sta.add_immediate_ba_tid = (u8) tid;
3322 3323 3324
	il->stations[sta_id].sta.add_immediate_ba_ssn = cpu_to_le16(ssn);
	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
	memcpy(&sta_cmd, &il->stations[sta_id].sta,
3325
	       sizeof(struct il_addsta_cmd));
3326 3327 3328 3329 3330
	spin_unlock_irqrestore(&il->sta_lock, flags);

	return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
}

3331 3332
int
il4965_sta_rx_agg_stop(struct il_priv *il, struct ieee80211_sta *sta, int tid)
3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348
{
	unsigned long flags;
	int sta_id;
	struct il_addsta_cmd sta_cmd;

	lockdep_assert_held(&il->mutex);

	sta_id = il_sta_id(sta);
	if (sta_id == IL_INVALID_STATION) {
		IL_ERR("Invalid station for AGG tid %d\n", tid);
		return -ENXIO;
	}

	spin_lock_irqsave(&il->sta_lock, flags);
	il->stations[sta_id].sta.station_flags_msk = 0;
	il->stations[sta_id].sta.sta.modify_mask = STA_MODIFY_DELBA_TID_MSK;
3349
	il->stations[sta_id].sta.remove_immediate_ba_tid = (u8) tid;
3350 3351
	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
	memcpy(&sta_cmd, &il->stations[sta_id].sta,
3352
	       sizeof(struct il_addsta_cmd));
3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366
	spin_unlock_irqrestore(&il->sta_lock, flags);

	return il_send_add_sta(il, &sta_cmd, CMD_SYNC);
}

void
il4965_sta_modify_sleep_tx_count(struct il_priv *il, int sta_id, int cnt)
{
	unsigned long flags;

	spin_lock_irqsave(&il->sta_lock, flags);
	il->stations[sta_id].sta.station_flags |= STA_FLG_PWR_SAVE_MSK;
	il->stations[sta_id].sta.station_flags_msk = STA_FLG_PWR_SAVE_MSK;
	il->stations[sta_id].sta.sta.modify_mask =
3367
	    STA_MODIFY_SLEEP_TX_COUNT_MSK;
3368 3369
	il->stations[sta_id].sta.sleep_tx_count = cpu_to_le16(cnt);
	il->stations[sta_id].sta.mode = STA_CONTROL_MODIFY_MSK;
3370
	il_send_add_sta(il, &il->stations[sta_id].sta, CMD_ASYNC);
3371 3372 3373 3374
	spin_unlock_irqrestore(&il->sta_lock, flags);

}

3375 3376
void
il4965_update_chain_flags(struct il_priv *il)
3377
{
S
Stanislaw Gruszka 已提交
3378
	if (il->cfg->ops->hcmd->set_rxon_chain) {
3379
		il->cfg->ops->hcmd->set_rxon_chain(il, &il->ctx);
3380
		if (il->active.rx_chain != il->staging.rx_chain)
3381
			il_commit_rxon(il, &il->ctx);
3382 3383 3384
	}
}

3385 3386
static void
il4965_clear_free_frames(struct il_priv *il)
3387 3388 3389
{
	struct list_head *element;

3390
	D_INFO("%d frames on pre-allocated heap on clear.\n", il->frames_count);
3391

S
Stanislaw Gruszka 已提交
3392 3393
	while (!list_empty(&il->free_frames)) {
		element = il->free_frames.next;
3394
		list_del(element);
S
Stanislaw Gruszka 已提交
3395
		kfree(list_entry(element, struct il_frame, list));
S
Stanislaw Gruszka 已提交
3396
		il->frames_count--;
3397 3398
	}

S
Stanislaw Gruszka 已提交
3399
	if (il->frames_count) {
3400
		IL_WARN("%d frames still in use.  Did we lose one?\n",
3401
			il->frames_count);
S
Stanislaw Gruszka 已提交
3402
		il->frames_count = 0;
3403 3404 3405
	}
}

3406 3407
static struct il_frame *
il4965_get_free_frame(struct il_priv *il)
3408
{
S
Stanislaw Gruszka 已提交
3409
	struct il_frame *frame;
3410
	struct list_head *element;
S
Stanislaw Gruszka 已提交
3411
	if (list_empty(&il->free_frames)) {
3412 3413
		frame = kzalloc(sizeof(*frame), GFP_KERNEL);
		if (!frame) {
3414
			IL_ERR("Could not allocate frame!\n");
3415 3416 3417
			return NULL;
		}

S
Stanislaw Gruszka 已提交
3418
		il->frames_count++;
3419 3420 3421
		return frame;
	}

S
Stanislaw Gruszka 已提交
3422
	element = il->free_frames.next;
3423
	list_del(element);
S
Stanislaw Gruszka 已提交
3424
	return list_entry(element, struct il_frame, list);
3425 3426
}

3427 3428
static void
il4965_free_frame(struct il_priv *il, struct il_frame *frame)
3429 3430
{
	memset(frame, 0, sizeof(*frame));
S
Stanislaw Gruszka 已提交
3431
	list_add(&frame->list, &il->free_frames);
3432 3433
}

3434 3435 3436
static u32
il4965_fill_beacon_frame(struct il_priv *il, struct ieee80211_hdr *hdr,
			 int left)
3437
{
S
Stanislaw Gruszka 已提交
3438
	lockdep_assert_held(&il->mutex);
3439

S
Stanislaw Gruszka 已提交
3440
	if (!il->beacon_skb)
3441 3442
		return 0;

S
Stanislaw Gruszka 已提交
3443
	if (il->beacon_skb->len > left)
3444 3445
		return 0;

S
Stanislaw Gruszka 已提交
3446
	memcpy(hdr, il->beacon_skb->data, il->beacon_skb->len);
3447

S
Stanislaw Gruszka 已提交
3448
	return il->beacon_skb->len;
3449 3450 3451
}

/* Parse the beacon frame to find the TIM element and set tim_idx & tim_size */
3452 3453 3454 3455
static void
il4965_set_beacon_tim(struct il_priv *il,
		      struct il_tx_beacon_cmd *tx_beacon_cmd, u8 * beacon,
		      u32 frame_size)
3456 3457 3458 3459 3460
{
	u16 tim_idx;
	struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)beacon;

	/*
S
Stanislaw Gruszka 已提交
3461
	 * The idx is relative to frame start but we start looking at the
3462 3463 3464 3465 3466 3467
	 * variable-length part of the beacon.
	 */
	tim_idx = mgmt->u.beacon.variable - beacon;

	/* Parse variable-length elements of beacon to find WLAN_EID_TIM */
	while ((tim_idx < (frame_size - 2)) &&
3468 3469
	       (beacon[tim_idx] != WLAN_EID_TIM))
		tim_idx += beacon[tim_idx + 1] + 2;
3470 3471 3472 3473

	/* If TIM field was found, set variables */
	if ((tim_idx < (frame_size - 1)) && (beacon[tim_idx] == WLAN_EID_TIM)) {
		tx_beacon_cmd->tim_idx = cpu_to_le16(tim_idx);
3474
		tx_beacon_cmd->tim_size = beacon[tim_idx + 1];
3475
	} else
3476
		IL_WARN("Unable to find TIM Element in beacon\n");
3477 3478
}

3479 3480
static unsigned int
il4965_hw_get_beacon_cmd(struct il_priv *il, struct il_frame *frame)
3481
{
S
Stanislaw Gruszka 已提交
3482
	struct il_tx_beacon_cmd *tx_beacon_cmd;
3483 3484 3485 3486 3487 3488 3489 3490
	u32 frame_size;
	u32 rate_flags;
	u32 rate;
	/*
	 * We have to set up the TX command, the TX Beacon command, and the
	 * beacon contents.
	 */

S
Stanislaw Gruszka 已提交
3491
	lockdep_assert_held(&il->mutex);
3492

S
Stanislaw Gruszka 已提交
3493
	if (!il->beacon_ctx) {
3494
		IL_ERR("trying to build beacon w/o beacon context!\n");
3495 3496 3497 3498 3499 3500 3501 3502
		return 0;
	}

	/* Initialize memory */
	tx_beacon_cmd = &frame->u.beacon;
	memset(tx_beacon_cmd, 0, sizeof(*tx_beacon_cmd));

	/* Set up TX beacon contents */
3503 3504 3505
	frame_size =
	    il4965_fill_beacon_frame(il, tx_beacon_cmd->frame,
				     sizeof(frame->u) - sizeof(*tx_beacon_cmd));
3506 3507 3508 3509 3510 3511
	if (WARN_ON_ONCE(frame_size > MAX_MPDU_SIZE))
		return 0;
	if (!frame_size)
		return 0;

	/* Set up TX command fields */
3512
	tx_beacon_cmd->tx.len = cpu_to_le16((u16) frame_size);
3513
	tx_beacon_cmd->tx.sta_id = il->hw_params.bcast_id;
3514
	tx_beacon_cmd->tx.stop_time.life_time = TX_CMD_LIFE_TIME_INFINITE;
3515 3516 3517
	tx_beacon_cmd->tx.tx_flags =
	    TX_CMD_FLG_SEQ_CTL_MSK | TX_CMD_FLG_TSF_MSK |
	    TX_CMD_FLG_STA_RATE_MSK;
3518 3519

	/* Set up TX beacon command fields */
3520 3521
	il4965_set_beacon_tim(il, tx_beacon_cmd, (u8 *) tx_beacon_cmd->frame,
			      frame_size);
3522 3523

	/* Set up packet rate and flags */
S
Stanislaw Gruszka 已提交
3524
	rate = il_get_lowest_plcp(il, il->beacon_ctx);
3525
	il4965_toggle_tx_ant(il, &il->mgmt_tx_ant, il->hw_params.valid_tx_ant);
3526
	rate_flags = BIT(il->mgmt_tx_ant) << RATE_MCS_ANT_POS;
S
Stanislaw Gruszka 已提交
3527
	if ((rate >= IL_FIRST_CCK_RATE) && (rate <= IL_LAST_CCK_RATE))
3528
		rate_flags |= RATE_MCS_CCK_MSK;
3529
	tx_beacon_cmd->tx.rate_n_flags = cpu_to_le32(rate | rate_flags);
3530 3531 3532 3533

	return sizeof(*tx_beacon_cmd) + frame_size;
}

3534 3535
int
il4965_send_beacon_cmd(struct il_priv *il)
3536
{
S
Stanislaw Gruszka 已提交
3537
	struct il_frame *frame;
3538 3539 3540
	unsigned int frame_size;
	int rc;

S
Stanislaw Gruszka 已提交
3541
	frame = il4965_get_free_frame(il);
3542
	if (!frame) {
3543
		IL_ERR("Could not obtain free frame buffer for beacon "
3544
		       "command.\n");
3545 3546 3547
		return -ENOMEM;
	}

S
Stanislaw Gruszka 已提交
3548
	frame_size = il4965_hw_get_beacon_cmd(il, frame);
3549
	if (!frame_size) {
3550
		IL_ERR("Error configuring the beacon command\n");
S
Stanislaw Gruszka 已提交
3551
		il4965_free_frame(il, frame);
3552 3553 3554
		return -EINVAL;
	}

3555
	rc = il_send_cmd_pdu(il, C_TX_BEACON, frame_size, &frame->u.cmd[0]);
3556

S
Stanislaw Gruszka 已提交
3557
	il4965_free_frame(il, frame);
3558 3559 3560 3561

	return rc;
}

3562 3563
static inline dma_addr_t
il4965_tfd_tb_get_addr(struct il_tfd *tfd, u8 idx)
3564
{
S
Stanislaw Gruszka 已提交
3565
	struct il_tfd_tb *tb = &tfd->tbs[idx];
3566 3567 3568 3569

	dma_addr_t addr = get_unaligned_le32(&tb->lo);
	if (sizeof(dma_addr_t) > sizeof(u32))
		addr |=
3570 3571
		    ((dma_addr_t) (le16_to_cpu(tb->hi_n_len) & 0xF) << 16) <<
		    16;
3572 3573 3574 3575

	return addr;
}

3576 3577
static inline u16
il4965_tfd_tb_get_len(struct il_tfd *tfd, u8 idx)
3578
{
S
Stanislaw Gruszka 已提交
3579
	struct il_tfd_tb *tb = &tfd->tbs[idx];
3580 3581 3582 3583

	return le16_to_cpu(tb->hi_n_len) >> 4;
}

3584 3585
static inline void
il4965_tfd_set_tb(struct il_tfd *tfd, u8 idx, dma_addr_t addr, u16 len)
3586
{
S
Stanislaw Gruszka 已提交
3587
	struct il_tfd_tb *tb = &tfd->tbs[idx];
3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598
	u16 hi_n_len = len << 4;

	put_unaligned_le32(addr, &tb->lo);
	if (sizeof(dma_addr_t) > sizeof(u32))
		hi_n_len |= ((addr >> 16) >> 16) & 0xF;

	tb->hi_n_len = cpu_to_le16(hi_n_len);

	tfd->num_tbs = idx + 1;
}

3599 3600
static inline u8
il4965_tfd_get_num_tbs(struct il_tfd *tfd)
3601 3602 3603 3604 3605
{
	return tfd->num_tbs & 0x1f;
}

/**
S
Stanislaw Gruszka 已提交
3606
 * il4965_hw_txq_free_tfd - Free all chunks referenced by TFD [txq->q.read_ptr]
S
Stanislaw Gruszka 已提交
3607
 * @il - driver ilate data
3608 3609
 * @txq - tx queue
 *
S
Stanislaw Gruszka 已提交
3610
 * Does NOT advance any TFD circular buffer read/write idxes
3611 3612
 * Does NOT free the TFD itself (which is within circular buffer)
 */
3613 3614
void
il4965_hw_txq_free_tfd(struct il_priv *il, struct il_tx_queue *txq)
3615
{
S
Stanislaw Gruszka 已提交
3616 3617
	struct il_tfd *tfd_tmp = (struct il_tfd *)txq->tfds;
	struct il_tfd *tfd;
S
Stanislaw Gruszka 已提交
3618
	struct pci_dev *dev = il->pci_dev;
S
Stanislaw Gruszka 已提交
3619
	int idx = txq->q.read_ptr;
3620 3621 3622
	int i;
	int num_tbs;

S
Stanislaw Gruszka 已提交
3623
	tfd = &tfd_tmp[idx];
3624 3625

	/* Sanity check on number of chunks */
S
Stanislaw Gruszka 已提交
3626
	num_tbs = il4965_tfd_get_num_tbs(tfd);
3627

S
Stanislaw Gruszka 已提交
3628
	if (num_tbs >= IL_NUM_OF_TBS) {
3629
		IL_ERR("Too many chunks: %i\n", num_tbs);
3630 3631 3632 3633 3634 3635
		/* @todo issue fatal error, it is quite serious situation */
		return;
	}

	/* Unmap tx_cmd */
	if (num_tbs)
3636 3637 3638
		pci_unmap_single(dev, dma_unmap_addr(&txq->meta[idx], mapping),
				 dma_unmap_len(&txq->meta[idx], len),
				 PCI_DMA_BIDIRECTIONAL);
3639 3640 3641

	/* Unmap chunks, if any. */
	for (i = 1; i < num_tbs; i++)
S
Stanislaw Gruszka 已提交
3642
		pci_unmap_single(dev, il4965_tfd_tb_get_addr(tfd, i),
3643 3644
				 il4965_tfd_tb_get_len(tfd, i),
				 PCI_DMA_TODEVICE);
3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659

	/* free SKB */
	if (txq->txb) {
		struct sk_buff *skb;

		skb = txq->txb[txq->q.read_ptr].skb;

		/* can be called from irqs-disabled context */
		if (skb) {
			dev_kfree_skb_any(skb);
			txq->txb[txq->q.read_ptr].skb = NULL;
		}
	}
}

3660 3661 3662
int
il4965_hw_txq_attach_buf_to_tfd(struct il_priv *il, struct il_tx_queue *txq,
				dma_addr_t addr, u16 len, u8 reset, u8 pad)
3663
{
S
Stanislaw Gruszka 已提交
3664 3665
	struct il_queue *q;
	struct il_tfd *tfd, *tfd_tmp;
3666 3667 3668
	u32 num_tbs;

	q = &txq->q;
S
Stanislaw Gruszka 已提交
3669
	tfd_tmp = (struct il_tfd *)txq->tfds;
3670 3671 3672 3673 3674
	tfd = &tfd_tmp[q->write_ptr];

	if (reset)
		memset(tfd, 0, sizeof(*tfd));

S
Stanislaw Gruszka 已提交
3675
	num_tbs = il4965_tfd_get_num_tbs(tfd);
3676 3677

	/* Each TFD can point to a maximum 20 Tx buffers */
S
Stanislaw Gruszka 已提交
3678
	if (num_tbs >= IL_NUM_OF_TBS) {
3679
		IL_ERR("Error can not send more than %d chunks\n",
3680
		       IL_NUM_OF_TBS);
3681 3682 3683 3684
		return -EINVAL;
	}

	BUG_ON(addr & ~DMA_BIT_MASK(36));
S
Stanislaw Gruszka 已提交
3685
	if (unlikely(addr & ~IL_TX_DMA_MASK))
3686
		IL_ERR("Unaligned address = %llx\n", (unsigned long long)addr);
3687

S
Stanislaw Gruszka 已提交
3688
	il4965_tfd_set_tb(tfd, num_tbs, addr, len);
3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699

	return 0;
}

/*
 * Tell nic where to find circular buffer of Tx Frame Descriptors for
 * given Tx queue, and enable the DMA channel used for that queue.
 *
 * 4965 supports up to 16 Tx queues in DRAM, mapped to up to 8 Tx DMA
 * channels supported in hardware.
 */
3700 3701
int
il4965_hw_tx_queue_init(struct il_priv *il, struct il_tx_queue *txq)
3702 3703 3704 3705
{
	int txq_id = txq->q.id;

	/* Circular buffer (TFD queue in DRAM) physical base address */
3706
	il_wr(il, FH49_MEM_CBBC_QUEUE(txq_id), txq->q.dma_addr >> 8);
3707 3708 3709 3710 3711 3712 3713 3714 3715

	return 0;
}

/******************************************************************************
 *
 * Generic RX handler implementations
 *
 ******************************************************************************/
3716 3717
static void
il4965_hdl_alive(struct il_priv *il, struct il_rx_buf *rxb)
3718
{
3719
	struct il_rx_pkt *pkt = rxb_addr(rxb);
S
Stanislaw Gruszka 已提交
3720
	struct il_alive_resp *palive;
3721 3722 3723 3724
	struct delayed_work *pwork;

	palive = &pkt->u.alive_frame;

3725 3726
	D_INFO("Alive ucode status 0x%08X revision " "0x%01X 0x%01X\n",
	       palive->is_valid, palive->ver_type, palive->ver_subtype);
3727 3728

	if (palive->ver_subtype == INITIALIZE_SUBTYPE) {
3729
		D_INFO("Initialization Alive received.\n");
3730
		memcpy(&il->card_alive_init, &pkt->u.alive_frame,
S
Stanislaw Gruszka 已提交
3731
		       sizeof(struct il_init_alive_resp));
S
Stanislaw Gruszka 已提交
3732
		pwork = &il->init_alive_start;
3733
	} else {
3734
		D_INFO("Runtime Alive received.\n");
S
Stanislaw Gruszka 已提交
3735
		memcpy(&il->card_alive, &pkt->u.alive_frame,
S
Stanislaw Gruszka 已提交
3736
		       sizeof(struct il_alive_resp));
S
Stanislaw Gruszka 已提交
3737
		pwork = &il->alive_start;
3738 3739 3740 3741 3742
	}

	/* We delay the ALIVE response by 5ms to
	 * give the HW RF Kill time to activate... */
	if (palive->is_valid == UCODE_VALID_OK)
3743
		queue_delayed_work(il->workqueue, pwork, msecs_to_jiffies(5));
3744
	else
3745
		IL_WARN("uCode did not respond OK.\n");
3746 3747 3748
}

/**
S
Stanislaw Gruszka 已提交
3749
 * il4965_bg_stats_periodic - Timer callback to queue stats
3750
 *
S
Stanislaw Gruszka 已提交
3751
 * This callback is provided in order to send a stats request.
3752 3753
 *
 * This timer function is continually reset to execute within
3754
 * REG_RECALIB_PERIOD seconds since the last N_STATS
S
Stanislaw Gruszka 已提交
3755
 * was received.  We need to ensure we receive the stats in order
3756 3757
 * to update the temperature used for calibrating the TXPOWER.
 */
3758 3759
static void
il4965_bg_stats_periodic(unsigned long data)
3760
{
S
Stanislaw Gruszka 已提交
3761
	struct il_priv *il = (struct il_priv *)data;
3762

S
Stanislaw Gruszka 已提交
3763
	if (test_bit(S_EXIT_PENDING, &il->status))
3764 3765 3766
		return;

	/* dont send host command if rf-kill is on */
S
Stanislaw Gruszka 已提交
3767
	if (!il_is_ready_rf(il))
3768 3769
		return;

S
Stanislaw Gruszka 已提交
3770
	il_send_stats_request(il, CMD_ASYNC, false);
3771 3772
}

3773 3774
static void
il4965_hdl_beacon(struct il_priv *il, struct il_rx_buf *rxb)
3775
{
3776
	struct il_rx_pkt *pkt = rxb_addr(rxb);
S
Stanislaw Gruszka 已提交
3777
	struct il4965_beacon_notif *beacon =
3778
	    (struct il4965_beacon_notif *)pkt->u.raw;
3779
#ifdef CONFIG_IWLEGACY_DEBUG
S
Stanislaw Gruszka 已提交
3780
	u8 rate = il4965_hw_get_rate(beacon->beacon_notify_hdr.rate_n_flags);
3781

3782
	D_RX("beacon status %x retries %d iss %d tsf:0x%.8x%.8x rate %d\n",
3783 3784 3785 3786
	     le32_to_cpu(beacon->beacon_notify_hdr.u.status) & TX_STATUS_MSK,
	     beacon->beacon_notify_hdr.failure_frame,
	     le32_to_cpu(beacon->ibss_mgr_status),
	     le32_to_cpu(beacon->high_tsf), le32_to_cpu(beacon->low_tsf), rate);
3787
#endif
S
Stanislaw Gruszka 已提交
3788
	il->ibss_manager = le32_to_cpu(beacon->ibss_mgr_status);
3789 3790
}

3791 3792
static void
il4965_perform_ct_kill_task(struct il_priv *il)
3793 3794 3795
{
	unsigned long flags;

3796
	D_POWER("Stop all queues\n");
3797

S
Stanislaw Gruszka 已提交
3798 3799
	if (il->mac80211_registered)
		ieee80211_stop_queues(il->hw);
3800

3801
	_il_wr(il, CSR_UCODE_DRV_GP1_SET,
3802
	       CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
3803
	_il_rd(il, CSR_UCODE_DRV_GP1);
3804

S
Stanislaw Gruszka 已提交
3805
	spin_lock_irqsave(&il->reg_lock, flags);
3806 3807
	if (!_il_grab_nic_access(il))
		_il_release_nic_access(il);
S
Stanislaw Gruszka 已提交
3808
	spin_unlock_irqrestore(&il->reg_lock, flags);
3809 3810 3811 3812
}

/* Handle notification from uCode that card's power state is changing
 * due to software, hardware, or critical temperature RFKILL */
3813 3814
static void
il4965_hdl_card_state(struct il_priv *il, struct il_rx_buf *rxb)
3815
{
3816
	struct il_rx_pkt *pkt = rxb_addr(rxb);
3817
	u32 flags = le32_to_cpu(pkt->u.card_state_notif.flags);
S
Stanislaw Gruszka 已提交
3818
	unsigned long status = il->status;
3819

3820
	D_RF_KILL("Card state received: HW:%s SW:%s CT:%s\n",
3821 3822 3823
		  (flags & HW_CARD_DISABLED) ? "Kill" : "On",
		  (flags & SW_CARD_DISABLED) ? "Kill" : "On",
		  (flags & CT_CARD_DISABLED) ? "Reached" : "Not reached");
3824

3825
	if (flags & (SW_CARD_DISABLED | HW_CARD_DISABLED | CT_CARD_DISABLED)) {
3826

3827
		_il_wr(il, CSR_UCODE_DRV_GP1_SET,
3828
		       CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
3829

3830
		il_wr(il, HBUS_TARG_MBX_C, HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
3831 3832

		if (!(flags & RXON_CARD_DISABLED)) {
3833
			_il_wr(il, CSR_UCODE_DRV_GP1_CLR,
3834
			       CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
3835
			il_wr(il, HBUS_TARG_MBX_C,
3836
			      HBUS_TARG_MBX_C_REG_BIT_CMD_BLOCKED);
3837 3838 3839 3840
		}
	}

	if (flags & CT_CARD_DISABLED)
S
Stanislaw Gruszka 已提交
3841
		il4965_perform_ct_kill_task(il);
3842 3843

	if (flags & HW_CARD_DISABLED)
S
Stanislaw Gruszka 已提交
3844
		set_bit(S_RF_KILL_HW, &il->status);
3845
	else
S
Stanislaw Gruszka 已提交
3846
		clear_bit(S_RF_KILL_HW, &il->status);
3847 3848

	if (!(flags & RXON_CARD_DISABLED))
S
Stanislaw Gruszka 已提交
3849
		il_scan_cancel(il);
3850

S
Stanislaw Gruszka 已提交
3851 3852
	if ((test_bit(S_RF_KILL_HW, &status) !=
	     test_bit(S_RF_KILL_HW, &il->status)))
S
Stanislaw Gruszka 已提交
3853
		wiphy_rfkill_set_hw_state(il->hw->wiphy,
3854
					  test_bit(S_RF_KILL_HW, &il->status));
3855
	else
S
Stanislaw Gruszka 已提交
3856
		wake_up(&il->wait_command_queue);
3857 3858 3859
}

/**
3860
 * il4965_setup_handlers - Initialize Rx handler callbacks
3861 3862 3863 3864 3865 3866 3867
 *
 * Setup the RX handlers for each of the reply types sent from the uCode
 * to the host.
 *
 * This function chains into the hardware specific files for them to setup
 * any hardware specific handlers as well.
 */
3868 3869
static void
il4965_setup_handlers(struct il_priv *il)
3870
{
S
Stanislaw Gruszka 已提交
3871 3872
	il->handlers[N_ALIVE] = il4965_hdl_alive;
	il->handlers[N_ERROR] = il_hdl_error;
3873
	il->handlers[N_CHANNEL_SWITCH] = il_hdl_csa;
3874
	il->handlers[N_SPECTRUM_MEASUREMENT] = il_hdl_spectrum_measurement;
3875
	il->handlers[N_PM_SLEEP] = il_hdl_pm_sleep;
3876
	il->handlers[N_PM_DEBUG_STATS] = il_hdl_pm_debug_stats;
3877
	il->handlers[N_BEACON] = il4965_hdl_beacon;
3878 3879 3880

	/*
	 * The same handler is used for both the REPLY to a discrete
S
Stanislaw Gruszka 已提交
3881 3882
	 * stats request from the host as well as for the periodic
	 * stats notifications (after received beacons) from the uCode.
3883
	 */
3884 3885
	il->handlers[C_STATS] = il4965_hdl_c_stats;
	il->handlers[N_STATS] = il4965_hdl_stats;
3886

S
Stanislaw Gruszka 已提交
3887
	il_setup_rx_scan_handlers(il);
3888 3889

	/* status change handler */
3890
	il->handlers[N_CARD_STATE] = il4965_hdl_card_state;
3891

3892
	il->handlers[N_MISSED_BEACONS] = il4965_hdl_missed_beacon;
3893
	/* Rx handlers */
S
Stanislaw Gruszka 已提交
3894 3895
	il->handlers[N_RX_PHY] = il4965_hdl_rx_phy;
	il->handlers[N_RX_MPDU] = il4965_hdl_rx;
3896
	/* block ack */
S
Stanislaw Gruszka 已提交
3897
	il->handlers[N_COMPRESSED_BA] = il4965_hdl_compressed_ba;
3898
	/* Set up hardware specific Rx handlers */
3899
	il->cfg->ops->lib->handler_setup(il);
3900 3901 3902
}

/**
S
Stanislaw Gruszka 已提交
3903
 * il4965_rx_handle - Main entry function for receiving responses from uCode
3904
 *
3905
 * Uses the il->handlers callback function array to invoke
3906 3907 3908
 * the appropriate handlers, including command responses,
 * frame-received notifications, and other notifications.
 */
3909 3910
void
il4965_rx_handle(struct il_priv *il)
3911
{
3912
	struct il_rx_buf *rxb;
3913
	struct il_rx_pkt *pkt;
S
Stanislaw Gruszka 已提交
3914
	struct il_rx_queue *rxq = &il->rxq;
3915 3916 3917 3918 3919 3920 3921
	u32 r, i;
	int reclaim;
	unsigned long flags;
	u8 fill_rx = 0;
	u32 count = 8;
	int total_empty;

S
Stanislaw Gruszka 已提交
3922
	/* uCode's read idx (stored in shared DRAM) indicates the last Rx
3923
	 * buffer that the driver may process (last buffer filled by ucode). */
3924
	r = le16_to_cpu(rxq->rb_stts->closed_rb_num) & 0x0FFF;
3925 3926 3927 3928
	i = rxq->read;

	/* Rx interrupt, but nothing sent from uCode */
	if (i == r)
3929
		D_RX("r = %d, i = %d\n", r, i);
3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950

	/* calculate total frames need to be restock after handling RX */
	total_empty = r - rxq->write_actual;
	if (total_empty < 0)
		total_empty += RX_QUEUE_SIZE;

	if (total_empty > (RX_QUEUE_SIZE / 2))
		fill_rx = 1;

	while (i != r) {
		int len;

		rxb = rxq->queue[i];

		/* If an RXB doesn't have a Rx queue slot associated with it,
		 * then a bug has been introduced in the queue refilling
		 * routines -- catch it here */
		BUG_ON(rxb == NULL);

		rxq->queue[i] = NULL;

S
Stanislaw Gruszka 已提交
3951 3952
		pci_unmap_page(il->pci_dev, rxb->page_dma,
			       PAGE_SIZE << il->hw_params.rx_page_order,
3953 3954 3955
			       PCI_DMA_FROMDEVICE);
		pkt = rxb_addr(rxb);

3956
		len = le32_to_cpu(pkt->len_n_flags) & IL_RX_FRAME_SIZE_MSK;
3957
		len += sizeof(u32);	/* account for status word */
3958 3959 3960 3961 3962 3963 3964 3965

		/* Reclaim a command buffer only if this packet is a response
		 *   to a (driver-originated) command.
		 * If the packet (e.g. Rx frame) originated from uCode,
		 *   there is no command buffer to reclaim.
		 * Ucode should set SEQ_RX_FRAME bit if ucode-originated,
		 *   but apparently a few don't get set; catch them here. */
		reclaim = !(pkt->hdr.sequence & SEQ_RX_FRAME) &&
3966 3967 3968 3969
		    (pkt->hdr.cmd != N_RX_PHY) && (pkt->hdr.cmd != N_RX) &&
		    (pkt->hdr.cmd != N_RX_MPDU) &&
		    (pkt->hdr.cmd != N_COMPRESSED_BA) &&
		    (pkt->hdr.cmd != N_STATS) && (pkt->hdr.cmd != C_TX);
3970 3971 3972

		/* Based on type of command response or notification,
		 *   handle those that need handling via function in
3973 3974
		 *   handlers table.  See il4965_setup_handlers() */
		if (il->handlers[pkt->hdr.cmd]) {
3975 3976
			D_RX("r = %d, i = %d, %s, 0x%02x\n", r, i,
			     il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
3977 3978
			il->isr_stats.handlers[pkt->hdr.cmd]++;
			il->handlers[pkt->hdr.cmd] (il, rxb);
3979 3980
		} else {
			/* No handling needed */
3981 3982
			D_RX("r %d i %d No handler needed for %s, 0x%02x\n", r,
			     i, il_get_cmd_string(pkt->hdr.cmd), pkt->hdr.cmd);
3983 3984 3985 3986 3987
		}

		/*
		 * XXX: After here, we should always check rxb->page
		 * against NULL before touching it or its virtual
3988
		 * memory (pkt). Because some handler might have
3989 3990 3991 3992 3993
		 * already taken or freed the pages.
		 */

		if (reclaim) {
			/* Invoke any callbacks, transfer the buffer to caller,
S
Stanislaw Gruszka 已提交
3994
			 * and fire off the (possibly) blocking il_send_cmd()
3995 3996
			 * as we reclaim the driver command queue */
			if (rxb->page)
S
Stanislaw Gruszka 已提交
3997
				il_tx_cmd_complete(il, rxb);
3998
			else
3999
				IL_WARN("Claim null rxb?\n");
4000 4001 4002 4003 4004 4005 4006
		}

		/* Reuse the page if possible. For notification packets and
		 * SKBs that fail to Rx correctly, add them back into the
		 * rx_free list for reuse later. */
		spin_lock_irqsave(&rxq->lock, flags);
		if (rxb->page != NULL) {
4007 4008 4009 4010
			rxb->page_dma =
			    pci_map_page(il->pci_dev, rxb->page, 0,
					 PAGE_SIZE << il->hw_params.
					 rx_page_order, PCI_DMA_FROMDEVICE);
4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024
			list_add_tail(&rxb->list, &rxq->rx_free);
			rxq->free_count++;
		} else
			list_add_tail(&rxb->list, &rxq->rx_used);

		spin_unlock_irqrestore(&rxq->lock, flags);

		i = (i + 1) & RX_QUEUE_MASK;
		/* If there are a lot of unused frames,
		 * restock the Rx queue so ucode wont assert. */
		if (fill_rx) {
			count++;
			if (count >= 8) {
				rxq->read = i;
S
Stanislaw Gruszka 已提交
4025
				il4965_rx_replenish_now(il);
4026 4027 4028 4029 4030 4031 4032 4033
				count = 0;
			}
		}
	}

	/* Backtrack one entry */
	rxq->read = i;
	if (fill_rx)
S
Stanislaw Gruszka 已提交
4034
		il4965_rx_replenish_now(il);
4035
	else
S
Stanislaw Gruszka 已提交
4036
		il4965_rx_queue_restock(il);
4037 4038 4039
}

/* call this function to flush any scheduled tasklet */
4040 4041
static inline void
il4965_synchronize_irq(struct il_priv *il)
4042
{
4043
	/* wait to make sure we flush pending tasklet */
S
Stanislaw Gruszka 已提交
4044 4045
	synchronize_irq(il->pci_dev->irq);
	tasklet_kill(&il->irq_tasklet);
4046 4047
}

4048 4049
static void
il4965_irq_tasklet(struct il_priv *il)
4050 4051 4052 4053 4054
{
	u32 inta, handled = 0;
	u32 inta_fh;
	unsigned long flags;
	u32 i;
4055
#ifdef CONFIG_IWLEGACY_DEBUG
4056 4057 4058
	u32 inta_mask;
#endif

S
Stanislaw Gruszka 已提交
4059
	spin_lock_irqsave(&il->lock, flags);
4060 4061 4062 4063

	/* Ack/clear/reset pending uCode interrupts.
	 * Note:  Some bits in CSR_INT are "OR" of bits in CSR_FH_INT_STATUS,
	 *  and will clear only when CSR_FH_INT_STATUS gets cleared. */
4064 4065
	inta = _il_rd(il, CSR_INT);
	_il_wr(il, CSR_INT, inta);
4066 4067 4068 4069

	/* Ack/clear/reset pending flow-handler (DMA) interrupts.
	 * Any new interrupts that happen after this, either while we're
	 * in this tasklet, or later, will show up in next ISR/tasklet. */
4070 4071
	inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
	_il_wr(il, CSR_FH_INT_STATUS, inta_fh);
4072

4073
#ifdef CONFIG_IWLEGACY_DEBUG
S
Stanislaw Gruszka 已提交
4074
	if (il_get_debug_level(il) & IL_DL_ISR) {
4075
		/* just for debug */
4076
		inta_mask = _il_rd(il, CSR_INT_MASK);
4077 4078
		D_ISR("inta 0x%08x, enabled 0x%08x, fh 0x%08x\n", inta,
		      inta_mask, inta_fh);
4079 4080 4081
	}
#endif

S
Stanislaw Gruszka 已提交
4082
	spin_unlock_irqrestore(&il->lock, flags);
4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094

	/* Since CSR_INT and CSR_FH_INT_STATUS reads and clears are not
	 * atomic, make sure that inta covers all the interrupts that
	 * we've discovered, even if FH interrupt came in just after
	 * reading CSR_INT. */
	if (inta_fh & CSR49_FH_INT_RX_MASK)
		inta |= CSR_INT_BIT_FH_RX;
	if (inta_fh & CSR49_FH_INT_TX_MASK)
		inta |= CSR_INT_BIT_FH_TX;

	/* Now service all interrupt bits discovered above. */
	if (inta & CSR_INT_BIT_HW_ERR) {
4095
		IL_ERR("Hardware error detected.  Restarting.\n");
4096 4097

		/* Tell the device to stop sending interrupts */
S
Stanislaw Gruszka 已提交
4098
		il_disable_interrupts(il);
4099

S
Stanislaw Gruszka 已提交
4100 4101
		il->isr_stats.hw++;
		il_irq_handle_error(il);
4102 4103 4104 4105 4106

		handled |= CSR_INT_BIT_HW_ERR;

		return;
	}
4107
#ifdef CONFIG_IWLEGACY_DEBUG
S
Stanislaw Gruszka 已提交
4108
	if (il_get_debug_level(il) & (IL_DL_ISR)) {
4109 4110
		/* NIC fires this, but we don't use it, redundant with WAKEUP */
		if (inta & CSR_INT_BIT_SCD) {
4111
			D_ISR("Scheduler finished to transmit "
4112
			      "the frame/frames.\n");
S
Stanislaw Gruszka 已提交
4113
			il->isr_stats.sch++;
4114 4115 4116 4117
		}

		/* Alive notification via Rx interrupt will do the real work */
		if (inta & CSR_INT_BIT_ALIVE) {
4118
			D_ISR("Alive interrupt\n");
S
Stanislaw Gruszka 已提交
4119
			il->isr_stats.alive++;
4120 4121 4122 4123 4124 4125 4126 4127 4128
		}
	}
#endif
	/* Safely ignore these bits for debug checks below */
	inta &= ~(CSR_INT_BIT_SCD | CSR_INT_BIT_ALIVE);

	/* HW RF KILL switch toggled */
	if (inta & CSR_INT_BIT_RF_KILL) {
		int hw_rf_kill = 0;
4129 4130 4131
		if (!
		    (_il_rd(il, CSR_GP_CNTRL) &
		     CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW))
4132 4133
			hw_rf_kill = 1;

4134
		IL_WARN("RF_KILL bit toggled to %s.\n",
4135
			hw_rf_kill ? "disable radio" : "enable radio");
4136

S
Stanislaw Gruszka 已提交
4137
		il->isr_stats.rfkill++;
4138 4139 4140 4141 4142 4143

		/* driver only loads ucode once setting the interface up.
		 * the driver allows loading the ucode even if the radio
		 * is killed. Hence update the killswitch state here. The
		 * rfkill handler will care about restarting if needed.
		 */
S
Stanislaw Gruszka 已提交
4144
		if (!test_bit(S_ALIVE, &il->status)) {
4145
			if (hw_rf_kill)
S
Stanislaw Gruszka 已提交
4146
				set_bit(S_RF_KILL_HW, &il->status);
4147
			else
S
Stanislaw Gruszka 已提交
4148
				clear_bit(S_RF_KILL_HW, &il->status);
S
Stanislaw Gruszka 已提交
4149
			wiphy_rfkill_set_hw_state(il->hw->wiphy, hw_rf_kill);
4150 4151 4152 4153 4154 4155 4156
		}

		handled |= CSR_INT_BIT_RF_KILL;
	}

	/* Chip got too hot and stopped itself */
	if (inta & CSR_INT_BIT_CT_KILL) {
4157
		IL_ERR("Microcode CT kill error detected.\n");
S
Stanislaw Gruszka 已提交
4158
		il->isr_stats.ctkill++;
4159 4160 4161 4162 4163
		handled |= CSR_INT_BIT_CT_KILL;
	}

	/* Error detected by uCode */
	if (inta & CSR_INT_BIT_SW_ERR) {
4164 4165
		IL_ERR("Microcode SW error detected. " " Restarting 0x%X.\n",
		       inta);
S
Stanislaw Gruszka 已提交
4166 4167
		il->isr_stats.sw++;
		il_irq_handle_error(il);
4168 4169 4170 4171 4172 4173 4174 4175 4176
		handled |= CSR_INT_BIT_SW_ERR;
	}

	/*
	 * uCode wakes up after power-down sleep.
	 * Tell device about any new tx or host commands enqueued,
	 * and about any Rx buffers made available while asleep.
	 */
	if (inta & CSR_INT_BIT_WAKEUP) {
4177
		D_ISR("Wakeup interrupt\n");
S
Stanislaw Gruszka 已提交
4178 4179 4180 4181
		il_rx_queue_update_write_ptr(il, &il->rxq);
		for (i = 0; i < il->hw_params.max_txq_num; i++)
			il_txq_update_write_ptr(il, &il->txq[i]);
		il->isr_stats.wakeup++;
4182 4183 4184 4185 4186 4187 4188
		handled |= CSR_INT_BIT_WAKEUP;
	}

	/* All uCode command responses, including Tx command responses,
	 * Rx "responses" (frame-received notification), and other
	 * notifications from uCode come through here*/
	if (inta & (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX)) {
S
Stanislaw Gruszka 已提交
4189 4190
		il4965_rx_handle(il);
		il->isr_stats.rx++;
4191 4192 4193 4194 4195
		handled |= (CSR_INT_BIT_FH_RX | CSR_INT_BIT_SW_RX);
	}

	/* This "Tx" DMA channel is used only for loading uCode */
	if (inta & CSR_INT_BIT_FH_TX) {
4196
		D_ISR("uCode load interrupt\n");
S
Stanislaw Gruszka 已提交
4197
		il->isr_stats.tx++;
4198 4199
		handled |= CSR_INT_BIT_FH_TX;
		/* Wake up uCode load routine, now that load is complete */
S
Stanislaw Gruszka 已提交
4200 4201
		il->ucode_write_complete = 1;
		wake_up(&il->wait_command_queue);
4202 4203 4204
	}

	if (inta & ~handled) {
4205
		IL_ERR("Unhandled INTA bits 0x%08x\n", inta & ~handled);
S
Stanislaw Gruszka 已提交
4206
		il->isr_stats.unhandled++;
4207 4208
	}

S
Stanislaw Gruszka 已提交
4209
	if (inta & ~(il->inta_mask)) {
4210
		IL_WARN("Disabled INTA bits 0x%08x were pending\n",
4211
			inta & ~il->inta_mask);
4212
		IL_WARN("   with FH49_INT = 0x%08x\n", inta_fh);
4213 4214 4215
	}

	/* Re-enable all interrupts */
4216
	/* only Re-enable if disabled by irq */
S
Stanislaw Gruszka 已提交
4217
	if (test_bit(S_INT_ENABLED, &il->status))
S
Stanislaw Gruszka 已提交
4218
		il_enable_interrupts(il);
4219 4220
	/* Re-enable RF_KILL if it occurred */
	else if (handled & CSR_INT_BIT_RF_KILL)
S
Stanislaw Gruszka 已提交
4221
		il_enable_rfkill_int(il);
4222

4223
#ifdef CONFIG_IWLEGACY_DEBUG
S
Stanislaw Gruszka 已提交
4224
	if (il_get_debug_level(il) & (IL_DL_ISR)) {
4225 4226 4227
		inta = _il_rd(il, CSR_INT);
		inta_mask = _il_rd(il, CSR_INT_MASK);
		inta_fh = _il_rd(il, CSR_FH_INT_STATUS);
4228 4229
		D_ISR("End inta 0x%08x, enabled 0x%08x, fh 0x%08x, "
		      "flags 0x%08lx\n", inta, inta_mask, inta_fh, flags);
4230 4231 4232 4233 4234 4235 4236 4237 4238 4239
	}
#endif
}

/*****************************************************************************
 *
 * sysfs attributes
 *
 *****************************************************************************/

4240
#ifdef CONFIG_IWLEGACY_DEBUG
4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252

/*
 * The following adds a new attribute to the sysfs representation
 * of this device driver (i.e. a new file in /sys/class/net/wlan0/device/)
 * used for controlling the debug level.
 *
 * See the level definitions in iwl for details.
 *
 * The debug_level being managed using sysfs below is a per device debug
 * level that is used instead of the global debug level if it (the per
 * device debug level) is set.
 */
4253 4254 4255
static ssize_t
il4965_show_debug_level(struct device *d, struct device_attribute *attr,
			char *buf)
4256
{
S
Stanislaw Gruszka 已提交
4257 4258
	struct il_priv *il = dev_get_drvdata(d);
	return sprintf(buf, "0x%08X\n", il_get_debug_level(il));
4259
}
4260 4261 4262 4263

static ssize_t
il4965_store_debug_level(struct device *d, struct device_attribute *attr,
			 const char *buf, size_t count)
4264
{
S
Stanislaw Gruszka 已提交
4265
	struct il_priv *il = dev_get_drvdata(d);
4266 4267 4268 4269 4270
	unsigned long val;
	int ret;

	ret = strict_strtoul(buf, 0, &val);
	if (ret)
4271
		IL_ERR("%s is not in hex or decimal form.\n", buf);
4272
	else {
S
Stanislaw Gruszka 已提交
4273 4274
		il->debug_level = val;
		if (il_alloc_traffic_mem(il))
4275
			IL_ERR("Not enough memory to generate traffic log\n");
4276 4277 4278 4279
	}
	return strnlen(buf, count);
}

4280 4281
static DEVICE_ATTR(debug_level, S_IWUSR | S_IRUGO, il4965_show_debug_level,
		   il4965_store_debug_level);
4282

4283
#endif /* CONFIG_IWLEGACY_DEBUG */
4284

4285 4286 4287
static ssize_t
il4965_show_temperature(struct device *d, struct device_attribute *attr,
			char *buf)
4288
{
S
Stanislaw Gruszka 已提交
4289
	struct il_priv *il = dev_get_drvdata(d);
4290

S
Stanislaw Gruszka 已提交
4291
	if (!il_is_alive(il))
4292 4293
		return -EAGAIN;

S
Stanislaw Gruszka 已提交
4294
	return sprintf(buf, "%d\n", il->temperature);
4295 4296
}

S
Stanislaw Gruszka 已提交
4297
static DEVICE_ATTR(temperature, S_IRUGO, il4965_show_temperature, NULL);
4298

4299 4300
static ssize_t
il4965_show_tx_power(struct device *d, struct device_attribute *attr, char *buf)
4301
{
S
Stanislaw Gruszka 已提交
4302
	struct il_priv *il = dev_get_drvdata(d);
4303

S
Stanislaw Gruszka 已提交
4304
	if (!il_is_ready_rf(il))
4305 4306
		return sprintf(buf, "off\n");
	else
S
Stanislaw Gruszka 已提交
4307
		return sprintf(buf, "%d\n", il->tx_power_user_lmt);
4308 4309
}

4310 4311 4312
static ssize_t
il4965_store_tx_power(struct device *d, struct device_attribute *attr,
		      const char *buf, size_t count)
4313
{
S
Stanislaw Gruszka 已提交
4314
	struct il_priv *il = dev_get_drvdata(d);
4315 4316 4317 4318 4319
	unsigned long val;
	int ret;

	ret = strict_strtoul(buf, 10, &val);
	if (ret)
4320
		IL_INFO("%s is not in decimal form.\n", buf);
4321
	else {
S
Stanislaw Gruszka 已提交
4322
		ret = il_set_tx_power(il, val, false);
4323
		if (ret)
4324
			IL_ERR("failed setting tx power (0x%d).\n", ret);
4325 4326 4327 4328 4329 4330
		else
			ret = count;
	}
	return ret;
}

4331 4332
static DEVICE_ATTR(tx_power, S_IWUSR | S_IRUGO, il4965_show_tx_power,
		   il4965_store_tx_power);
4333

S
Stanislaw Gruszka 已提交
4334
static struct attribute *il_sysfs_entries[] = {
4335 4336
	&dev_attr_temperature.attr,
	&dev_attr_tx_power.attr,
4337
#ifdef CONFIG_IWLEGACY_DEBUG
4338 4339 4340 4341 4342
	&dev_attr_debug_level.attr,
#endif
	NULL
};

S
Stanislaw Gruszka 已提交
4343
static struct attribute_group il_attribute_group = {
4344
	.name = NULL,		/* put in device directory */
S
Stanislaw Gruszka 已提交
4345
	.attrs = il_sysfs_entries,
4346 4347 4348 4349 4350 4351 4352 4353
};

/******************************************************************************
 *
 * uCode download functions
 *
 ******************************************************************************/

4354 4355
static void
il4965_dealloc_ucode_pci(struct il_priv *il)
4356
{
S
Stanislaw Gruszka 已提交
4357 4358 4359 4360 4361 4362
	il_free_fw_desc(il->pci_dev, &il->ucode_code);
	il_free_fw_desc(il->pci_dev, &il->ucode_data);
	il_free_fw_desc(il->pci_dev, &il->ucode_data_backup);
	il_free_fw_desc(il->pci_dev, &il->ucode_init);
	il_free_fw_desc(il->pci_dev, &il->ucode_init_data);
	il_free_fw_desc(il->pci_dev, &il->ucode_boot);
4363 4364
}

4365 4366
static void
il4965_nic_start(struct il_priv *il)
4367 4368
{
	/* Remove all resets to allow NIC to operate */
4369
	_il_wr(il, CSR_RESET, 0);
4370 4371
}

S
Stanislaw Gruszka 已提交
4372
static void il4965_ucode_callback(const struct firmware *ucode_raw,
4373 4374
				  void *context);
static int il4965_mac_setup_register(struct il_priv *il, u32 max_probe_length);
4375

4376 4377
static int __must_check
il4965_request_firmware(struct il_priv *il, bool first)
4378
{
S
Stanislaw Gruszka 已提交
4379
	const char *name_pre = il->cfg->fw_name_pre;
4380 4381 4382
	char tag[8];

	if (first) {
S
Stanislaw Gruszka 已提交
4383 4384
		il->fw_idx = il->cfg->ucode_api_max;
		sprintf(tag, "%d", il->fw_idx);
4385
	} else {
S
Stanislaw Gruszka 已提交
4386 4387
		il->fw_idx--;
		sprintf(tag, "%d", il->fw_idx);
4388 4389
	}

S
Stanislaw Gruszka 已提交
4390
	if (il->fw_idx < il->cfg->ucode_api_min) {
4391
		IL_ERR("no suitable firmware found!\n");
4392 4393 4394
		return -ENOENT;
	}

S
Stanislaw Gruszka 已提交
4395
	sprintf(il->firmware_name, "%s%s%s", name_pre, tag, ".ucode");
4396

4397
	D_INFO("attempting to load firmware '%s'\n", il->firmware_name);
4398

S
Stanislaw Gruszka 已提交
4399 4400
	return request_firmware_nowait(THIS_MODULE, 1, il->firmware_name,
				       &il->pci_dev->dev, GFP_KERNEL, il,
S
Stanislaw Gruszka 已提交
4401
				       il4965_ucode_callback);
4402 4403
}

S
Stanislaw Gruszka 已提交
4404
struct il4965_firmware_pieces {
4405 4406 4407 4408
	const void *inst, *data, *init, *init_data, *boot;
	size_t inst_size, data_size, init_size, init_data_size, boot_size;
};

4409 4410 4411
static int
il4965_load_firmware(struct il_priv *il, const struct firmware *ucode_raw,
		     struct il4965_firmware_pieces *pieces)
4412
{
S
Stanislaw Gruszka 已提交
4413
	struct il_ucode_header *ucode = (void *)ucode_raw->data;
4414 4415 4416
	u32 api_ver, hdr_size;
	const u8 *src;

S
Stanislaw Gruszka 已提交
4417 4418
	il->ucode_ver = le32_to_cpu(ucode->ver);
	api_ver = IL_UCODE_API(il->ucode_ver);
4419 4420 4421 4422 4423 4424 4425 4426

	switch (api_ver) {
	default:
	case 0:
	case 1:
	case 2:
		hdr_size = 24;
		if (ucode_raw->size < hdr_size) {
4427
			IL_ERR("File size too small!\n");
4428 4429 4430 4431 4432
			return -EINVAL;
		}
		pieces->inst_size = le32_to_cpu(ucode->v1.inst_size);
		pieces->data_size = le32_to_cpu(ucode->v1.data_size);
		pieces->init_size = le32_to_cpu(ucode->v1.init_size);
4433
		pieces->init_data_size = le32_to_cpu(ucode->v1.init_data_size);
4434 4435 4436 4437 4438 4439
		pieces->boot_size = le32_to_cpu(ucode->v1.boot_size);
		src = ucode->v1.data;
		break;
	}

	/* Verify size of file vs. image size info in file's header */
4440 4441 4442
	if (ucode_raw->size !=
	    hdr_size + pieces->inst_size + pieces->data_size +
	    pieces->init_size + pieces->init_data_size + pieces->boot_size) {
4443

4444 4445
		IL_ERR("uCode file size %d does not match expected size\n",
		       (int)ucode_raw->size);
4446 4447 4448 4449 4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463
		return -EINVAL;
	}

	pieces->inst = src;
	src += pieces->inst_size;
	pieces->data = src;
	src += pieces->data_size;
	pieces->init = src;
	src += pieces->init_size;
	pieces->init_data = src;
	src += pieces->init_data_size;
	pieces->boot = src;
	src += pieces->boot_size;

	return 0;
}

/**
S
Stanislaw Gruszka 已提交
4464
 * il4965_ucode_callback - callback when firmware was loaded
4465 4466 4467 4468 4469
 *
 * If loaded successfully, copies the firmware into buffers
 * for the card to fetch (via DMA).
 */
static void
S
Stanislaw Gruszka 已提交
4470
il4965_ucode_callback(const struct firmware *ucode_raw, void *context)
4471
{
S
Stanislaw Gruszka 已提交
4472
	struct il_priv *il = context;
S
Stanislaw Gruszka 已提交
4473
	struct il_ucode_header *ucode;
4474
	int err;
S
Stanislaw Gruszka 已提交
4475
	struct il4965_firmware_pieces pieces;
S
Stanislaw Gruszka 已提交
4476 4477
	const unsigned int api_max = il->cfg->ucode_api_max;
	const unsigned int api_min = il->cfg->ucode_api_min;
4478 4479 4480 4481
	u32 api_ver;

	u32 max_probe_length = 200;
	u32 standard_phy_calibration_size =
4482
	    IL_DEFAULT_STANDARD_PHY_CALIBRATE_TBL_SIZE;
4483 4484 4485 4486

	memset(&pieces, 0, sizeof(pieces));

	if (!ucode_raw) {
S
Stanislaw Gruszka 已提交
4487
		if (il->fw_idx <= il->cfg->ucode_api_max)
4488 4489
			IL_ERR("request for firmware file '%s' failed.\n",
			       il->firmware_name);
4490 4491 4492
		goto try_again;
	}

4493 4494
	D_INFO("Loaded firmware file '%s' (%zd bytes).\n", il->firmware_name,
	       ucode_raw->size);
4495 4496 4497

	/* Make sure that we got at least the API version number */
	if (ucode_raw->size < 4) {
4498
		IL_ERR("File size way too small!\n");
4499 4500 4501 4502
		goto try_again;
	}

	/* Data from ucode file:  header followed by uCode images */
S
Stanislaw Gruszka 已提交
4503
	ucode = (struct il_ucode_header *)ucode_raw->data;
4504

S
Stanislaw Gruszka 已提交
4505
	err = il4965_load_firmware(il, ucode_raw, &pieces);
4506 4507 4508 4509

	if (err)
		goto try_again;

S
Stanislaw Gruszka 已提交
4510
	api_ver = IL_UCODE_API(il->ucode_ver);
4511 4512 4513 4514 4515 4516 4517

	/*
	 * api_ver should match the api version forming part of the
	 * firmware filename ... but we don't check for that and only rely
	 * on the API version read from firmware header from here on forward
	 */
	if (api_ver < api_min || api_ver > api_max) {
4518 4519 4520
		IL_ERR("Driver unable to support your firmware API. "
		       "Driver supports v%u, firmware is v%u.\n", api_max,
		       api_ver);
4521 4522 4523 4524
		goto try_again;
	}

	if (api_ver != api_max)
4525 4526 4527 4528
		IL_ERR("Firmware has old API version. Expected v%u, "
		       "got v%u. New firmware can be obtained "
		       "from http://www.intellinuxwireless.org.\n", api_max,
		       api_ver);
4529

4530
	IL_INFO("loaded firmware version %u.%u.%u.%u\n",
4531 4532
		IL_UCODE_MAJOR(il->ucode_ver), IL_UCODE_MINOR(il->ucode_ver),
		IL_UCODE_API(il->ucode_ver), IL_UCODE_SERIAL(il->ucode_ver));
4533

4534 4535 4536
	snprintf(il->hw->wiphy->fw_version, sizeof(il->hw->wiphy->fw_version),
		 "%u.%u.%u.%u", IL_UCODE_MAJOR(il->ucode_ver),
		 IL_UCODE_MINOR(il->ucode_ver), IL_UCODE_API(il->ucode_ver),
S
Stanislaw Gruszka 已提交
4537
		 IL_UCODE_SERIAL(il->ucode_ver));
4538 4539 4540 4541 4542 4543 4544

	/*
	 * For any of the failures below (before allocating pci memory)
	 * we will try to load a version with a smaller API -- maybe the
	 * user just got a corrupted version of the latest API.
	 */

4545 4546 4547 4548 4549 4550
	D_INFO("f/w package hdr ucode version raw = 0x%x\n", il->ucode_ver);
	D_INFO("f/w package hdr runtime inst size = %Zd\n", pieces.inst_size);
	D_INFO("f/w package hdr runtime data size = %Zd\n", pieces.data_size);
	D_INFO("f/w package hdr init inst size = %Zd\n", pieces.init_size);
	D_INFO("f/w package hdr init data size = %Zd\n", pieces.init_data_size);
	D_INFO("f/w package hdr boot inst size = %Zd\n", pieces.boot_size);
4551 4552

	/* Verify that uCode images will fit in card's SRAM */
S
Stanislaw Gruszka 已提交
4553
	if (pieces.inst_size > il->hw_params.max_inst_size) {
4554
		IL_ERR("uCode instr len %Zd too large to fit in\n",
4555
		       pieces.inst_size);
4556 4557 4558
		goto try_again;
	}

S
Stanislaw Gruszka 已提交
4559
	if (pieces.data_size > il->hw_params.max_data_size) {
4560
		IL_ERR("uCode data len %Zd too large to fit in\n",
4561
		       pieces.data_size);
4562 4563 4564
		goto try_again;
	}

S
Stanislaw Gruszka 已提交
4565
	if (pieces.init_size > il->hw_params.max_inst_size) {
4566
		IL_ERR("uCode init instr len %Zd too large to fit in\n",
4567
		       pieces.init_size);
4568 4569 4570
		goto try_again;
	}

S
Stanislaw Gruszka 已提交
4571
	if (pieces.init_data_size > il->hw_params.max_data_size) {
4572
		IL_ERR("uCode init data len %Zd too large to fit in\n",
4573
		       pieces.init_data_size);
4574 4575 4576
		goto try_again;
	}

S
Stanislaw Gruszka 已提交
4577
	if (pieces.boot_size > il->hw_params.max_bsm_size) {
4578
		IL_ERR("uCode boot instr len %Zd too large to fit in\n",
4579
		       pieces.boot_size);
4580 4581 4582 4583 4584 4585 4586 4587
		goto try_again;
	}

	/* Allocate ucode buffers for card's bus-master loading ... */

	/* Runtime instructions and 2 copies of data:
	 * 1) unmodified from disk
	 * 2) backup cache for save/restore during power-downs */
S
Stanislaw Gruszka 已提交
4588 4589
	il->ucode_code.len = pieces.inst_size;
	il_alloc_fw_desc(il->pci_dev, &il->ucode_code);
4590

S
Stanislaw Gruszka 已提交
4591 4592
	il->ucode_data.len = pieces.data_size;
	il_alloc_fw_desc(il->pci_dev, &il->ucode_data);
4593

S
Stanislaw Gruszka 已提交
4594 4595
	il->ucode_data_backup.len = pieces.data_size;
	il_alloc_fw_desc(il->pci_dev, &il->ucode_data_backup);
4596

S
Stanislaw Gruszka 已提交
4597 4598
	if (!il->ucode_code.v_addr || !il->ucode_data.v_addr ||
	    !il->ucode_data_backup.v_addr)
4599 4600 4601 4602
		goto err_pci_alloc;

	/* Initialization instructions and data */
	if (pieces.init_size && pieces.init_data_size) {
S
Stanislaw Gruszka 已提交
4603 4604
		il->ucode_init.len = pieces.init_size;
		il_alloc_fw_desc(il->pci_dev, &il->ucode_init);
4605

S
Stanislaw Gruszka 已提交
4606 4607
		il->ucode_init_data.len = pieces.init_data_size;
		il_alloc_fw_desc(il->pci_dev, &il->ucode_init_data);
4608

S
Stanislaw Gruszka 已提交
4609
		if (!il->ucode_init.v_addr || !il->ucode_init_data.v_addr)
4610 4611 4612 4613 4614
			goto err_pci_alloc;
	}

	/* Bootstrap (instructions only, no data) */
	if (pieces.boot_size) {
S
Stanislaw Gruszka 已提交
4615 4616
		il->ucode_boot.len = pieces.boot_size;
		il_alloc_fw_desc(il->pci_dev, &il->ucode_boot);
4617

S
Stanislaw Gruszka 已提交
4618
		if (!il->ucode_boot.v_addr)
4619 4620 4621 4622 4623
			goto err_pci_alloc;
	}

	/* Now that we can no longer fail, copy information */

S
Stanislaw Gruszka 已提交
4624
	il->sta_key_max_num = STA_KEY_MAX_NUM;
4625 4626 4627 4628

	/* Copy images into buffers for card's bus-master reads ... */

	/* Runtime instructions (first block of data in file) */
4629
	D_INFO("Copying (but not loading) uCode instr len %Zd\n",
4630
	       pieces.inst_size);
S
Stanislaw Gruszka 已提交
4631
	memcpy(il->ucode_code.v_addr, pieces.inst, pieces.inst_size);
4632

4633
	D_INFO("uCode instr buf vaddr = 0x%p, paddr = 0x%08x\n",
4634
	       il->ucode_code.v_addr, (u32) il->ucode_code.p_addr);
4635 4636 4637

	/*
	 * Runtime data
S
Stanislaw Gruszka 已提交
4638
	 * NOTE:  Copy into backup buffer will be done in il_up()
4639
	 */
4640
	D_INFO("Copying (but not loading) uCode data len %Zd\n",
4641
	       pieces.data_size);
S
Stanislaw Gruszka 已提交
4642 4643
	memcpy(il->ucode_data.v_addr, pieces.data, pieces.data_size);
	memcpy(il->ucode_data_backup.v_addr, pieces.data, pieces.data_size);
4644 4645 4646

	/* Initialization instructions */
	if (pieces.init_size) {
4647 4648
		D_INFO("Copying (but not loading) init instr len %Zd\n",
		       pieces.init_size);
S
Stanislaw Gruszka 已提交
4649
		memcpy(il->ucode_init.v_addr, pieces.init, pieces.init_size);
4650 4651 4652 4653
	}

	/* Initialization data */
	if (pieces.init_data_size) {
4654 4655
		D_INFO("Copying (but not loading) init data len %Zd\n",
		       pieces.init_data_size);
S
Stanislaw Gruszka 已提交
4656
		memcpy(il->ucode_init_data.v_addr, pieces.init_data,
4657 4658 4659 4660
		       pieces.init_data_size);
	}

	/* Bootstrap instructions */
4661
	D_INFO("Copying (but not loading) boot instr len %Zd\n",
4662
	       pieces.boot_size);
S
Stanislaw Gruszka 已提交
4663
	memcpy(il->ucode_boot.v_addr, pieces.boot, pieces.boot_size);
4664 4665 4666 4667 4668

	/*
	 * figure out the offset of chain noise reset and gain commands
	 * base on the size of standard phy calibration commands table size
	 */
S
Stanislaw Gruszka 已提交
4669
	il->_4965.phy_calib_chain_noise_reset_cmd =
4670
	    standard_phy_calibration_size;
S
Stanislaw Gruszka 已提交
4671
	il->_4965.phy_calib_chain_noise_gain_cmd =
4672
	    standard_phy_calibration_size + 1;
4673 4674 4675 4676 4677 4678

	/**************************************************
	 * This is still part of probe() in a sense...
	 *
	 * 9. Setup and register with mac80211 and debugfs
	 **************************************************/
S
Stanislaw Gruszka 已提交
4679
	err = il4965_mac_setup_register(il, max_probe_length);
4680 4681 4682
	if (err)
		goto out_unbind;

S
Stanislaw Gruszka 已提交
4683
	err = il_dbgfs_register(il, DRV_NAME);
4684
	if (err)
4685 4686
		IL_ERR("failed to create debugfs files. Ignoring error: %d\n",
		       err);
4687

4688
	err = sysfs_create_group(&il->pci_dev->dev.kobj, &il_attribute_group);
4689
	if (err) {
4690
		IL_ERR("failed to create sysfs device attributes\n");
4691 4692 4693 4694 4695
		goto out_unbind;
	}

	/* We have our copies now, allow OS release its copies */
	release_firmware(ucode_raw);
S
Stanislaw Gruszka 已提交
4696
	complete(&il->_4965.firmware_loading_complete);
4697 4698
	return;

4699
try_again:
4700
	/* try next, if any */
S
Stanislaw Gruszka 已提交
4701
	if (il4965_request_firmware(il, false))
4702 4703 4704 4705
		goto out_unbind;
	release_firmware(ucode_raw);
	return;

4706
err_pci_alloc:
4707
	IL_ERR("failed to allocate pci memory\n");
S
Stanislaw Gruszka 已提交
4708
	il4965_dealloc_ucode_pci(il);
4709
out_unbind:
S
Stanislaw Gruszka 已提交
4710 4711
	complete(&il->_4965.firmware_loading_complete);
	device_release_driver(&il->pci_dev->dev);
4712 4713 4714
	release_firmware(ucode_raw);
}

4715
static const char *const desc_lookup_text[] = {
4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726
	"OK",
	"FAIL",
	"BAD_PARAM",
	"BAD_CHECKSUM",
	"NMI_INTERRUPT_WDG",
	"SYSASSERT",
	"FATAL_ERROR",
	"BAD_COMMAND",
	"HW_ERROR_TUNE_LOCK",
	"HW_ERROR_TEMPERATURE",
	"ILLEGAL_CHAN_FREQ",
S
Stanislaw Gruszka 已提交
4727
	"VCC_NOT_STBL",
4728
	"FH49_ERROR",
4729 4730 4731 4732 4733 4734 4735 4736 4737 4738
	"NMI_INTERRUPT_HOST",
	"NMI_INTERRUPT_ACTION_PT",
	"NMI_INTERRUPT_UNKNOWN",
	"UCODE_VERSION_MISMATCH",
	"HW_ERROR_ABS_LOCK",
	"HW_ERROR_CAL_LOCK_FAIL",
	"NMI_INTERRUPT_INST_ACTION_PT",
	"NMI_INTERRUPT_DATA_ACTION_PT",
	"NMI_TRM_HW_ER",
	"NMI_INTERRUPT_TRM",
4739
	"NMI_INTERRUPT_BREAK_POINT",
4740 4741 4742 4743 4744 4745
	"DEBUG_0",
	"DEBUG_1",
	"DEBUG_2",
	"DEBUG_3",
};

4746 4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769
static struct {
	char *name;
	u8 num;
} advanced_lookup[] = {
	{
	"NMI_INTERRUPT_WDG", 0x34}, {
	"SYSASSERT", 0x35}, {
	"UCODE_VERSION_MISMATCH", 0x37}, {
	"BAD_COMMAND", 0x38}, {
	"NMI_INTERRUPT_DATA_ACTION_PT", 0x3C}, {
	"FATAL_ERROR", 0x3D}, {
	"NMI_TRM_HW_ERR", 0x46}, {
	"NMI_INTERRUPT_TRM", 0x4C}, {
	"NMI_INTERRUPT_BREAK_POINT", 0x54}, {
	"NMI_INTERRUPT_WDG_RXF_FULL", 0x5C}, {
	"NMI_INTERRUPT_WDG_NO_RBD_RXF_FULL", 0x64}, {
	"NMI_INTERRUPT_HOST", 0x66}, {
	"NMI_INTERRUPT_ACTION_PT", 0x7C}, {
	"NMI_INTERRUPT_UNKNOWN", 0x84}, {
	"NMI_INTERRUPT_INST_ACTION_PT", 0x86}, {
"ADVANCED_SYSASSERT", 0},};

static const char *
il4965_desc_lookup(u32 num)
4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787
{
	int i;
	int max = ARRAY_SIZE(desc_lookup_text);

	if (num < max)
		return desc_lookup_text[num];

	max = ARRAY_SIZE(advanced_lookup) - 1;
	for (i = 0; i < max; i++) {
		if (advanced_lookup[i].num == num)
			break;
	}
	return advanced_lookup[i].name;
}

#define ERROR_START_OFFSET  (1 * sizeof(u32))
#define ERROR_ELEM_SIZE     (7 * sizeof(u32))

4788 4789
void
il4965_dump_nic_error_log(struct il_priv *il)
4790 4791 4792 4793 4794 4795
{
	u32 data2, line;
	u32 desc, time, count, base, data1;
	u32 blink1, blink2, ilink1, ilink2;
	u32 pc, hcmd;

S
Stanislaw Gruszka 已提交
4796
	if (il->ucode_type == UCODE_INIT)
S
Stanislaw Gruszka 已提交
4797
		base = le32_to_cpu(il->card_alive_init.error_event_table_ptr);
S
Stanislaw Gruszka 已提交
4798
	else
S
Stanislaw Gruszka 已提交
4799
		base = le32_to_cpu(il->card_alive.error_event_table_ptr);
4800

S
Stanislaw Gruszka 已提交
4801
	if (!il->cfg->ops->lib->is_valid_rtc_data_addr(base)) {
4802 4803
		IL_ERR("Not valid error log pointer 0x%08X for %s uCode\n",
		       base, (il->ucode_type == UCODE_INIT) ? "Init" : "RT");
4804 4805 4806
		return;
	}

S
Stanislaw Gruszka 已提交
4807
	count = il_read_targ_mem(il, base);
4808 4809

	if (ERROR_START_OFFSET <= count * ERROR_ELEM_SIZE) {
4810
		IL_ERR("Start IWL Error Log Dump:\n");
4811
		IL_ERR("Status: 0x%08lX, count: %d\n", il->status, count);
S
Stanislaw Gruszka 已提交
4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826
	}

	desc = il_read_targ_mem(il, base + 1 * sizeof(u32));
	il->isr_stats.err_code = desc;
	pc = il_read_targ_mem(il, base + 2 * sizeof(u32));
	blink1 = il_read_targ_mem(il, base + 3 * sizeof(u32));
	blink2 = il_read_targ_mem(il, base + 4 * sizeof(u32));
	ilink1 = il_read_targ_mem(il, base + 5 * sizeof(u32));
	ilink2 = il_read_targ_mem(il, base + 6 * sizeof(u32));
	data1 = il_read_targ_mem(il, base + 7 * sizeof(u32));
	data2 = il_read_targ_mem(il, base + 8 * sizeof(u32));
	line = il_read_targ_mem(il, base + 9 * sizeof(u32));
	time = il_read_targ_mem(il, base + 11 * sizeof(u32));
	hcmd = il_read_targ_mem(il, base + 22 * sizeof(u32));

4827
	IL_ERR("Desc                                  Time       "
4828
	       "data1      data2      line\n");
4829
	IL_ERR("%-28s (0x%04X) %010u 0x%08X 0x%08X %u\n",
4830
	       il4965_desc_lookup(desc), desc, time, data1, data2, line);
4831
	IL_ERR("pc      blink1  blink2  ilink1  ilink2  hcmd\n");
4832 4833
	IL_ERR("0x%05X 0x%05X 0x%05X 0x%05X 0x%05X 0x%05X\n", pc, blink1,
	       blink2, ilink1, ilink2, hcmd);
4834 4835
}

4836 4837
static void
il4965_rf_kill_ct_config(struct il_priv *il)
4838
{
S
Stanislaw Gruszka 已提交
4839
	struct il_ct_kill_config cmd;
4840 4841 4842
	unsigned long flags;
	int ret = 0;

S
Stanislaw Gruszka 已提交
4843
	spin_lock_irqsave(&il->lock, flags);
4844
	_il_wr(il, CSR_UCODE_DRV_GP1_CLR,
4845
	       CSR_UCODE_DRV_GP1_REG_BIT_CT_KILL_EXIT);
S
Stanislaw Gruszka 已提交
4846
	spin_unlock_irqrestore(&il->lock, flags);
4847 4848

	cmd.critical_temperature_R =
4849
	    cpu_to_le32(il->hw_params.ct_kill_threshold);
4850

4851
	ret = il_send_cmd_pdu(il, C_CT_KILL_CONFIG, sizeof(cmd), &cmd);
4852
	if (ret)
4853
		IL_ERR("C_CT_KILL_CONFIG failed\n");
4854
	else
4855 4856 4857
		D_INFO("C_CT_KILL_CONFIG " "succeeded, "
		       "critical temperature is %d\n",
		       il->hw_params.ct_kill_threshold);
4858 4859 4860
}

static const s8 default_queue_to_tx_fifo[] = {
S
Stanislaw Gruszka 已提交
4861 4862 4863 4864
	IL_TX_FIFO_VO,
	IL_TX_FIFO_VI,
	IL_TX_FIFO_BE,
	IL_TX_FIFO_BK,
4865
	IL49_CMD_FIFO_NUM,
S
Stanislaw Gruszka 已提交
4866 4867
	IL_TX_FIFO_UNUSED,
	IL_TX_FIFO_UNUSED,
4868 4869
};

S
Stanislaw Gruszka 已提交
4870 4871
#define IL_MASK(lo, hi) ((1 << (hi)) | ((1 << (hi)) - (1 << (lo))))

4872 4873
static int
il4965_alive_notify(struct il_priv *il)
4874 4875 4876 4877 4878 4879
{
	u32 a;
	unsigned long flags;
	int i, chan;
	u32 reg_val;

S
Stanislaw Gruszka 已提交
4880
	spin_lock_irqsave(&il->lock, flags);
4881 4882

	/* Clear 4965's internal Tx Scheduler data base */
4883
	il->scd_base_addr = il_rd_prph(il, IL49_SCD_SRAM_BASE_ADDR);
4884 4885
	a = il->scd_base_addr + IL49_SCD_CONTEXT_DATA_OFFSET;
	for (; a < il->scd_base_addr + IL49_SCD_TX_STTS_BITMAP_OFFSET; a += 4)
S
Stanislaw Gruszka 已提交
4886
		il_write_targ_mem(il, a, 0);
4887
	for (; a < il->scd_base_addr + IL49_SCD_TRANSLATE_TBL_OFFSET; a += 4)
S
Stanislaw Gruszka 已提交
4888
		il_write_targ_mem(il, a, 0);
4889 4890 4891 4892 4893
	for (;
	     a <
	     il->scd_base_addr +
	     IL49_SCD_TRANSLATE_TBL_OFFSET_QUEUE(il->hw_params.max_txq_num);
	     a += 4)
S
Stanislaw Gruszka 已提交
4894
		il_write_targ_mem(il, a, 0);
4895 4896

	/* Tel 4965 where to find Tx byte count tables */
4897
	il_wr_prph(il, IL49_SCD_DRAM_BASE_ADDR, il->scd_bc_tbls.dma >> 10);
4898 4899

	/* Enable DMA channel */
4900 4901 4902 4903
	for (chan = 0; chan < FH49_TCSR_CHNL_NUM; chan++)
		il_wr(il, FH49_TCSR_CHNL_TX_CONFIG_REG(chan),
		      FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CHNL_ENABLE |
		      FH49_TCSR_TX_CONFIG_REG_VAL_DMA_CREDIT_ENABLE);
4904 4905

	/* Update FH chicken bits */
4906 4907
	reg_val = il_rd(il, FH49_TX_CHICKEN_BITS_REG);
	il_wr(il, FH49_TX_CHICKEN_BITS_REG,
4908
	      reg_val | FH49_TX_CHICKEN_BITS_SCD_AUTO_RETRY_EN);
4909 4910

	/* Disable chain mode for all queues */
4911
	il_wr_prph(il, IL49_SCD_QUEUECHAIN_SEL, 0);
4912 4913

	/* Initialize each Tx queue (including the command queue) */
S
Stanislaw Gruszka 已提交
4914
	for (i = 0; i < il->hw_params.max_txq_num; i++) {
4915

S
Stanislaw Gruszka 已提交
4916
		/* TFD circular buffer read/write idxes */
4917
		il_wr_prph(il, IL49_SCD_QUEUE_RDPTR(i), 0);
4918
		il_wr(il, HBUS_TARG_WRPTR, 0 | (i << 8));
4919 4920

		/* Max Tx Window size for Scheduler-ACK mode */
4921 4922 4923 4924 4925 4926
		il_write_targ_mem(il,
				  il->scd_base_addr +
				  IL49_SCD_CONTEXT_QUEUE_OFFSET(i),
				  (SCD_WIN_SIZE <<
				   IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_POS) &
				  IL49_SCD_QUEUE_CTX_REG1_WIN_SIZE_MSK);
4927 4928

		/* Frame limit */
4929 4930 4931 4932 4933 4934 4935
		il_write_targ_mem(il,
				  il->scd_base_addr +
				  IL49_SCD_CONTEXT_QUEUE_OFFSET(i) +
				  sizeof(u32),
				  (SCD_FRAME_LIMIT <<
				   IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_POS) &
				  IL49_SCD_QUEUE_CTX_REG2_FRAME_LIMIT_MSK);
4936 4937

	}
4938
	il_wr_prph(il, IL49_SCD_INTERRUPT_MASK,
4939
		   (1 << il->hw_params.max_txq_num) - 1);
4940 4941

	/* Activate all Tx DMA/FIFO channels */
S
Stanislaw Gruszka 已提交
4942
	il4965_txq_set_sched(il, IL_MASK(0, 6));
4943

S
Stanislaw Gruszka 已提交
4944
	il4965_set_wr_ptrs(il, IL_DEFAULT_CMD_QUEUE_NUM, 0);
4945 4946

	/* make sure all queue are not stopped */
S
Stanislaw Gruszka 已提交
4947
	memset(&il->queue_stopped[0], 0, sizeof(il->queue_stopped));
4948
	for (i = 0; i < 4; i++)
S
Stanislaw Gruszka 已提交
4949
		atomic_set(&il->queue_stop_count[i], 0);
4950 4951

	/* reset to 0 to enable all the queue first */
S
Stanislaw Gruszka 已提交
4952
	il->txq_ctx_active_msk = 0;
4953 4954 4955 4956 4957 4958
	/* Map each Tx/cmd queue to its corresponding fifo */
	BUILD_BUG_ON(ARRAY_SIZE(default_queue_to_tx_fifo) != 7);

	for (i = 0; i < ARRAY_SIZE(default_queue_to_tx_fifo); i++) {
		int ac = default_queue_to_tx_fifo[i];

S
Stanislaw Gruszka 已提交
4959
		il_txq_ctx_activate(il, i);
4960

S
Stanislaw Gruszka 已提交
4961
		if (ac == IL_TX_FIFO_UNUSED)
4962 4963
			continue;

S
Stanislaw Gruszka 已提交
4964
		il4965_tx_queue_set_status(il, &il->txq[i], ac, 0);
4965 4966
	}

S
Stanislaw Gruszka 已提交
4967
	spin_unlock_irqrestore(&il->lock, flags);
4968 4969 4970 4971 4972

	return 0;
}

/**
4973
 * il4965_alive_start - called after N_ALIVE notification received
4974
 *                   from protocol/runtime uCode (initialization uCode's
S
Stanislaw Gruszka 已提交
4975
 *                   Alive gets handled by il_init_alive_start()).
4976
 */
4977 4978
static void
il4965_alive_start(struct il_priv *il)
4979 4980
{
	int ret = 0;
4981
	struct il_rxon_context *ctx = &il->ctx;
4982

4983
	D_INFO("Runtime Alive received.\n");
4984

S
Stanislaw Gruszka 已提交
4985
	if (il->card_alive.is_valid != UCODE_VALID_OK) {
4986 4987
		/* We had an error bringing up the hardware, so take it
		 * all the way back down so we can try again */
4988
		D_INFO("Alive failed.\n");
4989 4990 4991 4992 4993 4994
		goto restart;
	}

	/* Initialize uCode has loaded Runtime uCode ... verify inst image.
	 * This is a paranoid check, because we would not have gotten the
	 * "runtime" alive if code weren't properly loaded.  */
S
Stanislaw Gruszka 已提交
4995
	if (il4965_verify_ucode(il)) {
4996 4997
		/* Runtime instruction load was bad;
		 * take it all the way back down so we can try again */
4998
		D_INFO("Bad runtime uCode load.\n");
4999 5000 5001
		goto restart;
	}

S
Stanislaw Gruszka 已提交
5002
	ret = il4965_alive_notify(il);
5003
	if (ret) {
5004
		IL_WARN("Could not complete ALIVE transition [ntf]: %d\n", ret);
5005 5006 5007 5008
		goto restart;
	}

	/* After the ALIVE response, we can send host commands to the uCode */
S
Stanislaw Gruszka 已提交
5009
	set_bit(S_ALIVE, &il->status);
5010 5011

	/* Enable watchdog to monitor the driver tx queues */
S
Stanislaw Gruszka 已提交
5012
	il_setup_watchdog(il);
5013

S
Stanislaw Gruszka 已提交
5014
	if (il_is_rfkill(il))
5015 5016
		return;

S
Stanislaw Gruszka 已提交
5017
	ieee80211_wake_queues(il->hw);
5018

S
Stanislaw Gruszka 已提交
5019
	il->active_rate = RATES_MASK;
5020

5021
	if (il_is_associated(il)) {
S
Stanislaw Gruszka 已提交
5022
		struct il_rxon_cmd *active_rxon =
5023
		    (struct il_rxon_cmd *)&il->active;
5024
		/* apply any changes in staging */
5025
		il->staging.filter_flags |= RXON_FILTER_ASSOC_MSK;
5026 5027 5028
		active_rxon->filter_flags &= ~RXON_FILTER_ASSOC_MSK;
	} else {
		/* Initialize our rx_config data */
5029
		il_connection_init_rx_config(il, &il->ctx);
5030

S
Stanislaw Gruszka 已提交
5031 5032
		if (il->cfg->ops->hcmd->set_rxon_chain)
			il->cfg->ops->hcmd->set_rxon_chain(il, ctx);
5033 5034 5035
	}

	/* Configure bluetooth coexistence if enabled */
S
Stanislaw Gruszka 已提交
5036
	il_send_bt_config(il);
5037

S
Stanislaw Gruszka 已提交
5038
	il4965_reset_run_time_calib(il);
5039

S
Stanislaw Gruszka 已提交
5040
	set_bit(S_READY, &il->status);
5041 5042

	/* Configure the adapter for unassociated operation */
S
Stanislaw Gruszka 已提交
5043
	il_commit_rxon(il, ctx);
5044 5045

	/* At this point, the NIC is initialized and operational */
S
Stanislaw Gruszka 已提交
5046
	il4965_rf_kill_ct_config(il);
5047

5048
	D_INFO("ALIVE processing complete.\n");
S
Stanislaw Gruszka 已提交
5049
	wake_up(&il->wait_command_queue);
5050

S
Stanislaw Gruszka 已提交
5051
	il_power_update_mode(il, true);
5052
	D_INFO("Updated power mode\n");
5053 5054 5055

	return;

5056
restart:
S
Stanislaw Gruszka 已提交
5057
	queue_work(il->workqueue, &il->restart);
5058 5059
}

S
Stanislaw Gruszka 已提交
5060
static void il4965_cancel_deferred_work(struct il_priv *il);
5061

5062 5063
static void
__il4965_down(struct il_priv *il)
5064 5065
{
	unsigned long flags;
5066
	int exit_pending;
5067

5068
	D_INFO(DRV_NAME " is going down\n");
5069

S
Stanislaw Gruszka 已提交
5070
	il_scan_cancel_timeout(il, 200);
5071

S
Stanislaw Gruszka 已提交
5072
	exit_pending = test_and_set_bit(S_EXIT_PENDING, &il->status);
5073

S
Stanislaw Gruszka 已提交
5074
	/* Stop TX queues watchdog. We need to have S_EXIT_PENDING bit set
5075
	 * to prevent rearm timer */
S
Stanislaw Gruszka 已提交
5076
	del_timer_sync(&il->watchdog);
5077

S
Stanislaw Gruszka 已提交
5078 5079 5080
	il_clear_ucode_stations(il, NULL);
	il_dealloc_bcast_stations(il);
	il_clear_driver_stations(il);
5081 5082

	/* Unblock any waiting calls */
S
Stanislaw Gruszka 已提交
5083
	wake_up_all(&il->wait_command_queue);
5084 5085 5086 5087

	/* Wipe out the EXIT_PENDING status bit if we are not actually
	 * exiting the module */
	if (!exit_pending)
S
Stanislaw Gruszka 已提交
5088
		clear_bit(S_EXIT_PENDING, &il->status);
5089 5090

	/* stop and reset the on-board processor */
5091
	_il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
5092 5093

	/* tell the device to stop sending interrupts */
S
Stanislaw Gruszka 已提交
5094 5095 5096 5097
	spin_lock_irqsave(&il->lock, flags);
	il_disable_interrupts(il);
	spin_unlock_irqrestore(&il->lock, flags);
	il4965_synchronize_irq(il);
5098

S
Stanislaw Gruszka 已提交
5099 5100
	if (il->mac80211_registered)
		ieee80211_stop_queues(il->hw);
5101

S
Stanislaw Gruszka 已提交
5102
	/* If we have not previously called il_init() then
5103
	 * clear all bits but the RF Kill bit and return */
S
Stanislaw Gruszka 已提交
5104
	if (!il_is_init(il)) {
5105 5106 5107 5108 5109 5110 5111 5112
		il->status =
		    test_bit(S_RF_KILL_HW,
			     &il->
			     status) << S_RF_KILL_HW |
		    test_bit(S_GEO_CONFIGURED,
			     &il->
			     status) << S_GEO_CONFIGURED |
		    test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
5113 5114 5115 5116 5117
		goto exit;
	}

	/* ...otherwise clear out all the status bits but the RF Kill
	 * bit and continue taking the NIC down. */
5118 5119 5120 5121 5122 5123 5124 5125 5126
	il->status &=
	    test_bit(S_RF_KILL_HW,
		     &il->status) << S_RF_KILL_HW | test_bit(S_GEO_CONFIGURED,
							     &il->
							     status) <<
	    S_GEO_CONFIGURED | test_bit(S_FW_ERROR,
					&il->
					status) << S_FW_ERROR |
	    test_bit(S_EXIT_PENDING, &il->status) << S_EXIT_PENDING;
5127

S
Stanislaw Gruszka 已提交
5128 5129
	il4965_txq_ctx_stop(il);
	il4965_rxq_stop(il);
5130 5131

	/* Power-down device's busmaster DMA clocks */
5132
	il_wr_prph(il, APMG_CLK_DIS_REG, APMG_CLK_VAL_DMA_CLK_RQT);
5133 5134 5135
	udelay(5);

	/* Make sure (redundant) we've released our request to stay awake */
5136
	il_clear_bit(il, CSR_GP_CNTRL, CSR_GP_CNTRL_REG_FLAG_MAC_ACCESS_REQ);
5137 5138

	/* Stop the device, and put it in low power state */
S
Stanislaw Gruszka 已提交
5139
	il_apm_stop(il);
5140

5141
exit:
S
Stanislaw Gruszka 已提交
5142
	memset(&il->card_alive, 0, sizeof(struct il_alive_resp));
5143

S
Stanislaw Gruszka 已提交
5144 5145
	dev_kfree_skb(il->beacon_skb);
	il->beacon_skb = NULL;
5146 5147

	/* clear out any free frames */
S
Stanislaw Gruszka 已提交
5148
	il4965_clear_free_frames(il);
5149 5150
}

5151 5152
static void
il4965_down(struct il_priv *il)
5153
{
S
Stanislaw Gruszka 已提交
5154 5155 5156
	mutex_lock(&il->mutex);
	__il4965_down(il);
	mutex_unlock(&il->mutex);
5157

S
Stanislaw Gruszka 已提交
5158
	il4965_cancel_deferred_work(il);
5159 5160 5161 5162
}

#define HW_READY_TIMEOUT (50)

5163 5164
static int
il4965_set_hw_ready(struct il_priv *il)
5165 5166 5167
{
	int ret = 0;

S
Stanislaw Gruszka 已提交
5168
	il_set_bit(il, CSR_HW_IF_CONFIG_REG,
5169
		   CSR_HW_IF_CONFIG_REG_BIT_NIC_READY);
5170 5171

	/* See if we got it */
5172 5173 5174 5175
	ret =
	    _il_poll_bit(il, CSR_HW_IF_CONFIG_REG,
			 CSR_HW_IF_CONFIG_REG_BIT_NIC_READY,
			 CSR_HW_IF_CONFIG_REG_BIT_NIC_READY, HW_READY_TIMEOUT);
5176
	if (ret != -ETIMEDOUT)
S
Stanislaw Gruszka 已提交
5177
		il->hw_ready = true;
5178
	else
S
Stanislaw Gruszka 已提交
5179
		il->hw_ready = false;
5180

5181
	D_INFO("hardware %s\n", (il->hw_ready == 1) ? "ready" : "not ready");
5182 5183 5184
	return ret;
}

5185 5186
static int
il4965_prepare_card_hw(struct il_priv *il)
5187 5188 5189
{
	int ret = 0;

5190
	D_INFO("il4965_prepare_card_hw enter\n");
5191

S
Stanislaw Gruszka 已提交
5192 5193
	ret = il4965_set_hw_ready(il);
	if (il->hw_ready)
5194 5195 5196
		return ret;

	/* If HW is not ready, prepare the conditions to check again */
5197
	il_set_bit(il, CSR_HW_IF_CONFIG_REG, CSR_HW_IF_CONFIG_REG_PREPARE);
5198

5199 5200 5201 5202
	ret =
	    _il_poll_bit(il, CSR_HW_IF_CONFIG_REG,
			 ~CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE,
			 CSR_HW_IF_CONFIG_REG_BIT_NIC_PREPARE_DONE, 150000);
5203 5204 5205

	/* HW should be ready by now, check again. */
	if (ret != -ETIMEDOUT)
S
Stanislaw Gruszka 已提交
5206
		il4965_set_hw_ready(il);
5207 5208 5209 5210 5211 5212

	return ret;
}

#define MAX_HW_RESTARTS 5

5213 5214
static int
__il4965_up(struct il_priv *il)
5215 5216 5217 5218
{
	int i;
	int ret;

S
Stanislaw Gruszka 已提交
5219
	if (test_bit(S_EXIT_PENDING, &il->status)) {
5220
		IL_WARN("Exit pending; will not bring the NIC up\n");
5221 5222 5223
		return -EIO;
	}

S
Stanislaw Gruszka 已提交
5224
	if (!il->ucode_data_backup.v_addr || !il->ucode_data.v_addr) {
5225
		IL_ERR("ucode not available for device bringup\n");
5226 5227 5228
		return -EIO;
	}

5229 5230 5231 5232
	ret = il4965_alloc_bcast_station(il, &il->ctx);
	if (ret) {
		il_dealloc_bcast_stations(il);
		return ret;
5233 5234
	}

S
Stanislaw Gruszka 已提交
5235
	il4965_prepare_card_hw(il);
5236

S
Stanislaw Gruszka 已提交
5237
	if (!il->hw_ready) {
5238
		IL_WARN("Exit HW not ready\n");
5239 5240 5241 5242
		return -EIO;
	}

	/* If platform's RF_KILL switch is NOT set to KILL */
5243
	if (_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
S
Stanislaw Gruszka 已提交
5244
		clear_bit(S_RF_KILL_HW, &il->status);
5245
	else
S
Stanislaw Gruszka 已提交
5246
		set_bit(S_RF_KILL_HW, &il->status);
5247

S
Stanislaw Gruszka 已提交
5248 5249
	if (il_is_rfkill(il)) {
		wiphy_rfkill_set_hw_state(il->hw->wiphy, true);
5250

S
Stanislaw Gruszka 已提交
5251
		il_enable_interrupts(il);
5252
		IL_WARN("Radio disabled by HW RF Kill switch\n");
5253 5254 5255
		return 0;
	}

5256
	_il_wr(il, CSR_INT, 0xFFFFFFFF);
5257

S
Stanislaw Gruszka 已提交
5258
	/* must be initialised before il_hw_nic_init */
S
Stanislaw Gruszka 已提交
5259
	il->cmd_queue = IL_DEFAULT_CMD_QUEUE_NUM;
5260

S
Stanislaw Gruszka 已提交
5261
	ret = il4965_hw_nic_init(il);
5262
	if (ret) {
5263
		IL_ERR("Unable to init nic\n");
5264 5265 5266 5267
		return ret;
	}

	/* make sure rfkill handshake bits are cleared */
5268
	_il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
5269
	_il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_DRV_GP1_BIT_CMD_BLOCKED);
5270 5271

	/* clear (again), then enable host interrupts */
5272
	_il_wr(il, CSR_INT, 0xFFFFFFFF);
S
Stanislaw Gruszka 已提交
5273
	il_enable_interrupts(il);
5274 5275

	/* really make sure rfkill handshake bits are cleared */
5276 5277
	_il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
	_il_wr(il, CSR_UCODE_DRV_GP1_CLR, CSR_UCODE_SW_BIT_RFKILL);
5278 5279 5280 5281

	/* Copy original ucode data image from disk into backup cache.
	 * This will be used to initialize the on-board processor's
	 * data SRAM for a clean start when the runtime program first loads. */
S
Stanislaw Gruszka 已提交
5282 5283
	memcpy(il->ucode_data_backup.v_addr, il->ucode_data.v_addr,
	       il->ucode_data.len);
5284 5285 5286 5287 5288 5289

	for (i = 0; i < MAX_HW_RESTARTS; i++) {

		/* load bootstrap state machine,
		 * load bootstrap program into processor's memory,
		 * prepare to load the "initialize" uCode */
S
Stanislaw Gruszka 已提交
5290
		ret = il->cfg->ops->lib->load_ucode(il);
5291 5292

		if (ret) {
5293
			IL_ERR("Unable to set up bootstrap uCode: %d\n", ret);
5294 5295 5296 5297
			continue;
		}

		/* start card; "initialize" will load runtime ucode */
S
Stanislaw Gruszka 已提交
5298
		il4965_nic_start(il);
5299

5300
		D_INFO(DRV_NAME " is coming up\n");
5301 5302 5303 5304

		return 0;
	}

S
Stanislaw Gruszka 已提交
5305
	set_bit(S_EXIT_PENDING, &il->status);
S
Stanislaw Gruszka 已提交
5306
	__il4965_down(il);
S
Stanislaw Gruszka 已提交
5307
	clear_bit(S_EXIT_PENDING, &il->status);
5308 5309 5310

	/* tried to restart and config the device for as long as our
	 * patience could withstand */
5311
	IL_ERR("Unable to initialize device after %d attempts.\n", i);
5312 5313 5314 5315 5316 5317 5318 5319 5320
	return -EIO;
}

/*****************************************************************************
 *
 * Workqueue callbacks
 *
 *****************************************************************************/

5321 5322
static void
il4965_bg_init_alive_start(struct work_struct *data)
5323
{
S
Stanislaw Gruszka 已提交
5324
	struct il_priv *il =
S
Stanislaw Gruszka 已提交
5325
	    container_of(data, struct il_priv, init_alive_start.work);
5326

S
Stanislaw Gruszka 已提交
5327
	mutex_lock(&il->mutex);
S
Stanislaw Gruszka 已提交
5328
	if (test_bit(S_EXIT_PENDING, &il->status))
5329
		goto out;
5330

S
Stanislaw Gruszka 已提交
5331
	il->cfg->ops->lib->init_alive_start(il);
5332
out:
S
Stanislaw Gruszka 已提交
5333
	mutex_unlock(&il->mutex);
5334 5335
}

5336 5337
static void
il4965_bg_alive_start(struct work_struct *data)
5338
{
S
Stanislaw Gruszka 已提交
5339
	struct il_priv *il =
S
Stanislaw Gruszka 已提交
5340
	    container_of(data, struct il_priv, alive_start.work);
5341

S
Stanislaw Gruszka 已提交
5342
	mutex_lock(&il->mutex);
S
Stanislaw Gruszka 已提交
5343
	if (test_bit(S_EXIT_PENDING, &il->status))
5344
		goto out;
5345

S
Stanislaw Gruszka 已提交
5346
	il4965_alive_start(il);
5347
out:
S
Stanislaw Gruszka 已提交
5348
	mutex_unlock(&il->mutex);
5349 5350
}

5351 5352
static void
il4965_bg_run_time_calib_work(struct work_struct *work)
5353
{
S
Stanislaw Gruszka 已提交
5354
	struct il_priv *il = container_of(work, struct il_priv,
5355
					  run_time_calib_work);
5356

S
Stanislaw Gruszka 已提交
5357
	mutex_lock(&il->mutex);
5358

S
Stanislaw Gruszka 已提交
5359 5360
	if (test_bit(S_EXIT_PENDING, &il->status) ||
	    test_bit(S_SCANNING, &il->status)) {
S
Stanislaw Gruszka 已提交
5361
		mutex_unlock(&il->mutex);
5362 5363 5364
		return;
	}

S
Stanislaw Gruszka 已提交
5365
	if (il->start_calib) {
5366 5367
		il4965_chain_noise_calibration(il, (void *)&il->_4965.stats);
		il4965_sensitivity_calibration(il, (void *)&il->_4965.stats);
5368 5369
	}

S
Stanislaw Gruszka 已提交
5370
	mutex_unlock(&il->mutex);
5371 5372
}

5373 5374
static void
il4965_bg_restart(struct work_struct *data)
5375
{
S
Stanislaw Gruszka 已提交
5376
	struct il_priv *il = container_of(data, struct il_priv, restart);
5377

S
Stanislaw Gruszka 已提交
5378
	if (test_bit(S_EXIT_PENDING, &il->status))
5379 5380
		return;

S
Stanislaw Gruszka 已提交
5381
	if (test_and_clear_bit(S_FW_ERROR, &il->status)) {
S
Stanislaw Gruszka 已提交
5382
		mutex_lock(&il->mutex);
5383
		il->ctx.vif = NULL;
S
Stanislaw Gruszka 已提交
5384
		il->is_open = 0;
5385

S
Stanislaw Gruszka 已提交
5386
		__il4965_down(il);
5387

S
Stanislaw Gruszka 已提交
5388 5389 5390
		mutex_unlock(&il->mutex);
		il4965_cancel_deferred_work(il);
		ieee80211_restart_hw(il->hw);
5391
	} else {
S
Stanislaw Gruszka 已提交
5392
		il4965_down(il);
5393

S
Stanislaw Gruszka 已提交
5394
		mutex_lock(&il->mutex);
S
Stanislaw Gruszka 已提交
5395
		if (test_bit(S_EXIT_PENDING, &il->status)) {
S
Stanislaw Gruszka 已提交
5396
			mutex_unlock(&il->mutex);
5397
			return;
5398
		}
5399

S
Stanislaw Gruszka 已提交
5400 5401
		__il4965_up(il);
		mutex_unlock(&il->mutex);
5402 5403 5404
	}
}

5405 5406
static void
il4965_bg_rx_replenish(struct work_struct *data)
5407
{
5408
	struct il_priv *il = container_of(data, struct il_priv, rx_replenish);
5409

S
Stanislaw Gruszka 已提交
5410
	if (test_bit(S_EXIT_PENDING, &il->status))
5411 5412
		return;

S
Stanislaw Gruszka 已提交
5413 5414 5415
	mutex_lock(&il->mutex);
	il4965_rx_replenish(il);
	mutex_unlock(&il->mutex);
5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429
}

/*****************************************************************************
 *
 * mac80211 entry point functions
 *
 *****************************************************************************/

#define UCODE_READY_TIMEOUT	(4 * HZ)

/*
 * Not a mac80211 entry point function, but it fits in with all the
 * other mac80211 functions grouped here.
 */
5430 5431
static int
il4965_mac_setup_register(struct il_priv *il, u32 max_probe_length)
5432 5433
{
	int ret;
S
Stanislaw Gruszka 已提交
5434
	struct ieee80211_hw *hw = il->hw;
5435 5436 5437 5438

	hw->rate_control_algorithm = "iwl-4965-rs";

	/* Tell mac80211 our characteristics */
5439 5440 5441 5442
	hw->flags =
	    IEEE80211_HW_SIGNAL_DBM | IEEE80211_HW_AMPDU_AGGREGATION |
	    IEEE80211_HW_NEED_DTIM_PERIOD | IEEE80211_HW_SPECTRUM_MGMT |
	    IEEE80211_HW_REPORTS_TX_ACK_STATUS;
5443

S
Stanislaw Gruszka 已提交
5444
	if (il->cfg->sku & IL_SKU_N)
5445 5446 5447
		hw->flags |=
		    IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS |
		    IEEE80211_HW_SUPPORTS_STATIC_SMPS;
5448

S
Stanislaw Gruszka 已提交
5449 5450
	hw->sta_data_size = sizeof(struct il_station_priv);
	hw->vif_data_size = sizeof(struct il_vif_priv);
5451

5452 5453
	hw->wiphy->interface_modes |= il->ctx.interface_modes;
	hw->wiphy->interface_modes |= il->ctx.exclusive_interface_modes;
5454

5455 5456
	hw->wiphy->flags |=
	    WIPHY_FLAG_CUSTOM_REGULATORY | WIPHY_FLAG_DISABLE_BEACON_HINTS;
5457 5458 5459 5460 5461 5462 5463 5464 5465 5466 5467 5468 5469 5470

	/*
	 * For now, disable PS by default because it affects
	 * RX performance significantly.
	 */
	hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;

	hw->wiphy->max_scan_ssids = PROBE_OPTION_MAX;
	/* we create the 802.11 header and a zero-length SSID element */
	hw->wiphy->max_scan_ie_len = max_probe_length - 24 - 2;

	/* Default value; 4 EDCA QOS priorities */
	hw->queues = 4;

S
Stanislaw Gruszka 已提交
5471
	hw->max_listen_interval = IL_CONN_MAX_LISTEN_INTERVAL;
5472

S
Stanislaw Gruszka 已提交
5473 5474
	if (il->bands[IEEE80211_BAND_2GHZ].n_channels)
		il->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
5475
		    &il->bands[IEEE80211_BAND_2GHZ];
S
Stanislaw Gruszka 已提交
5476 5477
	if (il->bands[IEEE80211_BAND_5GHZ].n_channels)
		il->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
5478
		    &il->bands[IEEE80211_BAND_5GHZ];
5479

S
Stanislaw Gruszka 已提交
5480
	il_leds_init(il);
5481

S
Stanislaw Gruszka 已提交
5482
	ret = ieee80211_register_hw(il->hw);
5483
	if (ret) {
5484
		IL_ERR("Failed to register hw (error %d)\n", ret);
5485 5486
		return ret;
	}
S
Stanislaw Gruszka 已提交
5487
	il->mac80211_registered = 1;
5488 5489 5490 5491

	return 0;
}

5492 5493
int
il4965_mac_start(struct ieee80211_hw *hw)
5494
{
S
Stanislaw Gruszka 已提交
5495
	struct il_priv *il = hw->priv;
5496 5497
	int ret;

5498
	D_MAC80211("enter\n");
5499 5500

	/* we should be verifying the device is ready to be opened */
S
Stanislaw Gruszka 已提交
5501 5502 5503
	mutex_lock(&il->mutex);
	ret = __il4965_up(il);
	mutex_unlock(&il->mutex);
5504 5505 5506 5507

	if (ret)
		return ret;

S
Stanislaw Gruszka 已提交
5508
	if (il_is_rfkill(il))
5509 5510
		goto out;

5511
	D_INFO("Start UP work done.\n");
5512 5513 5514

	/* Wait for START_ALIVE from Run Time ucode. Otherwise callbacks from
	 * mac80211 will not be run successfully. */
S
Stanislaw Gruszka 已提交
5515
	ret = wait_event_timeout(il->wait_command_queue,
5516 5517
				 test_bit(S_READY, &il->status),
				 UCODE_READY_TIMEOUT);
5518
	if (!ret) {
S
Stanislaw Gruszka 已提交
5519
		if (!test_bit(S_READY, &il->status)) {
5520
			IL_ERR("START_ALIVE timeout after %dms.\n",
5521 5522 5523 5524 5525
				jiffies_to_msecs(UCODE_READY_TIMEOUT));
			return -ETIMEDOUT;
		}
	}

S
Stanislaw Gruszka 已提交
5526
	il4965_led_enable(il);
5527 5528

out:
S
Stanislaw Gruszka 已提交
5529
	il->is_open = 1;
5530
	D_MAC80211("leave\n");
5531 5532 5533
	return 0;
}

5534 5535
void
il4965_mac_stop(struct ieee80211_hw *hw)
5536
{
S
Stanislaw Gruszka 已提交
5537
	struct il_priv *il = hw->priv;
5538

5539
	D_MAC80211("enter\n");
5540

S
Stanislaw Gruszka 已提交
5541
	if (!il->is_open)
5542 5543
		return;

S
Stanislaw Gruszka 已提交
5544
	il->is_open = 0;
5545

S
Stanislaw Gruszka 已提交
5546
	il4965_down(il);
5547

S
Stanislaw Gruszka 已提交
5548
	flush_workqueue(il->workqueue);
5549

5550 5551
	/* User space software may expect getting rfkill changes
	 * even if interface is down */
5552
	_il_wr(il, CSR_INT, 0xFFFFFFFF);
S
Stanislaw Gruszka 已提交
5553
	il_enable_rfkill_int(il);
5554

5555
	D_MAC80211("leave\n");
5556 5557
}

5558 5559
void
il4965_mac_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
5560
{
S
Stanislaw Gruszka 已提交
5561
	struct il_priv *il = hw->priv;
5562

5563
	D_MACDUMP("enter\n");
5564

5565
	D_TX("dev->xmit(%d bytes) at rate 0x%02x\n", skb->len,
5566
	     ieee80211_get_tx_rate(hw, IEEE80211_SKB_CB(skb))->bitrate);
5567

S
Stanislaw Gruszka 已提交
5568
	if (il4965_tx_skb(il, skb))
5569 5570
		dev_kfree_skb_any(skb);

5571
	D_MACDUMP("leave\n");
5572 5573
}

5574 5575 5576 5577
void
il4965_mac_update_tkip_key(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			   struct ieee80211_key_conf *keyconf,
			   struct ieee80211_sta *sta, u32 iv32, u16 * phase1key)
5578
{
S
Stanislaw Gruszka 已提交
5579
	struct il_priv *il = hw->priv;
S
Stanislaw Gruszka 已提交
5580
	struct il_vif_priv *vif_priv = (void *)vif->drv_priv;
5581

5582
	D_MAC80211("enter\n");
5583

5584 5585
	il4965_update_tkip_key(il, vif_priv->ctx, keyconf, sta, iv32,
			       phase1key);
5586

5587
	D_MAC80211("leave\n");
5588 5589
}

5590 5591 5592 5593
int
il4965_mac_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
		   struct ieee80211_vif *vif, struct ieee80211_sta *sta,
		   struct ieee80211_key_conf *key)
5594
{
S
Stanislaw Gruszka 已提交
5595
	struct il_priv *il = hw->priv;
S
Stanislaw Gruszka 已提交
5596 5597
	struct il_vif_priv *vif_priv = (void *)vif->drv_priv;
	struct il_rxon_context *ctx = vif_priv->ctx;
5598 5599 5600 5601
	int ret;
	u8 sta_id;
	bool is_default_wep_key = false;

5602
	D_MAC80211("enter\n");
5603

S
Stanislaw Gruszka 已提交
5604
	if (il->cfg->mod_params->sw_crypto) {
5605
		D_MAC80211("leave - hwcrypto disabled\n");
5606 5607 5608
		return -EOPNOTSUPP;
	}

S
Stanislaw Gruszka 已提交
5609
	sta_id = il_sta_id_or_broadcast(il, vif_priv->ctx, sta);
S
Stanislaw Gruszka 已提交
5610
	if (sta_id == IL_INVALID_STATION)
5611 5612
		return -EINVAL;

S
Stanislaw Gruszka 已提交
5613 5614
	mutex_lock(&il->mutex);
	il_scan_cancel_timeout(il, 100);
5615 5616 5617 5618 5619 5620 5621 5622

	/*
	 * If we are getting WEP group key and we didn't receive any key mapping
	 * so far, we are in legacy wep mode (group key only), otherwise we are
	 * in 1X mode.
	 * In legacy wep mode, we use another host command to the uCode.
	 */
	if ((key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
5623
	     key->cipher == WLAN_CIPHER_SUITE_WEP104) && !sta) {
5624 5625 5626 5627
		if (cmd == SET_KEY)
			is_default_wep_key = !ctx->key_mapping_keys;
		else
			is_default_wep_key =
5628
			    (key->hw_key_idx == HW_KEY_DEFAULT);
5629 5630 5631 5632 5633
	}

	switch (cmd) {
	case SET_KEY:
		if (is_default_wep_key)
5634 5635
			ret =
			    il4965_set_default_wep_key(il, vif_priv->ctx, key);
5636
		else
5637 5638 5639
			ret =
			    il4965_set_dynamic_key(il, vif_priv->ctx, key,
						   sta_id);
5640

5641
		D_MAC80211("enable hwcrypto key\n");
5642 5643 5644
		break;
	case DISABLE_KEY:
		if (is_default_wep_key)
S
Stanislaw Gruszka 已提交
5645
			ret = il4965_remove_default_wep_key(il, ctx, key);
5646
		else
5647
			ret = il4965_remove_dynamic_key(il, ctx, key, sta_id);
5648

5649
		D_MAC80211("disable hwcrypto key\n");
5650 5651 5652 5653 5654
		break;
	default:
		ret = -EINVAL;
	}

S
Stanislaw Gruszka 已提交
5655
	mutex_unlock(&il->mutex);
5656
	D_MAC80211("leave\n");
5657 5658 5659 5660

	return ret;
}

5661 5662 5663 5664 5665
int
il4965_mac_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			enum ieee80211_ampdu_mlme_action action,
			struct ieee80211_sta *sta, u16 tid, u16 * ssn,
			u8 buf_size)
5666
{
S
Stanislaw Gruszka 已提交
5667
	struct il_priv *il = hw->priv;
5668 5669
	int ret = -EINVAL;

5670
	D_HT("A-MPDU action on addr %pM tid %d\n", sta->addr, tid);
5671

S
Stanislaw Gruszka 已提交
5672
	if (!(il->cfg->sku & IL_SKU_N))
5673 5674
		return -EACCES;

S
Stanislaw Gruszka 已提交
5675
	mutex_lock(&il->mutex);
5676 5677 5678

	switch (action) {
	case IEEE80211_AMPDU_RX_START:
5679
		D_HT("start Rx\n");
S
Stanislaw Gruszka 已提交
5680
		ret = il4965_sta_rx_agg_start(il, sta, tid, *ssn);
5681 5682
		break;
	case IEEE80211_AMPDU_RX_STOP:
5683
		D_HT("stop Rx\n");
S
Stanislaw Gruszka 已提交
5684
		ret = il4965_sta_rx_agg_stop(il, sta, tid);
S
Stanislaw Gruszka 已提交
5685
		if (test_bit(S_EXIT_PENDING, &il->status))
5686 5687 5688
			ret = 0;
		break;
	case IEEE80211_AMPDU_TX_START:
5689
		D_HT("start Tx\n");
S
Stanislaw Gruszka 已提交
5690
		ret = il4965_tx_agg_start(il, vif, sta, tid, ssn);
5691 5692
		break;
	case IEEE80211_AMPDU_TX_STOP:
5693
		D_HT("stop Tx\n");
S
Stanislaw Gruszka 已提交
5694
		ret = il4965_tx_agg_stop(il, vif, sta, tid);
S
Stanislaw Gruszka 已提交
5695
		if (test_bit(S_EXIT_PENDING, &il->status))
5696 5697 5698 5699 5700 5701
			ret = 0;
		break;
	case IEEE80211_AMPDU_TX_OPERATIONAL:
		ret = 0;
		break;
	}
S
Stanislaw Gruszka 已提交
5702
	mutex_unlock(&il->mutex);
5703 5704 5705 5706

	return ret;
}

5707 5708 5709
int
il4965_mac_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		   struct ieee80211_sta *sta)
5710
{
S
Stanislaw Gruszka 已提交
5711
	struct il_priv *il = hw->priv;
S
Stanislaw Gruszka 已提交
5712 5713
	struct il_station_priv *sta_priv = (void *)sta->drv_priv;
	struct il_vif_priv *vif_priv = (void *)vif->drv_priv;
5714 5715 5716 5717
	bool is_ap = vif->type == NL80211_IFTYPE_STATION;
	int ret;
	u8 sta_id;

5718
	D_INFO("received request to add station %pM\n", sta->addr);
S
Stanislaw Gruszka 已提交
5719
	mutex_lock(&il->mutex);
5720
	D_INFO("proceeding to add station %pM\n", sta->addr);
S
Stanislaw Gruszka 已提交
5721
	sta_priv->common.sta_id = IL_INVALID_STATION;
5722 5723 5724

	atomic_set(&sta_priv->pending_frames, 0);

5725 5726 5727
	ret =
	    il_add_station_common(il, vif_priv->ctx, sta->addr, is_ap, sta,
				  &sta_id);
5728
	if (ret) {
5729
		IL_ERR("Unable to add station %pM (%d)\n", sta->addr, ret);
5730
		/* Should we return success if return code is EEXIST ? */
S
Stanislaw Gruszka 已提交
5731
		mutex_unlock(&il->mutex);
5732 5733 5734 5735 5736 5737
		return ret;
	}

	sta_priv->common.sta_id = sta_id;

	/* Initialize rate scaling */
5738
	D_INFO("Initializing rate scaling for station %pM\n", sta->addr);
S
Stanislaw Gruszka 已提交
5739 5740
	il4965_rs_rate_init(il, sta, sta_id);
	mutex_unlock(&il->mutex);
5741 5742 5743 5744

	return 0;
}

5745 5746 5747
void
il4965_mac_channel_switch(struct ieee80211_hw *hw,
			  struct ieee80211_channel_switch *ch_switch)
5748
{
S
Stanislaw Gruszka 已提交
5749
	struct il_priv *il = hw->priv;
S
Stanislaw Gruszka 已提交
5750
	const struct il_channel_info *ch_info;
5751 5752
	struct ieee80211_conf *conf = &hw->conf;
	struct ieee80211_channel *channel = ch_switch->channel;
S
Stanislaw Gruszka 已提交
5753
	struct il_ht_config *ht_conf = &il->current_ht_config;
5754

5755
	struct il_rxon_context *ctx = &il->ctx;
5756 5757
	u16 ch;

5758
	D_MAC80211("enter\n");
5759

S
Stanislaw Gruszka 已提交
5760
	mutex_lock(&il->mutex);
5761

S
Stanislaw Gruszka 已提交
5762
	if (il_is_rfkill(il))
5763
		goto out;
5764

S
Stanislaw Gruszka 已提交
5765 5766 5767
	if (test_bit(S_EXIT_PENDING, &il->status) ||
	    test_bit(S_SCANNING, &il->status) ||
	    test_bit(S_CHANNEL_SWITCH_PENDING, &il->status))
5768
		goto out;
5769

5770
	if (!il_is_associated(il))
5771
		goto out;
5772

S
Stanislaw Gruszka 已提交
5773
	if (!il->cfg->ops->lib->set_channel_switch)
5774
		goto out;
5775

5776
	ch = channel->hw_value;
5777
	if (le16_to_cpu(il->active.channel) == ch)
5778 5779
		goto out;

S
Stanislaw Gruszka 已提交
5780
	ch_info = il_get_channel_info(il, channel->band, ch);
S
Stanislaw Gruszka 已提交
5781
	if (!il_is_channel_valid(ch_info)) {
5782
		D_MAC80211("invalid channel\n");
5783 5784 5785
		goto out;
	}

S
Stanislaw Gruszka 已提交
5786
	spin_lock_irq(&il->lock);
5787

S
Stanislaw Gruszka 已提交
5788
	il->current_ht_config.smps = conf->smps_mode;
5789 5790 5791 5792 5793 5794

	/* Configure HT40 channels */
	ctx->ht.enabled = conf_is_ht(conf);
	if (ctx->ht.enabled) {
		if (conf_is_ht40_minus(conf)) {
			ctx->ht.extension_chan_offset =
5795
			    IEEE80211_HT_PARAM_CHA_SEC_BELOW;
5796 5797 5798
			ctx->ht.is_40mhz = true;
		} else if (conf_is_ht40_plus(conf)) {
			ctx->ht.extension_chan_offset =
5799
			    IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
5800 5801 5802
			ctx->ht.is_40mhz = true;
		} else {
			ctx->ht.extension_chan_offset =
5803
			    IEEE80211_HT_PARAM_CHA_SEC_NONE;
5804
			ctx->ht.is_40mhz = false;
5805
		}
5806 5807 5808
	} else
		ctx->ht.is_40mhz = false;

5809 5810
	if ((le16_to_cpu(il->staging.channel) != ch))
		il->staging.flags = 0;
5811

S
Stanislaw Gruszka 已提交
5812 5813 5814
	il_set_rxon_channel(il, channel, ctx);
	il_set_rxon_ht(il, ht_conf);
	il_set_flags_for_band(il, ctx, channel->band, ctx->vif);
5815

S
Stanislaw Gruszka 已提交
5816
	spin_unlock_irq(&il->lock);
5817

S
Stanislaw Gruszka 已提交
5818
	il_set_rate(il);
5819 5820 5821 5822
	/*
	 * at this point, staging_rxon has the
	 * configuration for channel switch
	 */
S
Stanislaw Gruszka 已提交
5823
	set_bit(S_CHANNEL_SWITCH_PENDING, &il->status);
S
Stanislaw Gruszka 已提交
5824 5825
	il->switch_channel = cpu_to_le16(ch);
	if (il->cfg->ops->lib->set_channel_switch(il, ch_switch)) {
S
Stanislaw Gruszka 已提交
5826
		clear_bit(S_CHANNEL_SWITCH_PENDING, &il->status);
S
Stanislaw Gruszka 已提交
5827
		il->switch_channel = 0;
5828
		ieee80211_chswitch_done(ctx->vif, false);
5829
	}
5830

5831
out:
S
Stanislaw Gruszka 已提交
5832
	mutex_unlock(&il->mutex);
5833
	D_MAC80211("leave\n");
5834 5835
}

5836 5837 5838
void
il4965_configure_filter(struct ieee80211_hw *hw, unsigned int changed_flags,
			unsigned int *total_flags, u64 multicast)
5839
{
S
Stanislaw Gruszka 已提交
5840
	struct il_priv *il = hw->priv;
5841 5842 5843 5844 5845 5846 5847 5848 5849
	__le32 filter_or = 0, filter_nand = 0;

#define CHK(test, flag)	do { \
	if (*total_flags & (test))		\
		filter_or |= (flag);		\
	else					\
		filter_nand |= (flag);		\
	} while (0)

5850 5851
	D_MAC80211("Enter: changed: 0x%x, total: 0x%x\n", changed_flags,
		   *total_flags);
5852 5853 5854 5855 5856 5857 5858 5859

	CHK(FIF_OTHER_BSS | FIF_PROMISC_IN_BSS, RXON_FILTER_PROMISC_MSK);
	/* Setting _just_ RXON_FILTER_CTL2HOST_MSK causes FH errors */
	CHK(FIF_CONTROL, RXON_FILTER_CTL2HOST_MSK | RXON_FILTER_PROMISC_MSK);
	CHK(FIF_BCN_PRBRESP_PROMISC, RXON_FILTER_BCON_AWARE_MSK);

#undef CHK

S
Stanislaw Gruszka 已提交
5860
	mutex_lock(&il->mutex);
5861

5862 5863
	il->staging.filter_flags &= ~filter_nand;
	il->staging.filter_flags |= filter_or;
5864

5865 5866 5867 5868
	/*
	 * Not committing directly because hardware can perform a scan,
	 * but we'll eventually commit the filter flags change anyway.
	 */
5869

S
Stanislaw Gruszka 已提交
5870
	mutex_unlock(&il->mutex);
5871 5872 5873

	/*
	 * Receiving all multicast frames is always enabled by the
S
Stanislaw Gruszka 已提交
5874
	 * default flags setup in il_connection_init_rx_config()
5875 5876 5877
	 * since we currently do not support programming multicast
	 * filters into the device.
	 */
5878 5879 5880
	*total_flags &=
	    FIF_OTHER_BSS | FIF_ALLMULTI | FIF_PROMISC_IN_BSS |
	    FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL;
5881 5882 5883 5884 5885 5886 5887 5888
}

/*****************************************************************************
 *
 * driver setup and teardown
 *
 *****************************************************************************/

5889 5890
static void
il4965_bg_txpower_work(struct work_struct *work)
5891
{
S
Stanislaw Gruszka 已提交
5892
	struct il_priv *il = container_of(work, struct il_priv,
5893
					  txpower_work);
5894

S
Stanislaw Gruszka 已提交
5895
	mutex_lock(&il->mutex);
5896

5897
	/* If a scan happened to start before we got here
S
Stanislaw Gruszka 已提交
5898
	 * then just return; the stats notification will
5899 5900
	 * kick off another scheduled work to compensate for
	 * any temperature delta we missed here. */
S
Stanislaw Gruszka 已提交
5901 5902
	if (test_bit(S_EXIT_PENDING, &il->status) ||
	    test_bit(S_SCANNING, &il->status))
5903
		goto out;
5904 5905 5906 5907

	/* Regardless of if we are associated, we must reconfigure the
	 * TX power since frames can be sent on non-radar channels while
	 * not associated */
S
Stanislaw Gruszka 已提交
5908
	il->cfg->ops->lib->send_tx_power(il);
5909 5910 5911

	/* Update last_temperature to keep is_calib_needed from running
	 * when it isn't needed... */
S
Stanislaw Gruszka 已提交
5912
	il->last_temperature = il->temperature;
5913
out:
S
Stanislaw Gruszka 已提交
5914
	mutex_unlock(&il->mutex);
5915 5916
}

5917 5918
static void
il4965_setup_deferred_work(struct il_priv *il)
5919
{
S
Stanislaw Gruszka 已提交
5920
	il->workqueue = create_singlethread_workqueue(DRV_NAME);
5921

S
Stanislaw Gruszka 已提交
5922
	init_waitqueue_head(&il->wait_command_queue);
5923

S
Stanislaw Gruszka 已提交
5924 5925 5926 5927 5928
	INIT_WORK(&il->restart, il4965_bg_restart);
	INIT_WORK(&il->rx_replenish, il4965_bg_rx_replenish);
	INIT_WORK(&il->run_time_calib_work, il4965_bg_run_time_calib_work);
	INIT_DELAYED_WORK(&il->init_alive_start, il4965_bg_init_alive_start);
	INIT_DELAYED_WORK(&il->alive_start, il4965_bg_alive_start);
5929

S
Stanislaw Gruszka 已提交
5930
	il_setup_scan_deferred_work(il);
5931

S
Stanislaw Gruszka 已提交
5932
	INIT_WORK(&il->txpower_work, il4965_bg_txpower_work);
5933

S
Stanislaw Gruszka 已提交
5934 5935 5936
	init_timer(&il->stats_periodic);
	il->stats_periodic.data = (unsigned long)il;
	il->stats_periodic.function = il4965_bg_stats_periodic;
5937

S
Stanislaw Gruszka 已提交
5938 5939 5940
	init_timer(&il->watchdog);
	il->watchdog.data = (unsigned long)il;
	il->watchdog.function = il_bg_watchdog;
5941

5942 5943 5944
	tasklet_init(&il->irq_tasklet,
		     (void (*)(unsigned long))il4965_irq_tasklet,
		     (unsigned long)il);
5945 5946
}

5947 5948
static void
il4965_cancel_deferred_work(struct il_priv *il)
5949
{
S
Stanislaw Gruszka 已提交
5950 5951 5952 5953
	cancel_work_sync(&il->txpower_work);
	cancel_delayed_work_sync(&il->init_alive_start);
	cancel_delayed_work(&il->alive_start);
	cancel_work_sync(&il->run_time_calib_work);
5954

S
Stanislaw Gruszka 已提交
5955
	il_cancel_scan_deferred_work(il);
5956

S
Stanislaw Gruszka 已提交
5957
	del_timer_sync(&il->stats_periodic);
5958 5959
}

5960 5961
static void
il4965_init_hw_rates(struct il_priv *il, struct ieee80211_rate *rates)
5962 5963 5964
{
	int i;

S
Stanislaw Gruszka 已提交
5965
	for (i = 0; i < RATE_COUNT_LEGACY; i++) {
5966
		rates[i].bitrate = il_rates[i].ieee * 5;
5967
		rates[i].hw_value = i;	/* Rate scaling will work on idxes */
5968 5969
		rates[i].hw_value_short = i;
		rates[i].flags = 0;
S
Stanislaw Gruszka 已提交
5970
		if ((i >= IL_FIRST_CCK_RATE) && (i <= IL_LAST_CCK_RATE)) {
5971 5972 5973 5974
			/*
			 * If CCK != 1M then set short preamble rate flag.
			 */
			rates[i].flags |=
5975 5976
			    (il_rates[i].plcp ==
			     RATE_1M_PLCP) ? 0 : IEEE80211_RATE_SHORT_PREAMBLE;
5977 5978 5979
		}
	}
}
5980

5981
/*
S
Stanislaw Gruszka 已提交
5982
 * Acquire il->lock before calling this function !
5983
 */
5984 5985
void
il4965_set_wr_ptrs(struct il_priv *il, int txq_id, u32 idx)
5986
{
5987
	il_wr(il, HBUS_TARG_WRPTR, (idx & 0xff) | (txq_id << 8));
S
Stanislaw Gruszka 已提交
5988
	il_wr_prph(il, IL49_SCD_QUEUE_RDPTR(txq_id), idx);
5989 5990
}

5991 5992 5993
void
il4965_tx_queue_set_status(struct il_priv *il, struct il_tx_queue *txq,
			   int tx_fifo_id, int scd_retry)
5994 5995 5996 5997
{
	int txq_id = txq->q.id;

	/* Find out whether to activate Tx queue */
S
Stanislaw Gruszka 已提交
5998
	int active = test_bit(txq_id, &il->txq_ctx_active_msk) ? 1 : 0;
5999 6000

	/* Set up and activate */
6001
	il_wr_prph(il, IL49_SCD_QUEUE_STATUS_BITS(txq_id),
S
Stanislaw Gruszka 已提交
6002 6003 6004 6005 6006
		   (active << IL49_SCD_QUEUE_STTS_REG_POS_ACTIVE) |
		   (tx_fifo_id << IL49_SCD_QUEUE_STTS_REG_POS_TXF) |
		   (scd_retry << IL49_SCD_QUEUE_STTS_REG_POS_WSL) |
		   (scd_retry << IL49_SCD_QUEUE_STTS_REG_POS_SCD_ACK) |
		   IL49_SCD_QUEUE_STTS_REG_MSK);
6007 6008 6009

	txq->sched_retry = scd_retry;

6010 6011
	D_INFO("%s %s Queue %d on AC %d\n", active ? "Activate" : "Deactivate",
	       scd_retry ? "BA" : "AC", txq_id, tx_fifo_id);
6012 6013
}

6014 6015
static int
il4965_init_drv(struct il_priv *il)
6016 6017 6018
{
	int ret;

S
Stanislaw Gruszka 已提交
6019 6020
	spin_lock_init(&il->sta_lock);
	spin_lock_init(&il->hcmd_lock);
6021

S
Stanislaw Gruszka 已提交
6022
	INIT_LIST_HEAD(&il->free_frames);
6023

S
Stanislaw Gruszka 已提交
6024
	mutex_init(&il->mutex);
6025

S
Stanislaw Gruszka 已提交
6026 6027 6028
	il->ieee_channels = NULL;
	il->ieee_rates = NULL;
	il->band = IEEE80211_BAND_2GHZ;
6029

S
Stanislaw Gruszka 已提交
6030 6031 6032
	il->iw_mode = NL80211_IFTYPE_STATION;
	il->current_ht_config.smps = IEEE80211_SMPS_STATIC;
	il->missed_beacon_threshold = IL_MISSED_BEACON_THRESHOLD_DEF;
6033 6034

	/* initialize force reset */
S
Stanislaw Gruszka 已提交
6035
	il->force_reset.reset_duration = IL_DELAY_NEXT_FORCE_FW_RELOAD;
6036 6037

	/* Choose which receivers/antennas to use */
S
Stanislaw Gruszka 已提交
6038
	if (il->cfg->ops->hcmd->set_rxon_chain)
6039
		il->cfg->ops->hcmd->set_rxon_chain(il, &il->ctx);
6040

S
Stanislaw Gruszka 已提交
6041
	il_init_scan_params(il);
6042

S
Stanislaw Gruszka 已提交
6043
	ret = il_init_channel_map(il);
6044
	if (ret) {
6045
		IL_ERR("initializing regulatory failed: %d\n", ret);
6046 6047 6048
		goto err;
	}

S
Stanislaw Gruszka 已提交
6049
	ret = il_init_geos(il);
6050
	if (ret) {
6051
		IL_ERR("initializing geos failed: %d\n", ret);
6052 6053
		goto err_free_channel_map;
	}
S
Stanislaw Gruszka 已提交
6054
	il4965_init_hw_rates(il, il->ieee_rates);
6055 6056 6057 6058

	return 0;

err_free_channel_map:
S
Stanislaw Gruszka 已提交
6059
	il_free_channel_map(il);
6060 6061 6062 6063
err:
	return ret;
}

6064 6065
static void
il4965_uninit_drv(struct il_priv *il)
6066
{
S
Stanislaw Gruszka 已提交
6067 6068 6069 6070
	il4965_calib_free_results(il);
	il_free_geos(il);
	il_free_channel_map(il);
	kfree(il->scan_cmd);
6071 6072
}

6073 6074
static void
il4965_hw_detect(struct il_priv *il)
6075
{
6076 6077
	il->hw_rev = _il_rd(il, CSR_HW_REV);
	il->hw_wa_rev = _il_rd(il, CSR_HW_REV_WA_REG);
S
Stanislaw Gruszka 已提交
6078
	il->rev_id = il->pci_dev->revision;
6079
	D_INFO("HW Revision ID = 0x%X\n", il->rev_id);
6080 6081
}

6082 6083
static int
il4965_set_hw_params(struct il_priv *il)
6084
{
6085
	il->hw_params.bcast_id = IL4965_BROADCAST_ID;
S
Stanislaw Gruszka 已提交
6086 6087 6088 6089
	il->hw_params.max_rxq_size = RX_QUEUE_SIZE;
	il->hw_params.max_rxq_log = RX_QUEUE_SIZE_LOG;
	if (il->cfg->mod_params->amsdu_size_8K)
		il->hw_params.rx_page_order = get_order(IL_RX_BUF_SIZE_8K);
6090
	else
S
Stanislaw Gruszka 已提交
6091
		il->hw_params.rx_page_order = get_order(IL_RX_BUF_SIZE_4K);
6092

S
Stanislaw Gruszka 已提交
6093
	il->hw_params.max_beacon_itrvl = IL_MAX_UCODE_BEACON_INTERVAL;
6094

S
Stanislaw Gruszka 已提交
6095 6096
	if (il->cfg->mod_params->disable_11n)
		il->cfg->sku &= ~IL_SKU_N;
6097 6098

	/* Device-specific setup */
S
Stanislaw Gruszka 已提交
6099
	return il->cfg->ops->lib->set_hw_params(il);
6100 6101
}

S
Stanislaw Gruszka 已提交
6102 6103 6104 6105 6106
static const u8 il4965_bss_ac_to_fifo[] = {
	IL_TX_FIFO_VO,
	IL_TX_FIFO_VI,
	IL_TX_FIFO_BE,
	IL_TX_FIFO_BK,
6107 6108
};

S
Stanislaw Gruszka 已提交
6109
static const u8 il4965_bss_ac_to_queue[] = {
6110 6111 6112 6113
	0, 1, 2, 3,
};

static int
S
Stanislaw Gruszka 已提交
6114
il4965_pci_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
6115
{
6116
	int err = 0;
S
Stanislaw Gruszka 已提交
6117
	struct il_priv *il;
6118
	struct ieee80211_hw *hw;
S
Stanislaw Gruszka 已提交
6119
	struct il_cfg *cfg = (struct il_cfg *)(ent->driver_data);
6120 6121 6122 6123 6124 6125 6126
	unsigned long flags;
	u16 pci_cmd;

	/************************
	 * 1. Allocating HW data
	 ************************/

S
Stanislaw Gruszka 已提交
6127
	hw = il_alloc_all(cfg);
6128 6129 6130 6131
	if (!hw) {
		err = -ENOMEM;
		goto out;
	}
S
Stanislaw Gruszka 已提交
6132 6133
	il = hw->priv;
	/* At this point both hw and il are allocated. */
6134

6135 6136 6137 6138
	il->ctx.always_active = true;
	il->ctx.is_active = true;
	il->ctx.ac_to_fifo = il4965_bss_ac_to_fifo;
	il->ctx.ac_to_queue = il4965_bss_ac_to_queue;
6139 6140
	il->ctx.exclusive_interface_modes = BIT(NL80211_IFTYPE_ADHOC);
	il->ctx.interface_modes = BIT(NL80211_IFTYPE_STATION);
6141 6142 6143

	SET_IEEE80211_DEV(hw, &pdev->dev);

6144
	D_INFO("*** LOAD DRIVER ***\n");
S
Stanislaw Gruszka 已提交
6145 6146 6147
	il->cfg = cfg;
	il->pci_dev = pdev;
	il->inta_mask = CSR_INI_SET_MASK;
6148

S
Stanislaw Gruszka 已提交
6149
	if (il_alloc_traffic_mem(il))
6150
		IL_ERR("Not enough memory to generate traffic log\n");
6151 6152 6153 6154

	/**************************
	 * 2. Initializing PCI bus
	 **************************/
6155 6156 6157
	pci_disable_link_state(pdev,
			       PCIE_LINK_STATE_L0S | PCIE_LINK_STATE_L1 |
			       PCIE_LINK_STATE_CLKPM);
6158 6159 6160 6161 6162 6163 6164 6165 6166 6167 6168 6169 6170 6171

	if (pci_enable_device(pdev)) {
		err = -ENODEV;
		goto out_ieee80211_free_hw;
	}

	pci_set_master(pdev);

	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(36));
	if (!err)
		err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(36));
	if (err) {
		err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
		if (!err)
6172 6173
			err =
			    pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
6174 6175
		/* both attempts failed: */
		if (err) {
6176
			IL_WARN("No suitable DMA available.\n");
6177 6178 6179 6180 6181 6182 6183 6184
			goto out_pci_disable_device;
		}
	}

	err = pci_request_regions(pdev, DRV_NAME);
	if (err)
		goto out_pci_disable_device;

S
Stanislaw Gruszka 已提交
6185
	pci_set_drvdata(pdev, il);
6186 6187 6188 6189

	/***********************
	 * 3. Read REV register
	 ***********************/
S
Stanislaw Gruszka 已提交
6190 6191
	il->hw_base = pci_iomap(pdev, 0, 0);
	if (!il->hw_base) {
6192 6193 6194 6195
		err = -ENODEV;
		goto out_pci_release_regions;
	}

6196
	D_INFO("pci_resource_len = 0x%08llx\n",
6197
	       (unsigned long long)pci_resource_len(pdev, 0));
6198
	D_INFO("pci_resource_base = %p\n", il->hw_base);
6199 6200 6201 6202

	/* these spin locks will be used in apm_ops.init and EEPROM access
	 * we should init now
	 */
S
Stanislaw Gruszka 已提交
6203 6204
	spin_lock_init(&il->reg_lock);
	spin_lock_init(&il->lock);
6205 6206 6207 6208 6209 6210

	/*
	 * stop and reset the on-board processor just in case it is in a
	 * strange state ... like being left stranded by a primary kernel
	 * and this is now the kdump kernel trying to start up
	 */
6211
	_il_wr(il, CSR_RESET, CSR_RESET_REG_FLAG_NEVO_RESET);
6212

S
Stanislaw Gruszka 已提交
6213
	il4965_hw_detect(il);
6214
	IL_INFO("Detected %s, REV=0x%X\n", il->cfg->name, il->hw_rev);
6215 6216 6217 6218 6219

	/* We disable the RETRY_TIMEOUT register (0x41) to keep
	 * PCI Tx retries from interfering with C3 CPU state */
	pci_write_config_byte(pdev, PCI_CFG_RETRY_TIMEOUT, 0x00);

S
Stanislaw Gruszka 已提交
6220 6221
	il4965_prepare_card_hw(il);
	if (!il->hw_ready) {
6222
		IL_WARN("Failed, HW not ready\n");
6223 6224 6225 6226 6227 6228 6229
		goto out_iounmap;
	}

	/*****************
	 * 4. Read EEPROM
	 *****************/
	/* Read the EEPROM */
S
Stanislaw Gruszka 已提交
6230
	err = il_eeprom_init(il);
6231
	if (err) {
6232
		IL_ERR("Unable to init EEPROM\n");
6233 6234
		goto out_iounmap;
	}
S
Stanislaw Gruszka 已提交
6235
	err = il4965_eeprom_check_version(il);
6236 6237 6238 6239 6240 6241 6242
	if (err)
		goto out_free_eeprom;

	if (err)
		goto out_free_eeprom;

	/* extract MAC Address */
S
Stanislaw Gruszka 已提交
6243
	il4965_eeprom_get_mac(il, il->addresses[0].addr);
6244
	D_INFO("MAC address: %pM\n", il->addresses[0].addr);
S
Stanislaw Gruszka 已提交
6245 6246
	il->hw->wiphy->addresses = il->addresses;
	il->hw->wiphy->n_addresses = 1;
6247 6248 6249 6250

	/************************
	 * 5. Setup HW constants
	 ************************/
S
Stanislaw Gruszka 已提交
6251
	if (il4965_set_hw_params(il)) {
6252
		IL_ERR("failed to set hw parameters\n");
6253 6254 6255 6256
		goto out_free_eeprom;
	}

	/*******************
S
Stanislaw Gruszka 已提交
6257
	 * 6. Setup il
6258 6259
	 *******************/

S
Stanislaw Gruszka 已提交
6260
	err = il4965_init_drv(il);
6261 6262
	if (err)
		goto out_free_eeprom;
S
Stanislaw Gruszka 已提交
6263
	/* At this point both hw and il are initialized. */
6264 6265 6266 6267

	/********************
	 * 7. Setup services
	 ********************/
S
Stanislaw Gruszka 已提交
6268 6269 6270
	spin_lock_irqsave(&il->lock, flags);
	il_disable_interrupts(il);
	spin_unlock_irqrestore(&il->lock, flags);
6271

S
Stanislaw Gruszka 已提交
6272
	pci_enable_msi(il->pci_dev);
6273

6274
	err = request_irq(il->pci_dev->irq, il_isr, IRQF_SHARED, DRV_NAME, il);
6275
	if (err) {
6276
		IL_ERR("Error allocating IRQ %d\n", il->pci_dev->irq);
6277 6278 6279
		goto out_disable_msi;
	}

S
Stanislaw Gruszka 已提交
6280
	il4965_setup_deferred_work(il);
6281
	il4965_setup_handlers(il);
6282 6283 6284 6285 6286

	/*********************************************
	 * 8. Enable interrupts and read RFKILL state
	 *********************************************/

6287
	/* enable rfkill interrupt: hw bug w/a */
S
Stanislaw Gruszka 已提交
6288
	pci_read_config_word(il->pci_dev, PCI_COMMAND, &pci_cmd);
6289 6290
	if (pci_cmd & PCI_COMMAND_INTX_DISABLE) {
		pci_cmd &= ~PCI_COMMAND_INTX_DISABLE;
S
Stanislaw Gruszka 已提交
6291
		pci_write_config_word(il->pci_dev, PCI_COMMAND, pci_cmd);
6292 6293
	}

S
Stanislaw Gruszka 已提交
6294
	il_enable_rfkill_int(il);
6295 6296

	/* If platform's RF_KILL switch is NOT set to KILL */
6297
	if (_il_rd(il, CSR_GP_CNTRL) & CSR_GP_CNTRL_REG_FLAG_HW_RF_KILL_SW)
S
Stanislaw Gruszka 已提交
6298
		clear_bit(S_RF_KILL_HW, &il->status);
6299
	else
S
Stanislaw Gruszka 已提交
6300
		set_bit(S_RF_KILL_HW, &il->status);
6301

S
Stanislaw Gruszka 已提交
6302
	wiphy_rfkill_set_hw_state(il->hw->wiphy,
6303
				  test_bit(S_RF_KILL_HW, &il->status));
6304

S
Stanislaw Gruszka 已提交
6305
	il_power_initialize(il);
6306

S
Stanislaw Gruszka 已提交
6307
	init_completion(&il->_4965.firmware_loading_complete);
6308

S
Stanislaw Gruszka 已提交
6309
	err = il4965_request_firmware(il, true);
6310 6311 6312 6313 6314
	if (err)
		goto out_destroy_workqueue;

	return 0;

6315
out_destroy_workqueue:
S
Stanislaw Gruszka 已提交
6316 6317 6318
	destroy_workqueue(il->workqueue);
	il->workqueue = NULL;
	free_irq(il->pci_dev->irq, il);
6319
out_disable_msi:
S
Stanislaw Gruszka 已提交
6320 6321
	pci_disable_msi(il->pci_dev);
	il4965_uninit_drv(il);
6322
out_free_eeprom:
S
Stanislaw Gruszka 已提交
6323
	il_eeprom_free(il);
6324
out_iounmap:
S
Stanislaw Gruszka 已提交
6325
	pci_iounmap(pdev, il->hw_base);
6326
out_pci_release_regions:
6327 6328
	pci_set_drvdata(pdev, NULL);
	pci_release_regions(pdev);
6329
out_pci_disable_device:
6330
	pci_disable_device(pdev);
6331
out_ieee80211_free_hw:
S
Stanislaw Gruszka 已提交
6332 6333
	il_free_traffic_mem(il);
	ieee80211_free_hw(il->hw);
6334
out:
6335 6336 6337
	return err;
}

6338 6339
static void __devexit
il4965_pci_remove(struct pci_dev *pdev)
6340
{
S
Stanislaw Gruszka 已提交
6341
	struct il_priv *il = pci_get_drvdata(pdev);
6342 6343
	unsigned long flags;

S
Stanislaw Gruszka 已提交
6344
	if (!il)
6345 6346
		return;

S
Stanislaw Gruszka 已提交
6347
	wait_for_completion(&il->_4965.firmware_loading_complete);
6348

6349
	D_INFO("*** UNLOAD DRIVER ***\n");
6350

S
Stanislaw Gruszka 已提交
6351
	il_dbgfs_unregister(il);
S
Stanislaw Gruszka 已提交
6352
	sysfs_remove_group(&pdev->dev.kobj, &il_attribute_group);
6353

S
Stanislaw Gruszka 已提交
6354 6355
	/* ieee80211_unregister_hw call wil cause il_mac_stop to
	 * to be called and il4965_down since we are removing the device
S
Stanislaw Gruszka 已提交
6356
	 * we need to set S_EXIT_PENDING bit.
6357
	 */
S
Stanislaw Gruszka 已提交
6358
	set_bit(S_EXIT_PENDING, &il->status);
6359

S
Stanislaw Gruszka 已提交
6360
	il_leds_exit(il);
6361

S
Stanislaw Gruszka 已提交
6362 6363 6364
	if (il->mac80211_registered) {
		ieee80211_unregister_hw(il->hw);
		il->mac80211_registered = 0;
6365
	} else {
S
Stanislaw Gruszka 已提交
6366
		il4965_down(il);
6367 6368 6369 6370
	}

	/*
	 * Make sure device is reset to low power before unloading driver.
S
Stanislaw Gruszka 已提交
6371 6372 6373
	 * This may be redundant with il4965_down(), but there are paths to
	 * run il4965_down() without calling apm_ops.stop(), and there are
	 * paths to avoid running il4965_down() at all before leaving driver.
6374 6375
	 * This (inexpensive) call *makes sure* device is reset.
	 */
S
Stanislaw Gruszka 已提交
6376
	il_apm_stop(il);
6377 6378 6379 6380

	/* make sure we flush any pending irq or
	 * tasklet for the driver
	 */
S
Stanislaw Gruszka 已提交
6381 6382 6383
	spin_lock_irqsave(&il->lock, flags);
	il_disable_interrupts(il);
	spin_unlock_irqrestore(&il->lock, flags);
6384

S
Stanislaw Gruszka 已提交
6385
	il4965_synchronize_irq(il);
6386

S
Stanislaw Gruszka 已提交
6387
	il4965_dealloc_ucode_pci(il);
6388

S
Stanislaw Gruszka 已提交
6389 6390 6391
	if (il->rxq.bd)
		il4965_rx_queue_free(il, &il->rxq);
	il4965_hw_txq_ctx_free(il);
6392

S
Stanislaw Gruszka 已提交
6393
	il_eeprom_free(il);
6394 6395

	/*netif_stop_queue(dev); */
S
Stanislaw Gruszka 已提交
6396
	flush_workqueue(il->workqueue);
6397

S
Stanislaw Gruszka 已提交
6398
	/* ieee80211_unregister_hw calls il_mac_stop, which flushes
S
Stanislaw Gruszka 已提交
6399
	 * il->workqueue... so we can't take down the workqueue
6400
	 * until now... */
S
Stanislaw Gruszka 已提交
6401 6402 6403
	destroy_workqueue(il->workqueue);
	il->workqueue = NULL;
	il_free_traffic_mem(il);
6404

S
Stanislaw Gruszka 已提交
6405 6406 6407
	free_irq(il->pci_dev->irq, il);
	pci_disable_msi(il->pci_dev);
	pci_iounmap(pdev, il->hw_base);
6408 6409 6410 6411
	pci_release_regions(pdev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);

S
Stanislaw Gruszka 已提交
6412
	il4965_uninit_drv(il);
6413

S
Stanislaw Gruszka 已提交
6414
	dev_kfree_skb(il->beacon_skb);
6415

S
Stanislaw Gruszka 已提交
6416
	ieee80211_free_hw(il->hw);
6417 6418 6419 6420
}

/*
 * Activate/Deactivate Tx DMA/FIFO channels according tx fifos mask
S
Stanislaw Gruszka 已提交
6421
 * must be called under il->lock and mac access
6422
 */
6423 6424
void
il4965_txq_set_sched(struct il_priv *il, u32 mask)
6425
{
6426
	il_wr_prph(il, IL49_SCD_TXFACT, mask);
6427 6428 6429 6430 6431 6432 6433 6434 6435
}

/*****************************************************************************
 *
 * driver and module entry point
 *
 *****************************************************************************/

/* Hardware specific file defines the PCI IDs table for that hardware module */
S
Stanislaw Gruszka 已提交
6436 6437 6438
static DEFINE_PCI_DEVICE_TABLE(il4965_hw_card_ids) = {
	{IL_PCI_DEVICE(0x4229, PCI_ANY_ID, il4965_cfg)},
	{IL_PCI_DEVICE(0x4230, PCI_ANY_ID, il4965_cfg)},
6439 6440
	{0}
};
S
Stanislaw Gruszka 已提交
6441
MODULE_DEVICE_TABLE(pci, il4965_hw_card_ids);
6442

S
Stanislaw Gruszka 已提交
6443
static struct pci_driver il4965_driver = {
6444
	.name = DRV_NAME,
S
Stanislaw Gruszka 已提交
6445 6446 6447 6448
	.id_table = il4965_hw_card_ids,
	.probe = il4965_pci_probe,
	.remove = __devexit_p(il4965_pci_remove),
	.driver.pm = IL_LEGACY_PM_OPS,
6449 6450
};

6451 6452
static int __init
il4965_init(void)
6453 6454 6455 6456 6457 6458
{

	int ret;
	pr_info(DRV_DESCRIPTION ", " DRV_VERSION "\n");
	pr_info(DRV_COPYRIGHT "\n");

S
Stanislaw Gruszka 已提交
6459
	ret = il4965_rate_control_register();
6460 6461 6462 6463 6464
	if (ret) {
		pr_err("Unable to register rate control algorithm: %d\n", ret);
		return ret;
	}

S
Stanislaw Gruszka 已提交
6465
	ret = pci_register_driver(&il4965_driver);
6466 6467 6468 6469 6470 6471 6472 6473
	if (ret) {
		pr_err("Unable to initialize PCI module\n");
		goto error_register;
	}

	return ret;

error_register:
S
Stanislaw Gruszka 已提交
6474
	il4965_rate_control_unregister();
6475 6476 6477
	return ret;
}

6478 6479
static void __exit
il4965_exit(void)
6480
{
S
Stanislaw Gruszka 已提交
6481 6482
	pci_unregister_driver(&il4965_driver);
	il4965_rate_control_unregister();
6483 6484
}

S
Stanislaw Gruszka 已提交
6485 6486
module_exit(il4965_exit);
module_init(il4965_init);
6487

6488
#ifdef CONFIG_IWLEGACY_DEBUG
6489
module_param_named(debug, il_debug_level, uint, S_IRUGO | S_IWUSR);
6490 6491 6492
MODULE_PARM_DESC(debug, "debug output mask");
#endif

S
Stanislaw Gruszka 已提交
6493
module_param_named(swcrypto, il4965_mod_params.sw_crypto, int, S_IRUGO);
6494
MODULE_PARM_DESC(swcrypto, "using crypto in software (default 0 [hardware])");
S
Stanislaw Gruszka 已提交
6495
module_param_named(queues_num, il4965_mod_params.num_of_queues, int, S_IRUGO);
6496
MODULE_PARM_DESC(queues_num, "number of hw queues.");
S
Stanislaw Gruszka 已提交
6497
module_param_named(11n_disable, il4965_mod_params.disable_11n, int, S_IRUGO);
6498
MODULE_PARM_DESC(11n_disable, "disable 11n functionality");
6499 6500
module_param_named(amsdu_size_8K, il4965_mod_params.amsdu_size_8K, int,
		   S_IRUGO);
6501
MODULE_PARM_DESC(amsdu_size_8K, "enable 8K amsdu size");
S
Stanislaw Gruszka 已提交
6502
module_param_named(fw_restart, il4965_mod_params.restart_fw, int, S_IRUGO);
6503
MODULE_PARM_DESC(fw_restart, "restart firmware in case of error");