mwl8k.c 99.7 KB
Newer Older
1
/*
2 3
 * drivers/net/wireless/mwl8k.c
 * Driver for Marvell TOPDOG 802.11 Wireless cards
4
 *
5
 * Copyright (C) 2008, 2009, 2010 Marvell Semiconductor Inc.
6 7 8 9 10 11 12 13 14
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2.  This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
15
#include <linux/sched.h>
16 17 18 19 20 21 22 23 24 25 26 27 28
#include <linux/spinlock.h>
#include <linux/list.h>
#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/completion.h>
#include <linux/etherdevice.h>
#include <net/mac80211.h>
#include <linux/moduleparam.h>
#include <linux/firmware.h>
#include <linux/workqueue.h>

#define MWL8K_DESC	"Marvell TOPDOG(R) 802.11 Wireless Network Driver"
#define MWL8K_NAME	KBUILD_MODNAME
29
#define MWL8K_VERSION	"0.12"
30 31 32

/* Register definitions */
#define MWL8K_HIU_GEN_PTR			0x00000c10
33 34
#define  MWL8K_MODE_STA				 0x0000005a
#define  MWL8K_MODE_AP				 0x000000a5
35
#define MWL8K_HIU_INT_CODE			0x00000c14
36 37 38
#define  MWL8K_FWSTA_READY			 0xf0f1f2f4
#define  MWL8K_FWAP_READY			 0xf1f2f4a5
#define  MWL8K_INT_CODE_CMD_FINISHED		 0x00000005
39 40 41 42 43 44 45 46
#define MWL8K_HIU_SCRATCH			0x00000c40

/* Host->device communications */
#define MWL8K_HIU_H2A_INTERRUPT_EVENTS		0x00000c18
#define MWL8K_HIU_H2A_INTERRUPT_STATUS		0x00000c1c
#define MWL8K_HIU_H2A_INTERRUPT_MASK		0x00000c20
#define MWL8K_HIU_H2A_INTERRUPT_CLEAR_SEL	0x00000c24
#define MWL8K_HIU_H2A_INTERRUPT_STATUS_MASK	0x00000c28
47 48 49 50
#define  MWL8K_H2A_INT_DUMMY			 (1 << 20)
#define  MWL8K_H2A_INT_RESET			 (1 << 15)
#define  MWL8K_H2A_INT_DOORBELL			 (1 << 1)
#define  MWL8K_H2A_INT_PPA_READY		 (1 << 0)
51 52 53 54 55 56 57

/* Device->host communications */
#define MWL8K_HIU_A2H_INTERRUPT_EVENTS		0x00000c2c
#define MWL8K_HIU_A2H_INTERRUPT_STATUS		0x00000c30
#define MWL8K_HIU_A2H_INTERRUPT_MASK		0x00000c34
#define MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL	0x00000c38
#define MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK	0x00000c3c
58 59 60 61 62 63 64 65 66 67
#define  MWL8K_A2H_INT_DUMMY			 (1 << 20)
#define  MWL8K_A2H_INT_CHNL_SWITCHED		 (1 << 11)
#define  MWL8K_A2H_INT_QUEUE_EMPTY		 (1 << 10)
#define  MWL8K_A2H_INT_RADAR_DETECT		 (1 << 7)
#define  MWL8K_A2H_INT_RADIO_ON			 (1 << 6)
#define  MWL8K_A2H_INT_RADIO_OFF		 (1 << 5)
#define  MWL8K_A2H_INT_MAC_EVENT		 (1 << 3)
#define  MWL8K_A2H_INT_OPC_DONE			 (1 << 2)
#define  MWL8K_A2H_INT_RX_READY			 (1 << 1)
#define  MWL8K_A2H_INT_TX_DONE			 (1 << 0)
68 69 70 71 72 73 74 75 76 77 78 79 80 81 82

#define MWL8K_A2H_EVENTS	(MWL8K_A2H_INT_DUMMY | \
				 MWL8K_A2H_INT_CHNL_SWITCHED | \
				 MWL8K_A2H_INT_QUEUE_EMPTY | \
				 MWL8K_A2H_INT_RADAR_DETECT | \
				 MWL8K_A2H_INT_RADIO_ON | \
				 MWL8K_A2H_INT_RADIO_OFF | \
				 MWL8K_A2H_INT_MAC_EVENT | \
				 MWL8K_A2H_INT_OPC_DONE | \
				 MWL8K_A2H_INT_RX_READY | \
				 MWL8K_A2H_INT_TX_DONE)

#define MWL8K_RX_QUEUES		1
#define MWL8K_TX_QUEUES		4

83 84 85 86
struct rxd_ops {
	int rxd_size;
	void (*rxd_init)(void *rxd, dma_addr_t next_dma_addr);
	void (*rxd_refill)(void *rxd, dma_addr_t addr, int len);
87 88
	int (*rxd_process)(void *rxd, struct ieee80211_rx_status *status,
			   __le16 *qos);
89 90
};

91
struct mwl8k_device_info {
92 93 94
	char *part_name;
	char *helper_image;
	char *fw_image;
95
	struct rxd_ops *ap_rxd_ops;
96 97
};

98
struct mwl8k_rx_queue {
99
	int rxd_count;
100 101

	/* hw receives here */
102
	int head;
103 104

	/* refill descs here */
105
	int tail;
106

107
	void *rxd;
108
	dma_addr_t rxd_dma;
109 110 111 112
	struct {
		struct sk_buff *skb;
		DECLARE_PCI_UNMAP_ADDR(dma)
	} *buf;
113 114 115 116
};

struct mwl8k_tx_queue {
	/* hw transmits here */
117
	int head;
118 119

	/* sw appends here */
120
	int tail;
121

122
	unsigned int len;
123 124 125
	struct mwl8k_tx_desc *txd;
	dma_addr_t txd_dma;
	struct sk_buff **skb;
126 127 128 129 130 131
};

struct mwl8k_priv {
	struct ieee80211_hw *hw;
	struct pci_dev *pdev;

132 133
	struct mwl8k_device_info *device_info;

134 135 136 137
	void __iomem *sram;
	void __iomem *regs;

	/* firmware */
138 139
	struct firmware *fw_helper;
	struct firmware *fw_ucode;
140

141 142 143
	/* hardware/firmware parameters */
	bool ap_fw;
	struct rxd_ops *rxd_ops;
144 145 146
	struct ieee80211_supported_band band_24;
	struct ieee80211_channel channels_24[14];
	struct ieee80211_rate rates_24[14];
147 148 149
	struct ieee80211_supported_band band_50;
	struct ieee80211_channel channels_50[4];
	struct ieee80211_rate rates_50[9];
150 151
	u32 ap_macids_supported;
	u32 sta_macids_supported;
152

153 154 155 156 157 158
	/* firmware access */
	struct mutex fw_mutex;
	struct task_struct *fw_mutex_owner;
	int fw_mutex_depth;
	struct completion *hostcmd_wait;

159 160 161
	/* lock held over TX and TX reap */
	spinlock_t tx_lock;

162 163 164
	/* TX quiesce completion, protected by fw_mutex and tx_lock */
	struct completion *tx_wait;

165
	/* List of interfaces.  */
166
	u32 macids_used;
167
	struct list_head vif_list;
168 169 170 171 172 173 174

	/* power management status cookie from firmware */
	u32 *cookie;
	dma_addr_t cookie_dma;

	u16 num_mcaddrs;
	u8 hw_rev;
175
	u32 fw_rev;
176 177 178 179 180 181 182 183 184 185

	/*
	 * Running count of TX packets in flight, to avoid
	 * iterating over the transmit rings each time.
	 */
	int pending_tx_pkts;

	struct mwl8k_rx_queue rxq[MWL8K_RX_QUEUES];
	struct mwl8k_tx_queue txq[MWL8K_TX_QUEUES];

186
	bool radio_on;
187
	bool radio_short_preamble;
188
	bool sniffer_enabled;
189
	bool wmm_enabled;
190 191 192

	/* XXX need to convert this to handle multiple interfaces */
	bool capture_beacon;
193
	u8 capture_bssid[ETH_ALEN];
194 195 196 197 198 199 200 201 202 203
	struct sk_buff *beacon_skb;

	/*
	 * This FJ worker has to be global as it is scheduled from the
	 * RX handler.  At this point we don't know which interface it
	 * belongs to until the list of bssids waiting to complete join
	 * is checked.
	 */
	struct work_struct finalize_join_worker;

204 205
	/* Tasklet to perform TX reclaim.  */
	struct tasklet_struct poll_tx_task;
206 207 208

	/* Tasklet to perform RX.  */
	struct tasklet_struct poll_rx_task;
209 210 211 212
};

/* Per interface specific private data */
struct mwl8k_vif {
213 214 215
	struct list_head list;
	struct ieee80211_vif *vif;

216 217 218
	/* Firmware macid for this vif.  */
	int macid;

L
Lennert Buytenhek 已提交
219
	/* Non AMPDU sequence number assigned by driver.  */
220
	u16 seqno;
221
};
222
#define MWL8K_VIF(_vif) ((struct mwl8k_vif *)&((_vif)->drv_priv))
223

224 225 226 227 228 229
struct mwl8k_sta {
	/* Index into station database. Returned by UPDATE_STADB.  */
	u8 peer_id;
};
#define MWL8K_STA(_sta) ((struct mwl8k_sta *)&((_sta)->drv_priv))

230
static const struct ieee80211_channel mwl8k_channels_24[] = {
231 232 233 234 235 236 237 238 239 240 241
	{ .center_freq = 2412, .hw_value = 1, },
	{ .center_freq = 2417, .hw_value = 2, },
	{ .center_freq = 2422, .hw_value = 3, },
	{ .center_freq = 2427, .hw_value = 4, },
	{ .center_freq = 2432, .hw_value = 5, },
	{ .center_freq = 2437, .hw_value = 6, },
	{ .center_freq = 2442, .hw_value = 7, },
	{ .center_freq = 2447, .hw_value = 8, },
	{ .center_freq = 2452, .hw_value = 9, },
	{ .center_freq = 2457, .hw_value = 10, },
	{ .center_freq = 2462, .hw_value = 11, },
242 243 244
	{ .center_freq = 2467, .hw_value = 12, },
	{ .center_freq = 2472, .hw_value = 13, },
	{ .center_freq = 2484, .hw_value = 14, },
245 246
};

247
static const struct ieee80211_rate mwl8k_rates_24[] = {
248 249 250
	{ .bitrate = 10, .hw_value = 2, },
	{ .bitrate = 20, .hw_value = 4, },
	{ .bitrate = 55, .hw_value = 11, },
251 252
	{ .bitrate = 110, .hw_value = 22, },
	{ .bitrate = 220, .hw_value = 44, },
253 254 255 256 257 258 259 260
	{ .bitrate = 60, .hw_value = 12, },
	{ .bitrate = 90, .hw_value = 18, },
	{ .bitrate = 120, .hw_value = 24, },
	{ .bitrate = 180, .hw_value = 36, },
	{ .bitrate = 240, .hw_value = 48, },
	{ .bitrate = 360, .hw_value = 72, },
	{ .bitrate = 480, .hw_value = 96, },
	{ .bitrate = 540, .hw_value = 108, },
261 262 263
	{ .bitrate = 720, .hw_value = 144, },
};

264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282
static const struct ieee80211_channel mwl8k_channels_50[] = {
	{ .center_freq = 5180, .hw_value = 36, },
	{ .center_freq = 5200, .hw_value = 40, },
	{ .center_freq = 5220, .hw_value = 44, },
	{ .center_freq = 5240, .hw_value = 48, },
};

static const struct ieee80211_rate mwl8k_rates_50[] = {
	{ .bitrate = 60, .hw_value = 12, },
	{ .bitrate = 90, .hw_value = 18, },
	{ .bitrate = 120, .hw_value = 24, },
	{ .bitrate = 180, .hw_value = 36, },
	{ .bitrate = 240, .hw_value = 48, },
	{ .bitrate = 360, .hw_value = 72, },
	{ .bitrate = 480, .hw_value = 96, },
	{ .bitrate = 540, .hw_value = 108, },
	{ .bitrate = 720, .hw_value = 144, },
};

283 284 285 286 287 288 289
/* Set or get info from Firmware */
#define MWL8K_CMD_SET			0x0001
#define MWL8K_CMD_GET			0x0000

/* Firmware command codes */
#define MWL8K_CMD_CODE_DNLD		0x0001
#define MWL8K_CMD_GET_HW_SPEC		0x0003
290
#define MWL8K_CMD_SET_HW_SPEC		0x0004
291 292
#define MWL8K_CMD_MAC_MULTICAST_ADR	0x0010
#define MWL8K_CMD_GET_STAT		0x0014
293 294
#define MWL8K_CMD_RADIO_CONTROL		0x001c
#define MWL8K_CMD_RF_TX_POWER		0x001e
295
#define MWL8K_CMD_RF_ANTENNA		0x0020
296
#define MWL8K_CMD_SET_BEACON		0x0100		/* per-vif */
297 298
#define MWL8K_CMD_SET_PRE_SCAN		0x0107
#define MWL8K_CMD_SET_POST_SCAN		0x0108
299 300 301 302 303
#define MWL8K_CMD_SET_RF_CHANNEL	0x010a
#define MWL8K_CMD_SET_AID		0x010d
#define MWL8K_CMD_SET_RATE		0x0110
#define MWL8K_CMD_SET_FINALIZE_JOIN	0x0111
#define MWL8K_CMD_RTS_THRESHOLD		0x0113
304
#define MWL8K_CMD_SET_SLOT		0x0114
305 306
#define MWL8K_CMD_SET_EDCA_PARAMS	0x0115
#define MWL8K_CMD_SET_WMM_MODE		0x0123
307
#define MWL8K_CMD_MIMO_CONFIG		0x0125
308
#define MWL8K_CMD_USE_FIXED_RATE	0x0126
309
#define MWL8K_CMD_ENABLE_SNIFFER	0x0150
310
#define MWL8K_CMD_SET_MAC_ADDR		0x0202		/* per-vif */
311
#define MWL8K_CMD_SET_RATEADAPT_MODE	0x0203
312 313
#define MWL8K_CMD_BSS_START		0x1100		/* per-vif */
#define MWL8K_CMD_SET_NEW_STN		0x1111		/* per-vif */
314
#define MWL8K_CMD_UPDATE_STADB		0x1123
315 316 317 318 319 320 321

static const char *mwl8k_cmd_name(u16 cmd, char *buf, int bufsize)
{
#define MWL8K_CMDNAME(x)	case MWL8K_CMD_##x: do {\
					snprintf(buf, bufsize, "%s", #x);\
					return buf;\
					} while (0)
322
	switch (cmd & ~0x8000) {
323 324
		MWL8K_CMDNAME(CODE_DNLD);
		MWL8K_CMDNAME(GET_HW_SPEC);
325
		MWL8K_CMDNAME(SET_HW_SPEC);
326 327 328 329
		MWL8K_CMDNAME(MAC_MULTICAST_ADR);
		MWL8K_CMDNAME(GET_STAT);
		MWL8K_CMDNAME(RADIO_CONTROL);
		MWL8K_CMDNAME(RF_TX_POWER);
330
		MWL8K_CMDNAME(RF_ANTENNA);
331
		MWL8K_CMDNAME(SET_BEACON);
332 333 334
		MWL8K_CMDNAME(SET_PRE_SCAN);
		MWL8K_CMDNAME(SET_POST_SCAN);
		MWL8K_CMDNAME(SET_RF_CHANNEL);
335 336 337 338
		MWL8K_CMDNAME(SET_AID);
		MWL8K_CMDNAME(SET_RATE);
		MWL8K_CMDNAME(SET_FINALIZE_JOIN);
		MWL8K_CMDNAME(RTS_THRESHOLD);
339
		MWL8K_CMDNAME(SET_SLOT);
340 341
		MWL8K_CMDNAME(SET_EDCA_PARAMS);
		MWL8K_CMDNAME(SET_WMM_MODE);
342
		MWL8K_CMDNAME(MIMO_CONFIG);
343
		MWL8K_CMDNAME(USE_FIXED_RATE);
344
		MWL8K_CMDNAME(ENABLE_SNIFFER);
345
		MWL8K_CMDNAME(SET_MAC_ADDR);
346
		MWL8K_CMDNAME(SET_RATEADAPT_MODE);
347
		MWL8K_CMDNAME(BSS_START);
348
		MWL8K_CMDNAME(SET_NEW_STN);
349
		MWL8K_CMDNAME(UPDATE_STADB);
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378
	default:
		snprintf(buf, bufsize, "0x%x", cmd);
	}
#undef MWL8K_CMDNAME

	return buf;
}

/* Hardware and firmware reset */
static void mwl8k_hw_reset(struct mwl8k_priv *priv)
{
	iowrite32(MWL8K_H2A_INT_RESET,
		priv->regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
	iowrite32(MWL8K_H2A_INT_RESET,
		priv->regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
	msleep(20);
}

/* Release fw image */
static void mwl8k_release_fw(struct firmware **fw)
{
	if (*fw == NULL)
		return;
	release_firmware(*fw);
	*fw = NULL;
}

static void mwl8k_release_firmware(struct mwl8k_priv *priv)
{
379 380
	mwl8k_release_fw(&priv->fw_ucode);
	mwl8k_release_fw(&priv->fw_helper);
381 382 383 384
}

/* Request fw image */
static int mwl8k_request_fw(struct mwl8k_priv *priv,
L
Lennert Buytenhek 已提交
385
			    const char *fname, struct firmware **fw)
386 387 388 389 390 391
{
	/* release current image */
	if (*fw != NULL)
		mwl8k_release_fw(fw);

	return request_firmware((const struct firmware **)fw,
L
Lennert Buytenhek 已提交
392
				fname, &priv->pdev->dev);
393 394
}

395
static int mwl8k_request_firmware(struct mwl8k_priv *priv)
396
{
397
	struct mwl8k_device_info *di = priv->device_info;
398 399
	int rc;

400
	if (di->helper_image != NULL) {
401
		rc = mwl8k_request_fw(priv, di->helper_image, &priv->fw_helper);
402 403 404 405 406 407
		if (rc) {
			printk(KERN_ERR "%s: Error requesting helper "
			       "firmware file %s\n", pci_name(priv->pdev),
			       di->helper_image);
			return rc;
		}
408 409
	}

410
	rc = mwl8k_request_fw(priv, di->fw_image, &priv->fw_ucode);
411
	if (rc) {
L
Lennert Buytenhek 已提交
412
		printk(KERN_ERR "%s: Error requesting firmware file %s\n",
413
		       pci_name(priv->pdev), di->fw_image);
414
		mwl8k_release_fw(&priv->fw_helper);
415 416 417 418 419 420 421 422 423
		return rc;
	}

	return 0;
}

struct mwl8k_cmd_pkt {
	__le16	code;
	__le16	length;
424 425
	__u8	seq_num;
	__u8	macid;
426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460
	__le16	result;
	char	payload[0];
} __attribute__((packed));

/*
 * Firmware loading.
 */
static int
mwl8k_send_fw_load_cmd(struct mwl8k_priv *priv, void *data, int length)
{
	void __iomem *regs = priv->regs;
	dma_addr_t dma_addr;
	int loops;

	dma_addr = pci_map_single(priv->pdev, data, length, PCI_DMA_TODEVICE);
	if (pci_dma_mapping_error(priv->pdev, dma_addr))
		return -ENOMEM;

	iowrite32(dma_addr, regs + MWL8K_HIU_GEN_PTR);
	iowrite32(0, regs + MWL8K_HIU_INT_CODE);
	iowrite32(MWL8K_H2A_INT_DOORBELL,
		regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
	iowrite32(MWL8K_H2A_INT_DUMMY,
		regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);

	loops = 1000;
	do {
		u32 int_code;

		int_code = ioread32(regs + MWL8K_HIU_INT_CODE);
		if (int_code == MWL8K_INT_CODE_CMD_FINISHED) {
			iowrite32(0, regs + MWL8K_HIU_INT_CODE);
			break;
		}

461
		cond_resched();
462 463 464 465 466
		udelay(1);
	} while (--loops);

	pci_unmap_single(priv->pdev, dma_addr, length, PCI_DMA_TODEVICE);

467
	return loops ? 0 : -ETIMEDOUT;
468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
}

static int mwl8k_load_fw_image(struct mwl8k_priv *priv,
				const u8 *data, size_t length)
{
	struct mwl8k_cmd_pkt *cmd;
	int done;
	int rc = 0;

	cmd = kmalloc(sizeof(*cmd) + 256, GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->code = cpu_to_le16(MWL8K_CMD_CODE_DNLD);
	cmd->seq_num = 0;
483
	cmd->macid = 0;
484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 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 569 570
	cmd->result = 0;

	done = 0;
	while (length) {
		int block_size = length > 256 ? 256 : length;

		memcpy(cmd->payload, data + done, block_size);
		cmd->length = cpu_to_le16(block_size);

		rc = mwl8k_send_fw_load_cmd(priv, cmd,
						sizeof(*cmd) + block_size);
		if (rc)
			break;

		done += block_size;
		length -= block_size;
	}

	if (!rc) {
		cmd->length = 0;
		rc = mwl8k_send_fw_load_cmd(priv, cmd, sizeof(*cmd));
	}

	kfree(cmd);

	return rc;
}

static int mwl8k_feed_fw_image(struct mwl8k_priv *priv,
				const u8 *data, size_t length)
{
	unsigned char *buffer;
	int may_continue, rc = 0;
	u32 done, prev_block_size;

	buffer = kmalloc(1024, GFP_KERNEL);
	if (buffer == NULL)
		return -ENOMEM;

	done = 0;
	prev_block_size = 0;
	may_continue = 1000;
	while (may_continue > 0) {
		u32 block_size;

		block_size = ioread32(priv->regs + MWL8K_HIU_SCRATCH);
		if (block_size & 1) {
			block_size &= ~1;
			may_continue--;
		} else {
			done += prev_block_size;
			length -= prev_block_size;
		}

		if (block_size > 1024 || block_size > length) {
			rc = -EOVERFLOW;
			break;
		}

		if (length == 0) {
			rc = 0;
			break;
		}

		if (block_size == 0) {
			rc = -EPROTO;
			may_continue--;
			udelay(1);
			continue;
		}

		prev_block_size = block_size;
		memcpy(buffer, data + done, block_size);

		rc = mwl8k_send_fw_load_cmd(priv, buffer, block_size);
		if (rc)
			break;
	}

	if (!rc && length != 0)
		rc = -EREMOTEIO;

	kfree(buffer);

	return rc;
}

L
Lennert Buytenhek 已提交
571
static int mwl8k_load_firmware(struct ieee80211_hw *hw)
572
{
L
Lennert Buytenhek 已提交
573
	struct mwl8k_priv *priv = hw->priv;
574
	struct firmware *fw = priv->fw_ucode;
L
Lennert Buytenhek 已提交
575 576 577 578
	int rc;
	int loops;

	if (!memcmp(fw->data, "\x01\x00\x00\x00", 4)) {
579
		struct firmware *helper = priv->fw_helper;
580

L
Lennert Buytenhek 已提交
581 582 583 584 585
		if (helper == NULL) {
			printk(KERN_ERR "%s: helper image needed but none "
			       "given\n", pci_name(priv->pdev));
			return -EINVAL;
		}
586

L
Lennert Buytenhek 已提交
587
		rc = mwl8k_load_fw_image(priv, helper->data, helper->size);
588 589
		if (rc) {
			printk(KERN_ERR "%s: unable to load firmware "
L
Lennert Buytenhek 已提交
590
			       "helper image\n", pci_name(priv->pdev));
591 592
			return rc;
		}
593
		msleep(5);
594

L
Lennert Buytenhek 已提交
595
		rc = mwl8k_feed_fw_image(priv, fw->data, fw->size);
596
	} else {
L
Lennert Buytenhek 已提交
597
		rc = mwl8k_load_fw_image(priv, fw->data, fw->size);
598 599 600
	}

	if (rc) {
L
Lennert Buytenhek 已提交
601 602
		printk(KERN_ERR "%s: unable to load firmware image\n",
		       pci_name(priv->pdev));
603 604 605
		return rc;
	}

606
	iowrite32(MWL8K_MODE_STA, priv->regs + MWL8K_HIU_GEN_PTR);
607

608
	loops = 500000;
609
	do {
610 611 612 613 614 615 616 617
		u32 ready_code;

		ready_code = ioread32(priv->regs + MWL8K_HIU_INT_CODE);
		if (ready_code == MWL8K_FWAP_READY) {
			priv->ap_fw = 1;
			break;
		} else if (ready_code == MWL8K_FWSTA_READY) {
			priv->ap_fw = 0;
618
			break;
619 620 621
		}

		cond_resched();
622 623 624 625 626 627 628 629 630 631 632
		udelay(1);
	} while (--loops);

	return loops ? 0 : -ETIMEDOUT;
}


/* DMA header used by firmware and hardware.  */
struct mwl8k_dma_data {
	__le16 fwlen;
	struct ieee80211_hdr wh;
633
	char data[0];
634 635 636
} __attribute__((packed));

/* Routines to add/remove DMA header from skb.  */
637
static inline void mwl8k_remove_dma_header(struct sk_buff *skb, __le16 qos)
638
{
639 640 641 642 643 644 645 646 647 648 649 650 651
	struct mwl8k_dma_data *tr;
	int hdrlen;

	tr = (struct mwl8k_dma_data *)skb->data;
	hdrlen = ieee80211_hdrlen(tr->wh.frame_control);

	if (hdrlen != sizeof(tr->wh)) {
		if (ieee80211_is_data_qos(tr->wh.frame_control)) {
			memmove(tr->data - hdrlen, &tr->wh, hdrlen - 2);
			*((__le16 *)(tr->data - 2)) = qos;
		} else {
			memmove(tr->data - hdrlen, &tr->wh, hdrlen);
		}
652
	}
653 654 655

	if (hdrlen != sizeof(*tr))
		skb_pull(skb, sizeof(*tr) - hdrlen);
656 657
}

658
static inline void mwl8k_add_dma_header(struct sk_buff *skb)
659 660
{
	struct ieee80211_hdr *wh;
661
	int hdrlen;
662 663
	struct mwl8k_dma_data *tr;

664 665 666 667 668 669
	/*
	 * Add a firmware DMA header; the firmware requires that we
	 * present a 2-byte payload length followed by a 4-address
	 * header (without QoS field), followed (optionally) by any
	 * WEP/ExtIV header (but only filled in for CCMP).
	 */
670
	wh = (struct ieee80211_hdr *)skb->data;
671

672
	hdrlen = ieee80211_hdrlen(wh->frame_control);
673 674
	if (hdrlen != sizeof(*tr))
		skb_push(skb, sizeof(*tr) - hdrlen);
675

676 677
	if (ieee80211_is_data_qos(wh->frame_control))
		hdrlen -= 2;
678 679 680 681

	tr = (struct mwl8k_dma_data *)skb->data;
	if (wh != &tr->wh)
		memmove(&tr->wh, wh, hdrlen);
682 683
	if (hdrlen != sizeof(tr->wh))
		memset(((void *)&tr->wh) + hdrlen, 0, sizeof(tr->wh) - hdrlen);
684 685 686 687 688 689

	/*
	 * Firmware length is the length of the fully formed "802.11
	 * payload".  That is, everything except for the 802.11 header.
	 * This includes all crypto material including the MIC.
	 */
690
	tr->fwlen = cpu_to_le16(skb->len - sizeof(*tr));
691 692 693 694
}


/*
695
 * Packet reception for 88w8366 AP firmware.
696
 */
697
struct mwl8k_rxd_8366_ap {
698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
	__le16 pkt_len;
	__u8 sq2;
	__u8 rate;
	__le32 pkt_phys_addr;
	__le32 next_rxd_phys_addr;
	__le16 qos_control;
	__le16 htsig2;
	__le32 hw_rssi_info;
	__le32 hw_noise_floor_info;
	__u8 noise_floor;
	__u8 pad0[3];
	__u8 rssi;
	__u8 rx_status;
	__u8 channel;
	__u8 rx_ctrl;
} __attribute__((packed));

715 716 717
#define MWL8K_8366_AP_RATE_INFO_MCS_FORMAT	0x80
#define MWL8K_8366_AP_RATE_INFO_40MHZ		0x40
#define MWL8K_8366_AP_RATE_INFO_RATEID(x)	((x) & 0x3f)
718

719
#define MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST	0x80
720

721
static void mwl8k_rxd_8366_ap_init(void *_rxd, dma_addr_t next_dma_addr)
722
{
723
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
724 725

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
726
	rxd->rx_ctrl = MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST;
727 728
}

729
static void mwl8k_rxd_8366_ap_refill(void *_rxd, dma_addr_t addr, int len)
730
{
731
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
732 733 734 735 736 737 738 739

	rxd->pkt_len = cpu_to_le16(len);
	rxd->pkt_phys_addr = cpu_to_le32(addr);
	wmb();
	rxd->rx_ctrl = 0;
}

static int
740 741
mwl8k_rxd_8366_ap_process(void *_rxd, struct ieee80211_rx_status *status,
			  __le16 *qos)
742
{
743
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
744

745
	if (!(rxd->rx_ctrl & MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST))
746 747 748 749 750 751 752 753
		return -1;
	rmb();

	memset(status, 0, sizeof(*status));

	status->signal = -rxd->rssi;
	status->noise = -rxd->noise_floor;

754
	if (rxd->rate & MWL8K_8366_AP_RATE_INFO_MCS_FORMAT) {
755
		status->flag |= RX_FLAG_HT;
756
		if (rxd->rate & MWL8K_8366_AP_RATE_INFO_40MHZ)
757
			status->flag |= RX_FLAG_40MHZ;
758
		status->rate_idx = MWL8K_8366_AP_RATE_INFO_RATEID(rxd->rate);
759 760 761
	} else {
		int i;

762 763
		for (i = 0; i < ARRAY_SIZE(mwl8k_rates_24); i++) {
			if (mwl8k_rates_24[i].hw_value == rxd->rate) {
764 765 766 767 768 769
				status->rate_idx = i;
				break;
			}
		}
	}

770 771 772 773 774 775 776
	if (rxd->channel > 14) {
		status->band = IEEE80211_BAND_5GHZ;
		if (!(status->flag & RX_FLAG_HT))
			status->rate_idx -= 5;
	} else {
		status->band = IEEE80211_BAND_2GHZ;
	}
777 778
	status->freq = ieee80211_channel_to_frequency(rxd->channel);

779 780
	*qos = rxd->qos_control;

781 782 783
	return le16_to_cpu(rxd->pkt_len);
}

784 785 786 787 788
static struct rxd_ops rxd_8366_ap_ops = {
	.rxd_size	= sizeof(struct mwl8k_rxd_8366_ap),
	.rxd_init	= mwl8k_rxd_8366_ap_init,
	.rxd_refill	= mwl8k_rxd_8366_ap_refill,
	.rxd_process	= mwl8k_rxd_8366_ap_process,
789 790 791
};

/*
792
 * Packet reception for STA firmware.
793
 */
794
struct mwl8k_rxd_sta {
795 796 797 798
	__le16 pkt_len;
	__u8 link_quality;
	__u8 noise_level;
	__le32 pkt_phys_addr;
799
	__le32 next_rxd_phys_addr;
800 801 802 803 804 805 806 807 808 809 810
	__le16 qos_control;
	__le16 rate_info;
	__le32 pad0[4];
	__u8 rssi;
	__u8 channel;
	__le16 pad1;
	__u8 rx_ctrl;
	__u8 rx_status;
	__u8 pad2[2];
} __attribute__((packed));

811 812 813 814 815 816
#define MWL8K_STA_RATE_INFO_SHORTPRE		0x8000
#define MWL8K_STA_RATE_INFO_ANTSELECT(x)	(((x) >> 11) & 0x3)
#define MWL8K_STA_RATE_INFO_RATEID(x)		(((x) >> 3) & 0x3f)
#define MWL8K_STA_RATE_INFO_40MHZ		0x0004
#define MWL8K_STA_RATE_INFO_SHORTGI		0x0002
#define MWL8K_STA_RATE_INFO_MCS_FORMAT		0x0001
817

818
#define MWL8K_STA_RX_CTRL_OWNED_BY_HOST		0x02
819

820
static void mwl8k_rxd_sta_init(void *_rxd, dma_addr_t next_dma_addr)
821
{
822
	struct mwl8k_rxd_sta *rxd = _rxd;
823 824

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
825
	rxd->rx_ctrl = MWL8K_STA_RX_CTRL_OWNED_BY_HOST;
826 827
}

828
static void mwl8k_rxd_sta_refill(void *_rxd, dma_addr_t addr, int len)
829
{
830
	struct mwl8k_rxd_sta *rxd = _rxd;
831 832 833 834 835 836 837 838

	rxd->pkt_len = cpu_to_le16(len);
	rxd->pkt_phys_addr = cpu_to_le32(addr);
	wmb();
	rxd->rx_ctrl = 0;
}

static int
839
mwl8k_rxd_sta_process(void *_rxd, struct ieee80211_rx_status *status,
840
		       __le16 *qos)
841
{
842
	struct mwl8k_rxd_sta *rxd = _rxd;
843 844
	u16 rate_info;

845
	if (!(rxd->rx_ctrl & MWL8K_STA_RX_CTRL_OWNED_BY_HOST))
846 847 848 849 850 851 852 853 854
		return -1;
	rmb();

	rate_info = le16_to_cpu(rxd->rate_info);

	memset(status, 0, sizeof(*status));

	status->signal = -rxd->rssi;
	status->noise = -rxd->noise_level;
855 856
	status->antenna = MWL8K_STA_RATE_INFO_ANTSELECT(rate_info);
	status->rate_idx = MWL8K_STA_RATE_INFO_RATEID(rate_info);
857

858
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTPRE)
859
		status->flag |= RX_FLAG_SHORTPRE;
860
	if (rate_info & MWL8K_STA_RATE_INFO_40MHZ)
861
		status->flag |= RX_FLAG_40MHZ;
862
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTGI)
863
		status->flag |= RX_FLAG_SHORT_GI;
864
	if (rate_info & MWL8K_STA_RATE_INFO_MCS_FORMAT)
865 866
		status->flag |= RX_FLAG_HT;

867 868 869 870 871 872 873
	if (rxd->channel > 14) {
		status->band = IEEE80211_BAND_5GHZ;
		if (!(status->flag & RX_FLAG_HT))
			status->rate_idx -= 5;
	} else {
		status->band = IEEE80211_BAND_2GHZ;
	}
874 875
	status->freq = ieee80211_channel_to_frequency(rxd->channel);

876 877
	*qos = rxd->qos_control;

878 879 880
	return le16_to_cpu(rxd->pkt_len);
}

881 882 883 884 885
static struct rxd_ops rxd_sta_ops = {
	.rxd_size	= sizeof(struct mwl8k_rxd_sta),
	.rxd_init	= mwl8k_rxd_sta_init,
	.rxd_refill	= mwl8k_rxd_sta_refill,
	.rxd_process	= mwl8k_rxd_sta_process,
886 887 888
};


889 890 891 892 893 894 895 896 897 898
#define MWL8K_RX_DESCS		256
#define MWL8K_RX_MAXSZ		3800

static int mwl8k_rxq_init(struct ieee80211_hw *hw, int index)
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_rx_queue *rxq = priv->rxq + index;
	int size;
	int i;

899 900 901
	rxq->rxd_count = 0;
	rxq->head = 0;
	rxq->tail = 0;
902

903
	size = MWL8K_RX_DESCS * priv->rxd_ops->rxd_size;
904

905 906
	rxq->rxd = pci_alloc_consistent(priv->pdev, size, &rxq->rxd_dma);
	if (rxq->rxd == NULL) {
907
		printk(KERN_ERR "%s: failed to alloc RX descriptors\n",
L
Lennert Buytenhek 已提交
908
		       wiphy_name(hw->wiphy));
909 910
		return -ENOMEM;
	}
911
	memset(rxq->rxd, 0, size);
912

913 914
	rxq->buf = kmalloc(MWL8K_RX_DESCS * sizeof(*rxq->buf), GFP_KERNEL);
	if (rxq->buf == NULL) {
915
		printk(KERN_ERR "%s: failed to alloc RX skbuff list\n",
L
Lennert Buytenhek 已提交
916
		       wiphy_name(hw->wiphy));
917
		pci_free_consistent(priv->pdev, size, rxq->rxd, rxq->rxd_dma);
918 919
		return -ENOMEM;
	}
920
	memset(rxq->buf, 0, MWL8K_RX_DESCS * sizeof(*rxq->buf));
921 922

	for (i = 0; i < MWL8K_RX_DESCS; i++) {
923 924
		int desc_size;
		void *rxd;
925
		int nexti;
926 927 928 929
		dma_addr_t next_dma_addr;

		desc_size = priv->rxd_ops->rxd_size;
		rxd = rxq->rxd + (i * priv->rxd_ops->rxd_size);
930

931 932 933 934
		nexti = i + 1;
		if (nexti == MWL8K_RX_DESCS)
			nexti = 0;
		next_dma_addr = rxq->rxd_dma + (nexti * desc_size);
935

936
		priv->rxd_ops->rxd_init(rxd, next_dma_addr);
937 938 939 940 941 942 943 944 945 946 947 948
	}

	return 0;
}

static int rxq_refill(struct ieee80211_hw *hw, int index, int limit)
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_rx_queue *rxq = priv->rxq + index;
	int refilled;

	refilled = 0;
949
	while (rxq->rxd_count < MWL8K_RX_DESCS && limit--) {
950
		struct sk_buff *skb;
951
		dma_addr_t addr;
952
		int rx;
953
		void *rxd;
954 955 956 957 958

		skb = dev_alloc_skb(MWL8K_RX_MAXSZ);
		if (skb == NULL)
			break;

959 960
		addr = pci_map_single(priv->pdev, skb->data,
				      MWL8K_RX_MAXSZ, DMA_FROM_DEVICE);
961

962 963 964 965
		rxq->rxd_count++;
		rx = rxq->tail++;
		if (rxq->tail == MWL8K_RX_DESCS)
			rxq->tail = 0;
966 967
		rxq->buf[rx].skb = skb;
		pci_unmap_addr_set(&rxq->buf[rx], dma, addr);
968 969 970

		rxd = rxq->rxd + (rx * priv->rxd_ops->rxd_size);
		priv->rxd_ops->rxd_refill(rxd, addr, MWL8K_RX_MAXSZ);
971 972 973 974 975 976 977 978 979 980 981 982 983 984 985

		refilled++;
	}

	return refilled;
}

/* Must be called only when the card's reception is completely halted */
static void mwl8k_rxq_deinit(struct ieee80211_hw *hw, int index)
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_rx_queue *rxq = priv->rxq + index;
	int i;

	for (i = 0; i < MWL8K_RX_DESCS; i++) {
986 987 988 989 990 991 992 993
		if (rxq->buf[i].skb != NULL) {
			pci_unmap_single(priv->pdev,
					 pci_unmap_addr(&rxq->buf[i], dma),
					 MWL8K_RX_MAXSZ, PCI_DMA_FROMDEVICE);
			pci_unmap_addr_set(&rxq->buf[i], dma, 0);

			kfree_skb(rxq->buf[i].skb);
			rxq->buf[i].skb = NULL;
994 995 996
		}
	}

997 998
	kfree(rxq->buf);
	rxq->buf = NULL;
999 1000

	pci_free_consistent(priv->pdev,
1001
			    MWL8K_RX_DESCS * priv->rxd_ops->rxd_size,
1002 1003
			    rxq->rxd, rxq->rxd_dma);
	rxq->rxd = NULL;
1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018
}


/*
 * Scan a list of BSSIDs to process for finalize join.
 * Allows for extension to process multiple BSSIDs.
 */
static inline int
mwl8k_capture_bssid(struct mwl8k_priv *priv, struct ieee80211_hdr *wh)
{
	return priv->capture_beacon &&
		ieee80211_is_beacon(wh->frame_control) &&
		!compare_ether_addr(wh->addr3, priv->capture_bssid);
}

1019 1020
static inline void mwl8k_save_beacon(struct ieee80211_hw *hw,
				     struct sk_buff *skb)
1021
{
1022 1023
	struct mwl8k_priv *priv = hw->priv;

1024
	priv->capture_beacon = false;
1025
	memset(priv->capture_bssid, 0, ETH_ALEN);
1026 1027 1028 1029 1030 1031 1032 1033

	/*
	 * Use GFP_ATOMIC as rxq_process is called from
	 * the primary interrupt handler, memory allocation call
	 * must not sleep.
	 */
	priv->beacon_skb = skb_copy(skb, GFP_ATOMIC);
	if (priv->beacon_skb != NULL)
1034
		ieee80211_queue_work(hw, &priv->finalize_join_worker);
1035 1036 1037 1038 1039 1040 1041 1042 1043
}

static int rxq_process(struct ieee80211_hw *hw, int index, int limit)
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_rx_queue *rxq = priv->rxq + index;
	int processed;

	processed = 0;
1044
	while (rxq->rxd_count && limit--) {
1045
		struct sk_buff *skb;
1046 1047
		void *rxd;
		int pkt_len;
1048
		struct ieee80211_rx_status status;
1049
		__le16 qos;
1050

1051
		skb = rxq->buf[rxq->head].skb;
1052 1053
		if (skb == NULL)
			break;
1054 1055 1056

		rxd = rxq->rxd + (rxq->head * priv->rxd_ops->rxd_size);

1057
		pkt_len = priv->rxd_ops->rxd_process(rxd, &status, &qos);
1058 1059 1060
		if (pkt_len < 0)
			break;

1061 1062 1063 1064 1065 1066
		rxq->buf[rxq->head].skb = NULL;

		pci_unmap_single(priv->pdev,
				 pci_unmap_addr(&rxq->buf[rxq->head], dma),
				 MWL8K_RX_MAXSZ, PCI_DMA_FROMDEVICE);
		pci_unmap_addr_set(&rxq->buf[rxq->head], dma, 0);
1067

1068 1069 1070 1071
		rxq->head++;
		if (rxq->head == MWL8K_RX_DESCS)
			rxq->head = 0;

1072
		rxq->rxd_count--;
1073

1074
		skb_put(skb, pkt_len);
1075
		mwl8k_remove_dma_header(skb, qos);
1076 1077

		/*
L
Lennert Buytenhek 已提交
1078 1079 1080
		 * Check for a pending join operation.  Save a
		 * copy of the beacon and schedule a tasklet to
		 * send a FINALIZE_JOIN command to the firmware.
1081
		 */
1082
		if (mwl8k_capture_bssid(priv, (void *)skb->data))
1083
			mwl8k_save_beacon(hw, skb);
1084

1085 1086
		memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
		ieee80211_rx_irqsafe(hw, skb);
1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104

		processed++;
	}

	return processed;
}


/*
 * Packet transmission.
 */

#define MWL8K_TXD_STATUS_OK			0x00000001
#define MWL8K_TXD_STATUS_OK_RETRY		0x00000002
#define MWL8K_TXD_STATUS_OK_MORE_RETRY		0x00000004
#define MWL8K_TXD_STATUS_MULTICAST_TX		0x00000008
#define MWL8K_TXD_STATUS_FW_OWNED		0x80000000

1105 1106 1107 1108 1109 1110
#define MWL8K_QOS_QLEN_UNSPEC			0xff00
#define MWL8K_QOS_ACK_POLICY_MASK		0x0060
#define MWL8K_QOS_ACK_POLICY_NORMAL		0x0000
#define MWL8K_QOS_ACK_POLICY_BLOCKACK		0x0060
#define MWL8K_QOS_EOSP				0x0010

1111 1112 1113 1114 1115 1116 1117
struct mwl8k_tx_desc {
	__le32 status;
	__u8 data_rate;
	__u8 tx_priority;
	__le16 qos_control;
	__le32 pkt_phys_addr;
	__le16 pkt_len;
1118
	__u8 dest_MAC_addr[ETH_ALEN];
1119
	__le32 next_txd_phys_addr;
1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134
	__le32 reserved;
	__le16 rate_info;
	__u8 peer_id;
	__u8 tx_frag_cnt;
} __attribute__((packed));

#define MWL8K_TX_DESCS		128

static int mwl8k_txq_init(struct ieee80211_hw *hw, int index)
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_tx_queue *txq = priv->txq + index;
	int size;
	int i;

1135
	txq->len = 0;
1136 1137
	txq->head = 0;
	txq->tail = 0;
1138 1139 1140

	size = MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc);

1141 1142
	txq->txd = pci_alloc_consistent(priv->pdev, size, &txq->txd_dma);
	if (txq->txd == NULL) {
1143
		printk(KERN_ERR "%s: failed to alloc TX descriptors\n",
L
Lennert Buytenhek 已提交
1144
		       wiphy_name(hw->wiphy));
1145 1146
		return -ENOMEM;
	}
1147
	memset(txq->txd, 0, size);
1148

1149 1150
	txq->skb = kmalloc(MWL8K_TX_DESCS * sizeof(*txq->skb), GFP_KERNEL);
	if (txq->skb == NULL) {
1151
		printk(KERN_ERR "%s: failed to alloc TX skbuff list\n",
L
Lennert Buytenhek 已提交
1152
		       wiphy_name(hw->wiphy));
1153
		pci_free_consistent(priv->pdev, size, txq->txd, txq->txd_dma);
1154 1155
		return -ENOMEM;
	}
1156
	memset(txq->skb, 0, MWL8K_TX_DESCS * sizeof(*txq->skb));
1157 1158 1159 1160 1161

	for (i = 0; i < MWL8K_TX_DESCS; i++) {
		struct mwl8k_tx_desc *tx_desc;
		int nexti;

1162
		tx_desc = txq->txd + i;
1163 1164 1165
		nexti = (i + 1) % MWL8K_TX_DESCS;

		tx_desc->status = 0;
1166 1167
		tx_desc->next_txd_phys_addr =
			cpu_to_le32(txq->txd_dma + nexti * sizeof(*tx_desc));
1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181
	}

	return 0;
}

static inline void mwl8k_tx_start(struct mwl8k_priv *priv)
{
	iowrite32(MWL8K_H2A_INT_PPA_READY,
		priv->regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
	iowrite32(MWL8K_H2A_INT_DUMMY,
		priv->regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
	ioread32(priv->regs + MWL8K_HIU_INT_CODE);
}

1182
static void mwl8k_dump_tx_rings(struct ieee80211_hw *hw)
1183
{
1184 1185 1186 1187 1188 1189 1190 1191 1192 1193
	struct mwl8k_priv *priv = hw->priv;
	int i;

	for (i = 0; i < MWL8K_TX_QUEUES; i++) {
		struct mwl8k_tx_queue *txq = priv->txq + i;
		int fw_owned = 0;
		int drv_owned = 0;
		int unused = 0;
		int desc;

1194
		for (desc = 0; desc < MWL8K_TX_DESCS; desc++) {
1195 1196
			struct mwl8k_tx_desc *tx_desc = txq->txd + desc;
			u32 status;
1197

1198
			status = le32_to_cpu(tx_desc->status);
1199
			if (status & MWL8K_TXD_STATUS_FW_OWNED)
1200
				fw_owned++;
1201
			else
1202
				drv_owned++;
1203 1204

			if (tx_desc->pkt_len == 0)
1205
				unused++;
1206 1207
		}

1208 1209 1210
		printk(KERN_ERR "%s: txq[%d] len=%d head=%d tail=%d "
		       "fw_owned=%d drv_owned=%d unused=%d\n",
		       wiphy_name(hw->wiphy), i,
1211
		       txq->len, txq->head, txq->tail,
1212 1213
		       fw_owned, drv_owned, unused);
	}
1214 1215
}

1216
/*
1217
 * Must be called with priv->fw_mutex held and tx queues stopped.
1218
 */
1219
#define MWL8K_TX_WAIT_TIMEOUT_MS	5000
1220

1221
static int mwl8k_tx_wait_empty(struct ieee80211_hw *hw)
1222 1223
{
	struct mwl8k_priv *priv = hw->priv;
1224
	DECLARE_COMPLETION_ONSTACK(tx_wait);
1225 1226
	int retry;
	int rc;
1227 1228 1229

	might_sleep();

1230 1231 1232 1233 1234 1235 1236 1237 1238 1239
	/*
	 * The TX queues are stopped at this point, so this test
	 * doesn't need to take ->tx_lock.
	 */
	if (!priv->pending_tx_pkts)
		return 0;

	retry = 0;
	rc = 0;

1240
	spin_lock_bh(&priv->tx_lock);
1241 1242 1243 1244
	priv->tx_wait = &tx_wait;
	while (!rc) {
		int oldcount;
		unsigned long timeout;
1245

1246
		oldcount = priv->pending_tx_pkts;
1247

1248
		spin_unlock_bh(&priv->tx_lock);
1249
		timeout = wait_for_completion_timeout(&tx_wait,
1250
			    msecs_to_jiffies(MWL8K_TX_WAIT_TIMEOUT_MS));
1251
		spin_lock_bh(&priv->tx_lock);
1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262

		if (timeout) {
			WARN_ON(priv->pending_tx_pkts);
			if (retry) {
				printk(KERN_NOTICE "%s: tx rings drained\n",
				       wiphy_name(hw->wiphy));
			}
			break;
		}

		if (priv->pending_tx_pkts < oldcount) {
1263 1264
			printk(KERN_NOTICE "%s: waiting for tx rings "
			       "to drain (%d -> %d pkts)\n",
1265 1266 1267 1268 1269 1270
			       wiphy_name(hw->wiphy), oldcount,
			       priv->pending_tx_pkts);
			retry = 1;
			continue;
		}

1271 1272
		priv->tx_wait = NULL;

1273 1274 1275 1276 1277
		printk(KERN_ERR "%s: tx rings stuck for %d ms\n",
		       wiphy_name(hw->wiphy), MWL8K_TX_WAIT_TIMEOUT_MS);
		mwl8k_dump_tx_rings(hw);

		rc = -ETIMEDOUT;
1278
	}
1279
	spin_unlock_bh(&priv->tx_lock);
1280

1281
	return rc;
1282 1283
}

1284 1285 1286 1287
#define MWL8K_TXD_SUCCESS(status)				\
	((status) & (MWL8K_TXD_STATUS_OK |			\
		     MWL8K_TXD_STATUS_OK_RETRY |		\
		     MWL8K_TXD_STATUS_OK_MORE_RETRY))
1288

1289 1290
static int
mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int limit, int force)
1291 1292 1293
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_tx_queue *txq = priv->txq + index;
1294
	int processed;
1295

1296
	processed = 0;
1297
	while (txq->len > 0 && limit--) {
1298 1299 1300
		int tx;
		struct mwl8k_tx_desc *tx_desc;
		unsigned long addr;
1301
		int size;
1302 1303 1304 1305
		struct sk_buff *skb;
		struct ieee80211_tx_info *info;
		u32 status;

1306 1307
		tx = txq->head;
		tx_desc = txq->txd + tx;
1308 1309 1310 1311 1312 1313 1314 1315 1316 1317

		status = le32_to_cpu(tx_desc->status);

		if (status & MWL8K_TXD_STATUS_FW_OWNED) {
			if (!force)
				break;
			tx_desc->status &=
				~cpu_to_le32(MWL8K_TXD_STATUS_FW_OWNED);
		}

1318
		txq->head = (tx + 1) % MWL8K_TX_DESCS;
1319 1320
		BUG_ON(txq->len == 0);
		txq->len--;
1321 1322 1323
		priv->pending_tx_pkts--;

		addr = le32_to_cpu(tx_desc->pkt_phys_addr);
1324
		size = le16_to_cpu(tx_desc->pkt_len);
1325 1326
		skb = txq->skb[tx];
		txq->skb[tx] = NULL;
1327 1328 1329 1330

		BUG_ON(skb == NULL);
		pci_unmap_single(priv->pdev, addr, size, PCI_DMA_TODEVICE);

1331
		mwl8k_remove_dma_header(skb, tx_desc->qos_control);
1332 1333 1334 1335 1336 1337 1338

		/* Mark descriptor as unused */
		tx_desc->pkt_phys_addr = 0;
		tx_desc->pkt_len = 0;

		info = IEEE80211_SKB_CB(skb);
		ieee80211_tx_info_clear_status(info);
1339
		if (MWL8K_TXD_SUCCESS(status))
1340 1341 1342 1343
			info->flags |= IEEE80211_TX_STAT_ACK;

		ieee80211_tx_status_irqsafe(hw, skb);

1344
		processed++;
1345 1346
	}

1347
	if (processed && priv->radio_on && !mutex_is_locked(&priv->fw_mutex))
1348
		ieee80211_wake_queue(hw, index);
1349 1350

	return processed;
1351 1352 1353 1354 1355 1356 1357 1358
}

/* must be called only when the card's transmit is completely halted */
static void mwl8k_txq_deinit(struct ieee80211_hw *hw, int index)
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_tx_queue *txq = priv->txq + index;

1359
	mwl8k_txq_reclaim(hw, index, INT_MAX, 1);
1360

1361 1362
	kfree(txq->skb);
	txq->skb = NULL;
1363 1364 1365

	pci_free_consistent(priv->pdev,
			    MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc),
1366 1367
			    txq->txd, txq->txd_dma);
	txq->txd = NULL;
1368 1369 1370 1371 1372 1373 1374
}

static int
mwl8k_txq_xmit(struct ieee80211_hw *hw, int index, struct sk_buff *skb)
{
	struct mwl8k_priv *priv = hw->priv;
	struct ieee80211_tx_info *tx_info;
1375
	struct mwl8k_vif *mwl8k_vif;
1376 1377 1378 1379
	struct ieee80211_hdr *wh;
	struct mwl8k_tx_queue *txq;
	struct mwl8k_tx_desc *tx;
	dma_addr_t dma;
1380 1381 1382
	u32 txstatus;
	u8 txdatarate;
	u16 qos;
1383

1384 1385 1386 1387 1388
	wh = (struct ieee80211_hdr *)skb->data;
	if (ieee80211_is_data_qos(wh->frame_control))
		qos = le16_to_cpu(*((__le16 *)ieee80211_get_qos_ctl(wh)));
	else
		qos = 0;
1389

1390
	mwl8k_add_dma_header(skb);
1391
	wh = &((struct mwl8k_dma_data *)skb->data)->wh;
1392 1393 1394 1395 1396 1397

	tx_info = IEEE80211_SKB_CB(skb);
	mwl8k_vif = MWL8K_VIF(tx_info->control.vif);

	if (tx_info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
		wh->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
1398 1399
		wh->seq_ctrl |= cpu_to_le16(mwl8k_vif->seqno);
		mwl8k_vif->seqno += 0x10;
1400 1401
	}

1402 1403 1404 1405 1406 1407
	/* Setup firmware control bit fields for each frame type.  */
	txstatus = 0;
	txdatarate = 0;
	if (ieee80211_is_mgmt(wh->frame_control) ||
	    ieee80211_is_ctl(wh->frame_control)) {
		txdatarate = 0;
1408
		qos |= MWL8K_QOS_QLEN_UNSPEC | MWL8K_QOS_EOSP;
1409 1410 1411 1412 1413
	} else if (ieee80211_is_data(wh->frame_control)) {
		txdatarate = 1;
		if (is_multicast_ether_addr(wh->addr1))
			txstatus |= MWL8K_TXD_STATUS_MULTICAST_TX;

1414
		qos &= ~MWL8K_QOS_ACK_POLICY_MASK;
1415
		if (tx_info->flags & IEEE80211_TX_CTL_AMPDU)
1416
			qos |= MWL8K_QOS_ACK_POLICY_BLOCKACK;
1417
		else
1418
			qos |= MWL8K_QOS_ACK_POLICY_NORMAL;
1419
	}
1420 1421 1422 1423 1424 1425

	dma = pci_map_single(priv->pdev, skb->data,
				skb->len, PCI_DMA_TODEVICE);

	if (pci_dma_mapping_error(priv->pdev, dma)) {
		printk(KERN_DEBUG "%s: failed to dma map skb, "
L
Lennert Buytenhek 已提交
1426
		       "dropping TX frame.\n", wiphy_name(hw->wiphy));
1427
		dev_kfree_skb(skb);
1428 1429 1430
		return NETDEV_TX_OK;
	}

1431
	spin_lock_bh(&priv->tx_lock);
1432

1433
	txq = priv->txq + index;
1434

1435 1436
	BUG_ON(txq->skb[txq->tail] != NULL);
	txq->skb[txq->tail] = skb;
1437

1438
	tx = txq->txd + txq->tail;
1439 1440
	tx->data_rate = txdatarate;
	tx->tx_priority = index;
1441 1442 1443
	tx->qos_control = cpu_to_le16(qos);
	tx->pkt_phys_addr = cpu_to_le32(dma);
	tx->pkt_len = cpu_to_le16(skb->len);
1444
	tx->rate_info = 0;
1445 1446 1447 1448
	if (!priv->ap_fw && tx_info->control.sta != NULL)
		tx->peer_id = MWL8K_STA(tx_info->control.sta)->peer_id;
	else
		tx->peer_id = 0;
1449
	wmb();
1450 1451
	tx->status = cpu_to_le32(MWL8K_TXD_STATUS_FW_OWNED | txstatus);

1452
	txq->len++;
1453 1454
	priv->pending_tx_pkts++;

1455 1456 1457
	txq->tail++;
	if (txq->tail == MWL8K_TX_DESCS)
		txq->tail = 0;
1458

1459
	if (txq->head == txq->tail)
1460 1461
		ieee80211_stop_queue(hw, index);

1462
	mwl8k_tx_start(priv);
1463 1464 1465 1466 1467 1468 1469

	spin_unlock_bh(&priv->tx_lock);

	return NETDEV_TX_OK;
}


1470 1471 1472 1473 1474 1475 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
/*
 * Firmware access.
 *
 * We have the following requirements for issuing firmware commands:
 * - Some commands require that the packet transmit path is idle when
 *   the command is issued.  (For simplicity, we'll just quiesce the
 *   transmit path for every command.)
 * - There are certain sequences of commands that need to be issued to
 *   the hardware sequentially, with no other intervening commands.
 *
 * This leads to an implementation of a "firmware lock" as a mutex that
 * can be taken recursively, and which is taken by both the low-level
 * command submission function (mwl8k_post_cmd) as well as any users of
 * that function that require issuing of an atomic sequence of commands,
 * and quiesces the transmit path whenever it's taken.
 */
static int mwl8k_fw_lock(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;

	if (priv->fw_mutex_owner != current) {
		int rc;

		mutex_lock(&priv->fw_mutex);
		ieee80211_stop_queues(hw);

		rc = mwl8k_tx_wait_empty(hw);
		if (rc) {
			ieee80211_wake_queues(hw);
			mutex_unlock(&priv->fw_mutex);

			return rc;
		}

		priv->fw_mutex_owner = current;
	}

	priv->fw_mutex_depth++;

	return 0;
}

static void mwl8k_fw_unlock(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;

	if (!--priv->fw_mutex_depth) {
		ieee80211_wake_queues(hw);
		priv->fw_mutex_owner = NULL;
		mutex_unlock(&priv->fw_mutex);
	}
}


1524 1525 1526 1527
/*
 * Command processing.
 */

1528 1529
/* Timeout firmware commands after 10s */
#define MWL8K_CMD_TIMEOUT_MS	10000
1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541

static int mwl8k_post_cmd(struct ieee80211_hw *hw, struct mwl8k_cmd_pkt *cmd)
{
	DECLARE_COMPLETION_ONSTACK(cmd_wait);
	struct mwl8k_priv *priv = hw->priv;
	void __iomem *regs = priv->regs;
	dma_addr_t dma_addr;
	unsigned int dma_size;
	int rc;
	unsigned long timeout = 0;
	u8 buf[32];

L
Lennert Buytenhek 已提交
1542
	cmd->result = 0xffff;
1543 1544 1545 1546 1547 1548
	dma_size = le16_to_cpu(cmd->length);
	dma_addr = pci_map_single(priv->pdev, cmd, dma_size,
				  PCI_DMA_BIDIRECTIONAL);
	if (pci_dma_mapping_error(priv->pdev, dma_addr))
		return -ENOMEM;

1549
	rc = mwl8k_fw_lock(hw);
1550 1551 1552
	if (rc) {
		pci_unmap_single(priv->pdev, dma_addr, dma_size,
						PCI_DMA_BIDIRECTIONAL);
1553
		return rc;
1554
	}
1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565

	priv->hostcmd_wait = &cmd_wait;
	iowrite32(dma_addr, regs + MWL8K_HIU_GEN_PTR);
	iowrite32(MWL8K_H2A_INT_DOORBELL,
		regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);
	iowrite32(MWL8K_H2A_INT_DUMMY,
		regs + MWL8K_HIU_H2A_INTERRUPT_EVENTS);

	timeout = wait_for_completion_timeout(&cmd_wait,
				msecs_to_jiffies(MWL8K_CMD_TIMEOUT_MS));

1566 1567 1568 1569
	priv->hostcmd_wait = NULL;

	mwl8k_fw_unlock(hw);

1570 1571 1572
	pci_unmap_single(priv->pdev, dma_addr, dma_size,
					PCI_DMA_BIDIRECTIONAL);

1573 1574
	if (!timeout) {
		printk(KERN_ERR "%s: Command %s timeout after %u ms\n",
L
Lennert Buytenhek 已提交
1575
		       wiphy_name(hw->wiphy),
1576 1577 1578 1579
		       mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
		       MWL8K_CMD_TIMEOUT_MS);
		rc = -ETIMEDOUT;
	} else {
1580 1581 1582 1583
		int ms;

		ms = MWL8K_CMD_TIMEOUT_MS - jiffies_to_msecs(timeout);

1584
		rc = cmd->result ? -EINVAL : 0;
1585 1586
		if (rc)
			printk(KERN_ERR "%s: Command %s error 0x%x\n",
L
Lennert Buytenhek 已提交
1587
			       wiphy_name(hw->wiphy),
1588
			       mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
1589
			       le16_to_cpu(cmd->result));
1590 1591 1592 1593 1594
		else if (ms > 2000)
			printk(KERN_NOTICE "%s: Command %s took %d ms\n",
			       wiphy_name(hw->wiphy),
			       mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
			       ms);
1595 1596 1597 1598 1599
	}

	return rc;
}

1600 1601 1602 1603 1604 1605 1606 1607 1608
static int mwl8k_post_pervif_cmd(struct ieee80211_hw *hw,
				 struct ieee80211_vif *vif,
				 struct mwl8k_cmd_pkt *cmd)
{
	if (vif != NULL)
		cmd->macid = MWL8K_VIF(vif)->macid;
	return mwl8k_post_cmd(hw, cmd);
}

1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
/*
 * Setup code shared between STA and AP firmware images.
 */
static void mwl8k_setup_2ghz_band(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;

	BUILD_BUG_ON(sizeof(priv->channels_24) != sizeof(mwl8k_channels_24));
	memcpy(priv->channels_24, mwl8k_channels_24, sizeof(mwl8k_channels_24));

	BUILD_BUG_ON(sizeof(priv->rates_24) != sizeof(mwl8k_rates_24));
	memcpy(priv->rates_24, mwl8k_rates_24, sizeof(mwl8k_rates_24));

	priv->band_24.band = IEEE80211_BAND_2GHZ;
	priv->band_24.channels = priv->channels_24;
	priv->band_24.n_channels = ARRAY_SIZE(mwl8k_channels_24);
	priv->band_24.bitrates = priv->rates_24;
	priv->band_24.n_bitrates = ARRAY_SIZE(mwl8k_rates_24);

	hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band_24;
}

1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649
static void mwl8k_setup_5ghz_band(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;

	BUILD_BUG_ON(sizeof(priv->channels_50) != sizeof(mwl8k_channels_50));
	memcpy(priv->channels_50, mwl8k_channels_50, sizeof(mwl8k_channels_50));

	BUILD_BUG_ON(sizeof(priv->rates_50) != sizeof(mwl8k_rates_50));
	memcpy(priv->rates_50, mwl8k_rates_50, sizeof(mwl8k_rates_50));

	priv->band_50.band = IEEE80211_BAND_5GHZ;
	priv->band_50.channels = priv->channels_50;
	priv->band_50.n_channels = ARRAY_SIZE(mwl8k_channels_50);
	priv->band_50.bitrates = priv->rates_50;
	priv->band_50.n_bitrates = ARRAY_SIZE(mwl8k_rates_50);

	hw->wiphy->bands[IEEE80211_BAND_5GHZ] = &priv->band_50;
}

1650
/*
1651
 * CMD_GET_HW_SPEC (STA version).
1652
 */
1653
struct mwl8k_cmd_get_hw_spec_sta {
1654 1655 1656 1657
	struct mwl8k_cmd_pkt header;
	__u8 hw_rev;
	__u8 host_interface;
	__le16 num_mcaddrs;
1658
	__u8 perm_addr[ETH_ALEN];
1659 1660 1661 1662 1663 1664 1665 1666 1667 1668
	__le16 region_code;
	__le32 fw_rev;
	__le32 ps_cookie;
	__le32 caps;
	__u8 mcs_bitmap[16];
	__le32 rx_queue_ptr;
	__le32 num_tx_queues;
	__le32 tx_queue_ptrs[MWL8K_TX_QUEUES];
	__le32 caps2;
	__le32 num_tx_desc_per_queue;
1669
	__le32 total_rxd;
1670 1671
} __attribute__((packed));

1672 1673 1674 1675 1676 1677 1678 1679 1680 1681 1682 1683
#define MWL8K_CAP_MAX_AMSDU		0x20000000
#define MWL8K_CAP_GREENFIELD		0x08000000
#define MWL8K_CAP_AMPDU			0x04000000
#define MWL8K_CAP_RX_STBC		0x01000000
#define MWL8K_CAP_TX_STBC		0x00800000
#define MWL8K_CAP_SHORTGI_40MHZ		0x00400000
#define MWL8K_CAP_SHORTGI_20MHZ		0x00200000
#define MWL8K_CAP_RX_ANTENNA_MASK	0x000e0000
#define MWL8K_CAP_TX_ANTENNA_MASK	0x0001c000
#define MWL8K_CAP_DELAY_BA		0x00003000
#define MWL8K_CAP_MIMO			0x00000200
#define MWL8K_CAP_40MHZ			0x00000100
1684 1685 1686
#define MWL8K_CAP_BAND_MASK		0x00000007
#define MWL8K_CAP_5GHZ			0x00000004
#define MWL8K_CAP_2GHZ4			0x00000001
1687

1688 1689 1690
static void
mwl8k_set_ht_caps(struct ieee80211_hw *hw,
		  struct ieee80211_supported_band *band, u32 cap)
1691 1692 1693 1694
{
	int rx_streams;
	int tx_streams;

1695
	band->ht_cap.ht_supported = 1;
1696 1697

	if (cap & MWL8K_CAP_MAX_AMSDU)
1698
		band->ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
1699
	if (cap & MWL8K_CAP_GREENFIELD)
1700
		band->ht_cap.cap |= IEEE80211_HT_CAP_GRN_FLD;
1701 1702
	if (cap & MWL8K_CAP_AMPDU) {
		hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
1703 1704
		band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
		band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
1705 1706
	}
	if (cap & MWL8K_CAP_RX_STBC)
1707
		band->ht_cap.cap |= IEEE80211_HT_CAP_RX_STBC;
1708
	if (cap & MWL8K_CAP_TX_STBC)
1709
		band->ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
1710
	if (cap & MWL8K_CAP_SHORTGI_40MHZ)
1711
		band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
1712
	if (cap & MWL8K_CAP_SHORTGI_20MHZ)
1713
		band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
1714
	if (cap & MWL8K_CAP_DELAY_BA)
1715
		band->ht_cap.cap |= IEEE80211_HT_CAP_DELAY_BA;
1716
	if (cap & MWL8K_CAP_40MHZ)
1717
		band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
1718 1719 1720 1721

	rx_streams = hweight32(cap & MWL8K_CAP_RX_ANTENNA_MASK);
	tx_streams = hweight32(cap & MWL8K_CAP_TX_ANTENNA_MASK);

1722
	band->ht_cap.mcs.rx_mask[0] = 0xff;
1723
	if (rx_streams >= 2)
1724
		band->ht_cap.mcs.rx_mask[1] = 0xff;
1725
	if (rx_streams >= 3)
1726 1727 1728
		band->ht_cap.mcs.rx_mask[2] = 0xff;
	band->ht_cap.mcs.rx_mask[4] = 0x01;
	band->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
1729 1730

	if (rx_streams != tx_streams) {
1731 1732
		band->ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
		band->ht_cap.mcs.tx_params |= (tx_streams - 1) <<
1733 1734 1735 1736
				IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
	}
}

1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754
static void
mwl8k_set_caps(struct ieee80211_hw *hw, u32 caps)
{
	struct mwl8k_priv *priv = hw->priv;

	if ((caps & MWL8K_CAP_2GHZ4) || !(caps & MWL8K_CAP_BAND_MASK)) {
		mwl8k_setup_2ghz_band(hw);
		if (caps & MWL8K_CAP_MIMO)
			mwl8k_set_ht_caps(hw, &priv->band_24, caps);
	}

	if (caps & MWL8K_CAP_5GHZ) {
		mwl8k_setup_5ghz_band(hw);
		if (caps & MWL8K_CAP_MIMO)
			mwl8k_set_ht_caps(hw, &priv->band_50, caps);
	}
}

1755
static int mwl8k_cmd_get_hw_spec_sta(struct ieee80211_hw *hw)
1756 1757
{
	struct mwl8k_priv *priv = hw->priv;
1758
	struct mwl8k_cmd_get_hw_spec_sta *cmd;
1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770
	int rc;
	int i;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_GET_HW_SPEC);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));

	memset(cmd->perm_addr, 0xff, sizeof(cmd->perm_addr));
	cmd->ps_cookie = cpu_to_le32(priv->cookie_dma);
1771
	cmd->rx_queue_ptr = cpu_to_le32(priv->rxq[0].rxd_dma);
1772
	cmd->num_tx_queues = cpu_to_le32(MWL8K_TX_QUEUES);
1773
	for (i = 0; i < MWL8K_TX_QUEUES; i++)
1774
		cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[i].txd_dma);
1775
	cmd->num_tx_desc_per_queue = cpu_to_le32(MWL8K_TX_DESCS);
1776
	cmd->total_rxd = cpu_to_le32(MWL8K_RX_DESCS);
1777 1778 1779 1780 1781 1782

	rc = mwl8k_post_cmd(hw, &cmd->header);

	if (!rc) {
		SET_IEEE80211_PERM_ADDR(hw, cmd->perm_addr);
		priv->num_mcaddrs = le16_to_cpu(cmd->num_mcaddrs);
1783
		priv->fw_rev = le32_to_cpu(cmd->fw_rev);
1784
		priv->hw_rev = cmd->hw_rev;
1785
		mwl8k_set_caps(hw, le32_to_cpu(cmd->caps));
1786 1787
		priv->ap_macids_supported = 0x00000000;
		priv->sta_macids_supported = 0x00000001;
1788 1789 1790 1791 1792 1793
	}

	kfree(cmd);
	return rc;
}

1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840
/*
 * CMD_GET_HW_SPEC (AP version).
 */
struct mwl8k_cmd_get_hw_spec_ap {
	struct mwl8k_cmd_pkt header;
	__u8 hw_rev;
	__u8 host_interface;
	__le16 num_wcb;
	__le16 num_mcaddrs;
	__u8 perm_addr[ETH_ALEN];
	__le16 region_code;
	__le16 num_antenna;
	__le32 fw_rev;
	__le32 wcbbase0;
	__le32 rxwrptr;
	__le32 rxrdptr;
	__le32 ps_cookie;
	__le32 wcbbase1;
	__le32 wcbbase2;
	__le32 wcbbase3;
} __attribute__((packed));

static int mwl8k_cmd_get_hw_spec_ap(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_cmd_get_hw_spec_ap *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_GET_HW_SPEC);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));

	memset(cmd->perm_addr, 0xff, sizeof(cmd->perm_addr));
	cmd->ps_cookie = cpu_to_le32(priv->cookie_dma);

	rc = mwl8k_post_cmd(hw, &cmd->header);

	if (!rc) {
		int off;

		SET_IEEE80211_PERM_ADDR(hw, cmd->perm_addr);
		priv->num_mcaddrs = le16_to_cpu(cmd->num_mcaddrs);
		priv->fw_rev = le32_to_cpu(cmd->fw_rev);
		priv->hw_rev = cmd->hw_rev;
1841
		mwl8k_setup_2ghz_band(hw);
1842 1843
		priv->ap_macids_supported = 0x000000ff;
		priv->sta_macids_supported = 0x00000000;
1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888

		off = le32_to_cpu(cmd->wcbbase0) & 0xffff;
		iowrite32(cpu_to_le32(priv->txq[0].txd_dma), priv->sram + off);

		off = le32_to_cpu(cmd->rxwrptr) & 0xffff;
		iowrite32(cpu_to_le32(priv->rxq[0].rxd_dma), priv->sram + off);

		off = le32_to_cpu(cmd->rxrdptr) & 0xffff;
		iowrite32(cpu_to_le32(priv->rxq[0].rxd_dma), priv->sram + off);

		off = le32_to_cpu(cmd->wcbbase1) & 0xffff;
		iowrite32(cpu_to_le32(priv->txq[1].txd_dma), priv->sram + off);

		off = le32_to_cpu(cmd->wcbbase2) & 0xffff;
		iowrite32(cpu_to_le32(priv->txq[2].txd_dma), priv->sram + off);

		off = le32_to_cpu(cmd->wcbbase3) & 0xffff;
		iowrite32(cpu_to_le32(priv->txq[3].txd_dma), priv->sram + off);
	}

	kfree(cmd);
	return rc;
}

/*
 * CMD_SET_HW_SPEC.
 */
struct mwl8k_cmd_set_hw_spec {
	struct mwl8k_cmd_pkt header;
	__u8 hw_rev;
	__u8 host_interface;
	__le16 num_mcaddrs;
	__u8 perm_addr[ETH_ALEN];
	__le16 region_code;
	__le32 fw_rev;
	__le32 ps_cookie;
	__le32 caps;
	__le32 rx_queue_ptr;
	__le32 num_tx_queues;
	__le32 tx_queue_ptrs[MWL8K_TX_QUEUES];
	__le32 flags;
	__le32 num_tx_desc_per_queue;
	__le32 total_rxd;
} __attribute__((packed));

1889 1890 1891
#define MWL8K_SET_HW_SPEC_FLAG_HOST_DECR_MGMT		0x00000080
#define MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_PROBERESP	0x00000020
#define MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_BEACON		0x00000010
1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911

static int mwl8k_cmd_set_hw_spec(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_cmd_set_hw_spec *cmd;
	int rc;
	int i;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_HW_SPEC);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));

	cmd->ps_cookie = cpu_to_le32(priv->cookie_dma);
	cmd->rx_queue_ptr = cpu_to_le32(priv->rxq[0].rxd_dma);
	cmd->num_tx_queues = cpu_to_le32(MWL8K_TX_QUEUES);
	for (i = 0; i < MWL8K_TX_QUEUES; i++)
		cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[i].txd_dma);
1912 1913 1914
	cmd->flags = cpu_to_le32(MWL8K_SET_HW_SPEC_FLAG_HOST_DECR_MGMT |
				 MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_PROBERESP |
				 MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_BEACON);
1915 1916 1917 1918 1919 1920 1921 1922 1923
	cmd->num_tx_desc_per_queue = cpu_to_le32(MWL8K_TX_DESCS);
	cmd->total_rxd = cpu_to_le32(MWL8K_RX_DESCS);

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

1924 1925 1926 1927 1928 1929 1930
/*
 * CMD_MAC_MULTICAST_ADR.
 */
struct mwl8k_cmd_mac_multicast_adr {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 numaddr;
1931
	__u8 addr[0][ETH_ALEN];
1932 1933
};

1934 1935 1936 1937
#define MWL8K_ENABLE_RX_DIRECTED	0x0001
#define MWL8K_ENABLE_RX_MULTICAST	0x0002
#define MWL8K_ENABLE_RX_ALL_MULTICAST	0x0004
#define MWL8K_ENABLE_RX_BROADCAST	0x0008
1938

1939
static struct mwl8k_cmd_pkt *
L
Lennert Buytenhek 已提交
1940
__mwl8k_cmd_mac_multicast_adr(struct ieee80211_hw *hw, int allmulti,
1941
			      int mc_count, struct dev_addr_list *mclist)
1942
{
1943
	struct mwl8k_priv *priv = hw->priv;
1944
	struct mwl8k_cmd_mac_multicast_adr *cmd;
1945 1946
	int size;

L
Lennert Buytenhek 已提交
1947
	if (allmulti || mc_count > priv->num_mcaddrs) {
1948 1949 1950
		allmulti = 1;
		mc_count = 0;
	}
1951 1952

	size = sizeof(*cmd) + mc_count * ETH_ALEN;
1953

1954
	cmd = kzalloc(size, GFP_ATOMIC);
1955
	if (cmd == NULL)
1956
		return NULL;
1957 1958 1959

	cmd->header.code = cpu_to_le16(MWL8K_CMD_MAC_MULTICAST_ADR);
	cmd->header.length = cpu_to_le16(size);
1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976
	cmd->action = cpu_to_le16(MWL8K_ENABLE_RX_DIRECTED |
				  MWL8K_ENABLE_RX_BROADCAST);

	if (allmulti) {
		cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_ALL_MULTICAST);
	} else if (mc_count) {
		int i;

		cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_MULTICAST);
		cmd->numaddr = cpu_to_le16(mc_count);
		for (i = 0; i < mc_count && mclist; i++) {
			if (mclist->da_addrlen != ETH_ALEN) {
				kfree(cmd);
				return NULL;
			}
			memcpy(cmd->addr[i], mclist->da_addr, ETH_ALEN);
			mclist = mclist->next;
1977 1978 1979
		}
	}

1980
	return &cmd->header;
1981 1982 1983
}

/*
1984
 * CMD_GET_STAT.
1985
 */
1986
struct mwl8k_cmd_get_stat {
1987 1988 1989 1990 1991 1992 1993 1994 1995
	struct mwl8k_cmd_pkt header;
	__le32 stats[64];
} __attribute__((packed));

#define MWL8K_STAT_ACK_FAILURE	9
#define MWL8K_STAT_RTS_FAILURE	12
#define MWL8K_STAT_FCS_ERROR	24
#define MWL8K_STAT_RTS_SUCCESS	11

1996 1997
static int mwl8k_cmd_get_stat(struct ieee80211_hw *hw,
			      struct ieee80211_low_level_stats *stats)
1998
{
1999
	struct mwl8k_cmd_get_stat *cmd;
2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_GET_STAT);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));

	rc = mwl8k_post_cmd(hw, &cmd->header);
	if (!rc) {
		stats->dot11ACKFailureCount =
			le32_to_cpu(cmd->stats[MWL8K_STAT_ACK_FAILURE]);
		stats->dot11RTSFailureCount =
			le32_to_cpu(cmd->stats[MWL8K_STAT_RTS_FAILURE]);
		stats->dot11FCSErrorCount =
			le32_to_cpu(cmd->stats[MWL8K_STAT_FCS_ERROR]);
		stats->dot11RTSSuccessCount =
			le32_to_cpu(cmd->stats[MWL8K_STAT_RTS_SUCCESS]);
	}
	kfree(cmd);

	return rc;
}

/*
2026
 * CMD_RADIO_CONTROL.
2027
 */
2028
struct mwl8k_cmd_radio_control {
2029 2030 2031 2032 2033 2034
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 control;
	__le16 radio_on;
} __attribute__((packed));

2035
static int
2036
mwl8k_cmd_radio_control(struct ieee80211_hw *hw, bool enable, bool force)
2037 2038
{
	struct mwl8k_priv *priv = hw->priv;
2039
	struct mwl8k_cmd_radio_control *cmd;
2040 2041
	int rc;

2042
	if (enable == priv->radio_on && !force)
2043 2044 2045 2046 2047 2048 2049 2050 2051
		return 0;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_RADIO_CONTROL);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
2052
	cmd->control = cpu_to_le16(priv->radio_short_preamble ? 3 : 1);
2053 2054 2055 2056 2057 2058
	cmd->radio_on = cpu_to_le16(enable ? 0x0001 : 0x0000);

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	if (!rc)
2059
		priv->radio_on = enable;
2060 2061 2062 2063

	return rc;
}

2064
static int mwl8k_cmd_radio_disable(struct ieee80211_hw *hw)
2065
{
2066
	return mwl8k_cmd_radio_control(hw, 0, 0);
2067 2068
}

2069
static int mwl8k_cmd_radio_enable(struct ieee80211_hw *hw)
2070
{
2071
	return mwl8k_cmd_radio_control(hw, 1, 0);
2072 2073
}

2074 2075 2076
static int
mwl8k_set_radio_preamble(struct ieee80211_hw *hw, bool short_preamble)
{
2077
	struct mwl8k_priv *priv = hw->priv;
2078

2079
	priv->radio_short_preamble = short_preamble;
2080

2081
	return mwl8k_cmd_radio_control(hw, 1, 1);
2082 2083 2084
}

/*
2085
 * CMD_RF_TX_POWER.
2086 2087 2088
 */
#define MWL8K_TX_POWER_LEVEL_TOTAL	8

2089
struct mwl8k_cmd_rf_tx_power {
2090 2091 2092 2093 2094 2095 2096 2097
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 support_level;
	__le16 current_level;
	__le16 reserved;
	__le16 power_level_list[MWL8K_TX_POWER_LEVEL_TOTAL];
} __attribute__((packed));

2098
static int mwl8k_cmd_rf_tx_power(struct ieee80211_hw *hw, int dBm)
2099
{
2100
	struct mwl8k_cmd_rf_tx_power *cmd;
2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_RF_TX_POWER);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->support_level = cpu_to_le16(dBm);

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150
/*
 * CMD_RF_ANTENNA.
 */
struct mwl8k_cmd_rf_antenna {
	struct mwl8k_cmd_pkt header;
	__le16 antenna;
	__le16 mode;
} __attribute__((packed));

#define MWL8K_RF_ANTENNA_RX		1
#define MWL8K_RF_ANTENNA_TX		2

static int
mwl8k_cmd_rf_antenna(struct ieee80211_hw *hw, int antenna, int mask)
{
	struct mwl8k_cmd_rf_antenna *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_RF_ANTENNA);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->antenna = cpu_to_le16(antenna);
	cmd->mode = cpu_to_le16(mask);

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

2151 2152 2153 2154 2155 2156 2157 2158 2159
/*
 * CMD_SET_BEACON.
 */
struct mwl8k_cmd_set_beacon {
	struct mwl8k_cmd_pkt header;
	__le16 beacon_len;
	__u8 beacon[0];
};

2160 2161
static int mwl8k_cmd_set_beacon(struct ieee80211_hw *hw,
				struct ieee80211_vif *vif, u8 *beacon, int len)
2162 2163 2164 2165 2166 2167 2168 2169 2170 2171 2172 2173 2174
{
	struct mwl8k_cmd_set_beacon *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd) + len, GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_BEACON);
	cmd->header.length = cpu_to_le16(sizeof(*cmd) + len);
	cmd->beacon_len = cpu_to_le16(len);
	memcpy(cmd->beacon, beacon, len);

2175
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2176 2177 2178 2179 2180
	kfree(cmd);

	return rc;
}

2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211
/*
 * CMD_SET_PRE_SCAN.
 */
struct mwl8k_cmd_set_pre_scan {
	struct mwl8k_cmd_pkt header;
} __attribute__((packed));

static int mwl8k_cmd_set_pre_scan(struct ieee80211_hw *hw)
{
	struct mwl8k_cmd_set_pre_scan *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_PRE_SCAN);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

/*
 * CMD_SET_POST_SCAN.
 */
struct mwl8k_cmd_set_post_scan {
	struct mwl8k_cmd_pkt header;
	__le32 isibss;
2212
	__u8 bssid[ETH_ALEN];
2213 2214 2215
} __attribute__((packed));

static int
2216
mwl8k_cmd_set_post_scan(struct ieee80211_hw *hw, const __u8 *mac)
2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227
{
	struct mwl8k_cmd_set_post_scan *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_POST_SCAN);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->isibss = 0;
2228
	memcpy(cmd->bssid, mac, ETH_ALEN);
2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

/*
 * CMD_SET_RF_CHANNEL.
 */
struct mwl8k_cmd_set_rf_channel {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__u8 current_channel;
	__le32 channel_flags;
} __attribute__((packed));

static int mwl8k_cmd_set_rf_channel(struct ieee80211_hw *hw,
2247
				    struct ieee80211_conf *conf)
2248
{
2249
	struct ieee80211_channel *channel = conf->channel;
2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260
	struct mwl8k_cmd_set_rf_channel *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RF_CHANNEL);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->current_channel = channel->hw_value;
2261

2262
	if (channel->band == IEEE80211_BAND_2GHZ)
2263
		cmd->channel_flags |= cpu_to_le32(0x00000001);
2264 2265
	else if (channel->band == IEEE80211_BAND_5GHZ)
		cmd->channel_flags |= cpu_to_le32(0x00000004);
2266 2267 2268 2269 2270 2271 2272 2273

	if (conf->channel_type == NL80211_CHAN_NO_HT ||
	    conf->channel_type == NL80211_CHAN_HT20)
		cmd->channel_flags |= cpu_to_le32(0x00000080);
	else if (conf->channel_type == NL80211_CHAN_HT40MINUS)
		cmd->channel_flags |= cpu_to_le32(0x000001900);
	else if (conf->channel_type == NL80211_CHAN_HT40PLUS)
		cmd->channel_flags |= cpu_to_le32(0x000000900);
2274 2275 2276 2277 2278 2279 2280 2281

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

/*
2282
 * CMD_SET_AID.
2283
 */
2284 2285 2286 2287
#define MWL8K_FRAME_PROT_DISABLED			0x00
#define MWL8K_FRAME_PROT_11G				0x07
#define MWL8K_FRAME_PROT_11N_HT_40MHZ_ONLY		0x02
#define MWL8K_FRAME_PROT_11N_HT_ALL			0x06
2288

2289 2290 2291
struct mwl8k_cmd_update_set_aid {
	struct	mwl8k_cmd_pkt header;
	__le16	aid;
2292

2293 2294 2295 2296
	 /* AP's MAC address (BSSID) */
	__u8	bssid[ETH_ALEN];
	__le16	protection_mode;
	__u8	supp_rates[14];
2297 2298
} __attribute__((packed));

L
Lennert Buytenhek 已提交
2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
static void legacy_rate_mask_to_array(u8 *rates, u32 mask)
{
	int i;
	int j;

	/*
	 * Clear nonstandard rates 4 and 13.
	 */
	mask &= 0x1fef;

	for (i = 0, j = 0; i < 14; i++) {
		if (mask & (1 << i))
2311
			rates[j++] = mwl8k_rates_24[i].hw_value;
L
Lennert Buytenhek 已提交
2312 2313 2314
	}
}

2315
static int
L
Lennert Buytenhek 已提交
2316 2317
mwl8k_cmd_set_aid(struct ieee80211_hw *hw,
		  struct ieee80211_vif *vif, u32 legacy_rate_mask)
2318
{
2319 2320
	struct mwl8k_cmd_update_set_aid *cmd;
	u16 prot_mode;
2321 2322 2323 2324 2325 2326
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

2327
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_AID);
2328
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2329
	cmd->aid = cpu_to_le16(vif->bss_conf.aid);
2330
	memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN);
2331

2332
	if (vif->bss_conf.use_cts_prot) {
2333 2334
		prot_mode = MWL8K_FRAME_PROT_11G;
	} else {
2335
		switch (vif->bss_conf.ht_operation_mode &
2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348
			IEEE80211_HT_OP_MODE_PROTECTION) {
		case IEEE80211_HT_OP_MODE_PROTECTION_20MHZ:
			prot_mode = MWL8K_FRAME_PROT_11N_HT_40MHZ_ONLY;
			break;
		case IEEE80211_HT_OP_MODE_PROTECTION_NONHT_MIXED:
			prot_mode = MWL8K_FRAME_PROT_11N_HT_ALL;
			break;
		default:
			prot_mode = MWL8K_FRAME_PROT_DISABLED;
			break;
		}
	}
	cmd->protection_mode = cpu_to_le16(prot_mode);
2349

L
Lennert Buytenhek 已提交
2350
	legacy_rate_mask_to_array(cmd->supp_rates, legacy_rate_mask);
2351 2352 2353 2354 2355 2356 2357

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

2358
/*
2359
 * CMD_SET_RATE.
2360
 */
2361 2362 2363 2364 2365 2366 2367
struct mwl8k_cmd_set_rate {
	struct	mwl8k_cmd_pkt header;
	__u8	legacy_rates[14];

	/* Bitmap for supported MCS codes.  */
	__u8	mcs_set[16];
	__u8	reserved[16];
2368 2369
} __attribute__((packed));

2370
static int
L
Lennert Buytenhek 已提交
2371
mwl8k_cmd_set_rate(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2372
		   u32 legacy_rate_mask, u8 *mcs_rates)
2373
{
2374
	struct mwl8k_cmd_set_rate *cmd;
2375 2376 2377 2378 2379 2380
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

2381
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATE);
2382
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
2383
	legacy_rate_mask_to_array(cmd->legacy_rates, legacy_rate_mask);
2384
	memcpy(cmd->mcs_set, mcs_rates, 16);
2385 2386 2387 2388 2389 2390 2391

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

2392
/*
2393
 * CMD_FINALIZE_JOIN.
2394
 */
2395 2396 2397
#define MWL8K_FJ_BEACON_MAXLEN	128

struct mwl8k_cmd_finalize_join {
2398
	struct mwl8k_cmd_pkt header;
2399 2400
	__le32 sleep_interval;	/* Number of beacon periods to sleep */
	__u8 beacon_data[MWL8K_FJ_BEACON_MAXLEN];
2401 2402
} __attribute__((packed));

2403 2404
static int mwl8k_cmd_finalize_join(struct ieee80211_hw *hw, void *frame,
				   int framelen, int dtim)
2405
{
2406 2407 2408
	struct mwl8k_cmd_finalize_join *cmd;
	struct ieee80211_mgmt *payload = frame;
	int payload_len;
2409 2410 2411 2412 2413 2414
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

2415
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_FINALIZE_JOIN);
2416
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2417 2418 2419 2420 2421 2422 2423 2424 2425
	cmd->sleep_interval = cpu_to_le32(dtim ? dtim : 1);

	payload_len = framelen - ieee80211_hdrlen(payload->frame_control);
	if (payload_len < 0)
		payload_len = 0;
	else if (payload_len > MWL8K_FJ_BEACON_MAXLEN)
		payload_len = MWL8K_FJ_BEACON_MAXLEN;

	memcpy(cmd->beacon_data, &payload->u.beacon, payload_len);
2426 2427 2428 2429 2430 2431 2432 2433

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

/*
2434
 * CMD_SET_RTS_THRESHOLD.
2435
 */
2436
struct mwl8k_cmd_set_rts_threshold {
2437 2438
	struct mwl8k_cmd_pkt header;
	__le16 action;
2439
	__le16 threshold;
2440 2441
} __attribute__((packed));

L
Lennert Buytenhek 已提交
2442 2443
static int
mwl8k_cmd_set_rts_threshold(struct ieee80211_hw *hw, int rts_thresh)
2444
{
2445
	struct mwl8k_cmd_set_rts_threshold *cmd;
2446 2447 2448 2449 2450 2451
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

2452
	cmd->header.code = cpu_to_le16(MWL8K_CMD_RTS_THRESHOLD);
2453
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
2454 2455
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->threshold = cpu_to_le16(rts_thresh);
2456 2457 2458 2459 2460 2461 2462 2463

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

/*
2464
 * CMD_SET_SLOT.
2465
 */
2466
struct mwl8k_cmd_set_slot {
2467 2468
	struct mwl8k_cmd_pkt header;
	__le16 action;
2469
	__u8 short_slot;
2470 2471
} __attribute__((packed));

2472
static int mwl8k_cmd_set_slot(struct ieee80211_hw *hw, bool short_slot_time)
2473
{
2474
	struct mwl8k_cmd_set_slot *cmd;
2475 2476 2477 2478 2479 2480
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

2481
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_SLOT);
2482
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2483 2484
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->short_slot = short_slot_time;
2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

/*
 * CMD_SET_EDCA_PARAMS.
 */
struct mwl8k_cmd_set_edca_params {
	struct mwl8k_cmd_pkt header;

	/* See MWL8K_SET_EDCA_XXX below */
	__le16 action;

	/* TX opportunity in units of 32 us */
	__le16 txop;

2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520
	union {
		struct {
			/* Log exponent of max contention period: 0...15 */
			__le32 log_cw_max;

			/* Log exponent of min contention period: 0...15 */
			__le32 log_cw_min;

			/* Adaptive interframe spacing in units of 32us */
			__u8 aifs;

			/* TX queue to configure */
			__u8 txq;
		} ap;
		struct {
			/* Log exponent of max contention period: 0...15 */
			__u8 log_cw_max;
2521

2522 2523
			/* Log exponent of min contention period: 0...15 */
			__u8 log_cw_min;
2524

2525 2526
			/* Adaptive interframe spacing in units of 32us */
			__u8 aifs;
2527

2528 2529 2530 2531
			/* TX queue to configure */
			__u8 txq;
		} sta;
	};
2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542
} __attribute__((packed));

#define MWL8K_SET_EDCA_CW	0x01
#define MWL8K_SET_EDCA_TXOP	0x02
#define MWL8K_SET_EDCA_AIFS	0x04

#define MWL8K_SET_EDCA_ALL	(MWL8K_SET_EDCA_CW | \
				 MWL8K_SET_EDCA_TXOP | \
				 MWL8K_SET_EDCA_AIFS)

static int
2543 2544 2545
mwl8k_cmd_set_edca_params(struct ieee80211_hw *hw, __u8 qnum,
			  __u16 cw_min, __u16 cw_max,
			  __u8 aifs, __u16 txop)
2546
{
2547
	struct mwl8k_priv *priv = hw->priv;
2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558
	struct mwl8k_cmd_set_edca_params *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_EDCA_PARAMS);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->action = cpu_to_le16(MWL8K_SET_EDCA_ALL);
	cmd->txop = cpu_to_le16(txop);
2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569
	if (priv->ap_fw) {
		cmd->ap.log_cw_max = cpu_to_le32(ilog2(cw_max + 1));
		cmd->ap.log_cw_min = cpu_to_le32(ilog2(cw_min + 1));
		cmd->ap.aifs = aifs;
		cmd->ap.txq = qnum;
	} else {
		cmd->sta.log_cw_max = (u8)ilog2(cw_max + 1);
		cmd->sta.log_cw_min = (u8)ilog2(cw_min + 1);
		cmd->sta.aifs = aifs;
		cmd->sta.txq = qnum;
	}
2570 2571 2572 2573 2574 2575 2576 2577

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

/*
2578
 * CMD_SET_WMM_MODE.
2579
 */
2580
struct mwl8k_cmd_set_wmm_mode {
2581
	struct mwl8k_cmd_pkt header;
2582
	__le16 action;
2583 2584
} __attribute__((packed));

2585
static int mwl8k_cmd_set_wmm_mode(struct ieee80211_hw *hw, bool enable)
2586
{
2587 2588
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_cmd_set_wmm_mode *cmd;
2589 2590 2591 2592 2593 2594
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

2595
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_WMM_MODE);
2596
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2597
	cmd->action = cpu_to_le16(!!enable);
2598 2599 2600

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);
2601

2602 2603
	if (!rc)
		priv->wmm_enabled = enable;
2604 2605 2606 2607 2608

	return rc;
}

/*
2609
 * CMD_MIMO_CONFIG.
2610
 */
2611 2612 2613 2614 2615
struct mwl8k_cmd_mimo_config {
	struct mwl8k_cmd_pkt header;
	__le32 action;
	__u8 rx_antenna_map;
	__u8 tx_antenna_map;
2616 2617
} __attribute__((packed));

2618
static int mwl8k_cmd_mimo_config(struct ieee80211_hw *hw, __u8 rx, __u8 tx)
2619
{
2620
	struct mwl8k_cmd_mimo_config *cmd;
2621 2622 2623 2624 2625 2626
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

2627
	cmd->header.code = cpu_to_le16(MWL8K_CMD_MIMO_CONFIG);
2628
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2629 2630 2631
	cmd->action = cpu_to_le32((u32)MWL8K_CMD_SET);
	cmd->rx_antenna_map = rx;
	cmd->tx_antenna_map = tx;
2632 2633 2634 2635 2636 2637 2638 2639

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

/*
2640
 * CMD_USE_FIXED_RATE (STA version).
2641
 */
2642 2643 2644 2645 2646 2647 2648 2649 2650 2651 2652 2653 2654 2655
struct mwl8k_cmd_use_fixed_rate_sta {
	struct mwl8k_cmd_pkt header;
	__le32 action;
	__le32 allow_rate_drop;
	__le32 num_rates;
	struct {
		__le32 is_ht_rate;
		__le32 enable_retry;
		__le32 rate;
		__le32 retry_count;
	} rate_entry[8];
	__le32 rate_type;
	__le32 reserved1;
	__le32 reserved2;
2656 2657
} __attribute__((packed));

2658 2659
#define MWL8K_USE_AUTO_RATE	0x0002
#define MWL8K_UCAST_RATE	0
2660

2661
static int mwl8k_cmd_use_fixed_rate_sta(struct ieee80211_hw *hw)
2662
{
2663
	struct mwl8k_cmd_use_fixed_rate_sta *cmd;
2664 2665 2666 2667 2668 2669 2670 2671
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_USE_FIXED_RATE);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2672 2673
	cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE);
	cmd->rate_type = cpu_to_le32(MWL8K_UCAST_RATE);
2674 2675 2676 2677 2678 2679 2680

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721
/*
 * CMD_USE_FIXED_RATE (AP version).
 */
struct mwl8k_cmd_use_fixed_rate_ap {
	struct mwl8k_cmd_pkt header;
	__le32 action;
	__le32 allow_rate_drop;
	__le32 num_rates;
	struct mwl8k_rate_entry_ap {
		__le32 is_ht_rate;
		__le32 enable_retry;
		__le32 rate;
		__le32 retry_count;
	} rate_entry[4];
	u8 multicast_rate;
	u8 multicast_rate_type;
	u8 management_rate;
} __attribute__((packed));

static int
mwl8k_cmd_use_fixed_rate_ap(struct ieee80211_hw *hw, int mcast, int mgmt)
{
	struct mwl8k_cmd_use_fixed_rate_ap *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_USE_FIXED_RATE);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE);
	cmd->multicast_rate = mcast;
	cmd->management_rate = mgmt;

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

2722 2723 2724 2725 2726 2727 2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762
/*
 * CMD_ENABLE_SNIFFER.
 */
struct mwl8k_cmd_enable_sniffer {
	struct mwl8k_cmd_pkt header;
	__le32 action;
} __attribute__((packed));

static int mwl8k_cmd_enable_sniffer(struct ieee80211_hw *hw, bool enable)
{
	struct mwl8k_cmd_enable_sniffer *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_ENABLE_SNIFFER);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->action = cpu_to_le32(!!enable);

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

/*
 * CMD_SET_MAC_ADDR.
 */
struct mwl8k_cmd_set_mac_addr {
	struct mwl8k_cmd_pkt header;
	union {
		struct {
			__le16 mac_type;
			__u8 mac_addr[ETH_ALEN];
		} mbss;
		__u8 mac_addr[ETH_ALEN];
	};
} __attribute__((packed));

2763 2764 2765 2766
#define MWL8K_MAC_TYPE_PRIMARY_CLIENT		0
#define MWL8K_MAC_TYPE_SECONDARY_CLIENT		1
#define MWL8K_MAC_TYPE_PRIMARY_AP		2
#define MWL8K_MAC_TYPE_SECONDARY_AP		3
2767

2768 2769
static int mwl8k_cmd_set_mac_addr(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif, u8 *mac)
2770 2771
{
	struct mwl8k_priv *priv = hw->priv;
2772
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
2773
	struct mwl8k_cmd_set_mac_addr *cmd;
2774
	int mac_type;
2775 2776
	int rc;

2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789
	mac_type = MWL8K_MAC_TYPE_PRIMARY_AP;
	if (vif != NULL && vif->type == NL80211_IFTYPE_STATION) {
		if (mwl8k_vif->macid + 1 == ffs(priv->sta_macids_supported))
			mac_type = MWL8K_MAC_TYPE_PRIMARY_CLIENT;
		else
			mac_type = MWL8K_MAC_TYPE_SECONDARY_CLIENT;
	} else if (vif != NULL && vif->type == NL80211_IFTYPE_AP) {
		if (mwl8k_vif->macid + 1 == ffs(priv->ap_macids_supported))
			mac_type = MWL8K_MAC_TYPE_PRIMARY_AP;
		else
			mac_type = MWL8K_MAC_TYPE_SECONDARY_AP;
	}

2790 2791 2792 2793 2794 2795 2796
	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_MAC_ADDR);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	if (priv->ap_fw) {
2797
		cmd->mbss.mac_type = cpu_to_le16(mac_type);
2798 2799 2800 2801 2802
		memcpy(cmd->mbss.mac_addr, mac, ETH_ALEN);
	} else {
		memcpy(cmd->mac_addr, mac, ETH_ALEN);
	}

2803
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2804 2805 2806 2807 2808 2809 2810 2811 2812 2813 2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837
	kfree(cmd);

	return rc;
}

/*
 * CMD_SET_RATEADAPT_MODE.
 */
struct mwl8k_cmd_set_rate_adapt_mode {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 mode;
} __attribute__((packed));

static int mwl8k_cmd_set_rateadapt_mode(struct ieee80211_hw *hw, __u16 mode)
{
	struct mwl8k_cmd_set_rate_adapt_mode *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATEADAPT_MODE);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->mode = cpu_to_le16(mode);

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc;
}

2838 2839 2840 2841 2842 2843 2844 2845
/*
 * CMD_BSS_START.
 */
struct mwl8k_cmd_bss_start {
	struct mwl8k_cmd_pkt header;
	__le32 enable;
} __attribute__((packed));

2846 2847
static int mwl8k_cmd_bss_start(struct ieee80211_hw *hw,
			       struct ieee80211_vif *vif, int enable)
2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859
{
	struct mwl8k_cmd_bss_start *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_BSS_START);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->enable = cpu_to_le32(enable);

2860
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2861 2862 2863 2864 2865
	kfree(cmd);

	return rc;
}

2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898
/*
 * CMD_SET_NEW_STN.
 */
struct mwl8k_cmd_set_new_stn {
	struct mwl8k_cmd_pkt header;
	__le16 aid;
	__u8 mac_addr[6];
	__le16 stn_id;
	__le16 action;
	__le16 rsvd;
	__le32 legacy_rates;
	__u8 ht_rates[4];
	__le16 cap_info;
	__le16 ht_capabilities_info;
	__u8 mac_ht_param_info;
	__u8 rev;
	__u8 control_channel;
	__u8 add_channel;
	__le16 op_mode;
	__le16 stbc;
	__u8 add_qos_info;
	__u8 is_qos_sta;
	__le32 fw_sta_ptr;
} __attribute__((packed));

#define MWL8K_STA_ACTION_ADD		0
#define MWL8K_STA_ACTION_REMOVE		2

static int mwl8k_cmd_set_new_stn_add(struct ieee80211_hw *hw,
				     struct ieee80211_vif *vif,
				     struct ieee80211_sta *sta)
{
	struct mwl8k_cmd_set_new_stn *cmd;
2899
	u32 rates;
2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_NEW_STN);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->aid = cpu_to_le16(sta->aid);
	memcpy(cmd->mac_addr, sta->addr, ETH_ALEN);
	cmd->stn_id = cpu_to_le16(sta->aid);
	cmd->action = cpu_to_le16(MWL8K_STA_ACTION_ADD);
2912 2913 2914 2915 2916
	if (hw->conf.channel->band == IEEE80211_BAND_2GHZ)
		rates = sta->supp_rates[IEEE80211_BAND_2GHZ];
	else
		rates = sta->supp_rates[IEEE80211_BAND_5GHZ] << 5;
	cmd->legacy_rates = cpu_to_le32(rates);
2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927
	if (sta->ht_cap.ht_supported) {
		cmd->ht_rates[0] = sta->ht_cap.mcs.rx_mask[0];
		cmd->ht_rates[1] = sta->ht_cap.mcs.rx_mask[1];
		cmd->ht_rates[2] = sta->ht_cap.mcs.rx_mask[2];
		cmd->ht_rates[3] = sta->ht_cap.mcs.rx_mask[3];
		cmd->ht_capabilities_info = cpu_to_le16(sta->ht_cap.cap);
		cmd->mac_ht_param_info = (sta->ht_cap.ampdu_factor & 3) |
			((sta->ht_cap.ampdu_density & 7) << 2);
		cmd->is_qos_sta = 1;
	}

2928
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2929 2930 2931 2932 2933
	kfree(cmd);

	return rc;
}

2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947
static int mwl8k_cmd_set_new_stn_add_self(struct ieee80211_hw *hw,
					  struct ieee80211_vif *vif)
{
	struct mwl8k_cmd_set_new_stn *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_NEW_STN);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	memcpy(cmd->mac_addr, vif->addr, ETH_ALEN);

2948
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2949 2950 2951 2952 2953
	kfree(cmd);

	return rc;
}

2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968
static int mwl8k_cmd_set_new_stn_del(struct ieee80211_hw *hw,
				     struct ieee80211_vif *vif, u8 *addr)
{
	struct mwl8k_cmd_set_new_stn *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_NEW_STN);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	memcpy(cmd->mac_addr, addr, ETH_ALEN);
	cmd->action = cpu_to_le16(MWL8K_STA_ACTION_REMOVE);

2969
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2970 2971 2972 2973 2974
	kfree(cmd);

	return rc;
}

2975 2976 2977
/*
 * CMD_UPDATE_STADB.
 */
2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012
struct ewc_ht_info {
	__le16	control1;
	__le16	control2;
	__le16	control3;
} __attribute__((packed));

struct peer_capability_info {
	/* Peer type - AP vs. STA.  */
	__u8	peer_type;

	/* Basic 802.11 capabilities from assoc resp.  */
	__le16	basic_caps;

	/* Set if peer supports 802.11n high throughput (HT).  */
	__u8	ht_support;

	/* Valid if HT is supported.  */
	__le16	ht_caps;
	__u8	extended_ht_caps;
	struct ewc_ht_info	ewc_info;

	/* Legacy rate table. Intersection of our rates and peer rates.  */
	__u8	legacy_rates[12];

	/* HT rate table. Intersection of our rates and peer rates.  */
	__u8	ht_rates[16];
	__u8	pad[16];

	/* If set, interoperability mode, no proprietary extensions.  */
	__u8	interop;
	__u8	pad2;
	__u8	station_id;
	__le16	amsdu_enabled;
} __attribute__((packed));

3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027
struct mwl8k_cmd_update_stadb {
	struct mwl8k_cmd_pkt header;

	/* See STADB_ACTION_TYPE */
	__le32	action;

	/* Peer MAC address */
	__u8	peer_addr[ETH_ALEN];

	__le32	reserved;

	/* Peer info - valid during add/update.  */
	struct peer_capability_info	peer_info;
} __attribute__((packed));

3028 3029 3030 3031 3032 3033 3034
#define MWL8K_STA_DB_MODIFY_ENTRY	1
#define MWL8K_STA_DB_DEL_ENTRY		2

/* Peer Entry flags - used to define the type of the peer node */
#define MWL8K_PEER_TYPE_ACCESSPOINT	2

static int mwl8k_cmd_update_stadb_add(struct ieee80211_hw *hw,
L
Lennert Buytenhek 已提交
3035
				      struct ieee80211_vif *vif,
3036
				      struct ieee80211_sta *sta)
3037 3038
{
	struct mwl8k_cmd_update_stadb *cmd;
3039
	struct peer_capability_info *p;
3040
	u32 rates;
3041 3042 3043 3044 3045 3046 3047 3048
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_STADB);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
3049
	cmd->action = cpu_to_le32(MWL8K_STA_DB_MODIFY_ENTRY);
3050
	memcpy(cmd->peer_addr, sta->addr, ETH_ALEN);
3051

3052 3053 3054
	p = &cmd->peer_info;
	p->peer_type = MWL8K_PEER_TYPE_ACCESSPOINT;
	p->basic_caps = cpu_to_le16(vif->bss_conf.assoc_capability);
3055 3056 3057 3058
	p->ht_support = sta->ht_cap.ht_supported;
	p->ht_caps = sta->ht_cap.cap;
	p->extended_ht_caps = (sta->ht_cap.ampdu_factor & 3) |
		((sta->ht_cap.ampdu_density & 7) << 2);
3059 3060 3061 3062 3063
	if (hw->conf.channel->band == IEEE80211_BAND_2GHZ)
		rates = sta->supp_rates[IEEE80211_BAND_2GHZ];
	else
		rates = sta->supp_rates[IEEE80211_BAND_5GHZ] << 5;
	legacy_rate_mask_to_array(p->legacy_rates, rates);
3064
	memcpy(p->ht_rates, sta->ht_cap.mcs.rx_mask, 16);
3065 3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086
	p->interop = 1;
	p->amsdu_enabled = 0;

	rc = mwl8k_post_cmd(hw, &cmd->header);
	kfree(cmd);

	return rc ? rc : p->station_id;
}

static int mwl8k_cmd_update_stadb_del(struct ieee80211_hw *hw,
				      struct ieee80211_vif *vif, u8 *addr)
{
	struct mwl8k_cmd_update_stadb *cmd;
	int rc;

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (cmd == NULL)
		return -ENOMEM;

	cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_STADB);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->action = cpu_to_le32(MWL8K_STA_DB_DEL_ENTRY);
3087
	memcpy(cmd->peer_addr, addr, ETH_ALEN);
3088

3089
	rc = mwl8k_post_cmd(hw, &cmd->header);
3090 3091 3092 3093 3094
	kfree(cmd);

	return rc;
}

3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108

/*
 * Interrupt handling.
 */
static irqreturn_t mwl8k_interrupt(int irq, void *dev_id)
{
	struct ieee80211_hw *hw = dev_id;
	struct mwl8k_priv *priv = hw->priv;
	u32 status;

	status = ioread32(priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
	if (!status)
		return IRQ_NONE;

3109 3110 3111 3112 3113
	if (status & MWL8K_A2H_INT_TX_DONE) {
		status &= ~MWL8K_A2H_INT_TX_DONE;
		tasklet_schedule(&priv->poll_tx_task);
	}

3114
	if (status & MWL8K_A2H_INT_RX_READY) {
3115 3116
		status &= ~MWL8K_A2H_INT_RX_READY;
		tasklet_schedule(&priv->poll_rx_task);
3117 3118
	}

3119 3120 3121
	if (status)
		iowrite32(~status, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);

3122
	if (status & MWL8K_A2H_INT_OPC_DONE) {
3123
		if (priv->hostcmd_wait != NULL)
3124 3125 3126 3127
			complete(priv->hostcmd_wait);
	}

	if (status & MWL8K_A2H_INT_QUEUE_EMPTY) {
3128
		if (!mutex_is_locked(&priv->fw_mutex) &&
3129
		    priv->radio_on && priv->pending_tx_pkts)
3130
			mwl8k_tx_start(priv);
3131 3132 3133 3134 3135
	}

	return IRQ_HANDLED;
}

3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164
static void mwl8k_tx_poll(unsigned long data)
{
	struct ieee80211_hw *hw = (struct ieee80211_hw *)data;
	struct mwl8k_priv *priv = hw->priv;
	int limit;
	int i;

	limit = 32;

	spin_lock_bh(&priv->tx_lock);

	for (i = 0; i < MWL8K_TX_QUEUES; i++)
		limit -= mwl8k_txq_reclaim(hw, i, limit, 0);

	if (!priv->pending_tx_pkts && priv->tx_wait != NULL) {
		complete(priv->tx_wait);
		priv->tx_wait = NULL;
	}

	spin_unlock_bh(&priv->tx_lock);

	if (limit) {
		writel(~MWL8K_A2H_INT_TX_DONE,
		       priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
	} else {
		tasklet_schedule(&priv->poll_tx_task);
	}
}

3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182
static void mwl8k_rx_poll(unsigned long data)
{
	struct ieee80211_hw *hw = (struct ieee80211_hw *)data;
	struct mwl8k_priv *priv = hw->priv;
	int limit;

	limit = 32;
	limit -= rxq_process(hw, 0, limit);
	limit -= rxq_refill(hw, 0, limit);

	if (limit) {
		writel(~MWL8K_A2H_INT_RX_READY,
		       priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
	} else {
		tasklet_schedule(&priv->poll_rx_task);
	}
}

3183 3184 3185 3186 3187 3188 3189 3190 3191 3192

/*
 * Core driver operations.
 */
static int mwl8k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
{
	struct mwl8k_priv *priv = hw->priv;
	int index = skb_get_queue_mapping(skb);
	int rc;

3193
	if (!priv->radio_on) {
3194
		printk(KERN_DEBUG "%s: dropped TX frame since radio "
L
Lennert Buytenhek 已提交
3195
		       "disabled\n", wiphy_name(hw->wiphy));
3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207 3208 3209
		dev_kfree_skb(skb);
		return NETDEV_TX_OK;
	}

	rc = mwl8k_txq_xmit(hw, index, skb);

	return rc;
}

static int mwl8k_start(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;
	int rc;

3210
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
3211 3212 3213
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
		printk(KERN_ERR "%s: failed to register IRQ handler\n",
L
Lennert Buytenhek 已提交
3214
		       wiphy_name(hw->wiphy));
3215
		return -EIO;
3216 3217
	}

3218
	/* Enable TX reclaim and RX tasklets.  */
3219
	tasklet_enable(&priv->poll_tx_task);
3220
	tasklet_enable(&priv->poll_rx_task);
3221

3222
	/* Enable interrupts */
3223
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
3224

3225 3226
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
3227
		rc = mwl8k_cmd_radio_enable(hw);
3228

3229 3230
		if (!priv->ap_fw) {
			if (!rc)
3231
				rc = mwl8k_cmd_enable_sniffer(hw, 0);
3232

3233 3234 3235 3236 3237 3238 3239
			if (!rc)
				rc = mwl8k_cmd_set_pre_scan(hw);

			if (!rc)
				rc = mwl8k_cmd_set_post_scan(hw,
						"\x00\x00\x00\x00\x00\x00");
		}
3240 3241

		if (!rc)
3242
			rc = mwl8k_cmd_set_rateadapt_mode(hw, 0);
3243

3244
		if (!rc)
3245
			rc = mwl8k_cmd_set_wmm_mode(hw, 0);
3246

3247 3248 3249 3250 3251 3252
		mwl8k_fw_unlock(hw);
	}

	if (rc) {
		iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
		free_irq(priv->pdev->irq, hw);
3253
		tasklet_disable(&priv->poll_tx_task);
3254
		tasklet_disable(&priv->poll_rx_task);
3255
	}
3256 3257 3258 3259 3260 3261 3262 3263 3264

	return rc;
}

static void mwl8k_stop(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;
	int i;

3265
	mwl8k_cmd_radio_disable(hw);
3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277

	ieee80211_stop_queues(hw);

	/* Disable interrupts */
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
	free_irq(priv->pdev->irq, hw);

	/* Stop finalize join worker */
	cancel_work_sync(&priv->finalize_join_worker);
	if (priv->beacon_skb != NULL)
		dev_kfree_skb(priv->beacon_skb);

3278
	/* Stop TX reclaim and RX tasklets.  */
3279
	tasklet_disable(&priv->poll_tx_task);
3280
	tasklet_disable(&priv->poll_rx_task);
3281 3282 3283

	/* Return all skbs to mac80211 */
	for (i = 0; i < MWL8K_TX_QUEUES; i++)
3284
		mwl8k_txq_reclaim(hw, i, INT_MAX, 1);
3285 3286 3287
}

static int mwl8k_add_interface(struct ieee80211_hw *hw,
3288
			       struct ieee80211_vif *vif)
3289 3290 3291
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_vif *mwl8k_vif;
3292 3293
	u32 macids_supported;
	int macid;
3294

3295 3296 3297
	/*
	 * Reject interface creation if sniffer mode is active, as
	 * STA operation is mutually exclusive with hardware sniffer
3298
	 * mode.  (Sniffer mode is only used on STA firmware.)
3299 3300 3301 3302 3303 3304 3305 3306
	 */
	if (priv->sniffer_enabled) {
		printk(KERN_INFO "%s: unable to create STA "
		       "interface due to sniffer mode being enabled\n",
		       wiphy_name(hw->wiphy));
		return -EINVAL;
	}

3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322

	switch (vif->type) {
	case NL80211_IFTYPE_AP:
		macids_supported = priv->ap_macids_supported;
		break;
	case NL80211_IFTYPE_STATION:
		macids_supported = priv->sta_macids_supported;
		break;
	default:
		return -EINVAL;
	}

	macid = ffs(macids_supported & ~priv->macids_used);
	if (!macid--)
		return -EBUSY;

3323
	/* Setup driver private area. */
3324
	mwl8k_vif = MWL8K_VIF(vif);
3325
	memset(mwl8k_vif, 0, sizeof(*mwl8k_vif));
3326
	mwl8k_vif->vif = vif;
3327
	mwl8k_vif->macid = macid;
3328 3329
	mwl8k_vif->seqno = 0;

3330 3331 3332 3333 3334 3335
	/* Set the mac address.  */
	mwl8k_cmd_set_mac_addr(hw, vif, vif->addr);

	if (priv->ap_fw)
		mwl8k_cmd_set_new_stn_add_self(hw, vif);

3336
	priv->macids_used |= 1 << mwl8k_vif->macid;
3337
	list_add_tail(&mwl8k_vif->list, &priv->vif_list);
3338 3339 3340 3341 3342

	return 0;
}

static void mwl8k_remove_interface(struct ieee80211_hw *hw,
3343
				   struct ieee80211_vif *vif)
3344 3345
{
	struct mwl8k_priv *priv = hw->priv;
3346
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
3347

3348 3349 3350
	if (priv->ap_fw)
		mwl8k_cmd_set_new_stn_del(hw, vif, vif->addr);

3351
	mwl8k_cmd_set_mac_addr(hw, vif, "\x00\x00\x00\x00\x00\x00");
3352

3353
	priv->macids_used &= ~(1 << mwl8k_vif->macid);
3354
	list_del(&mwl8k_vif->list);
3355 3356
}

3357
static int mwl8k_config(struct ieee80211_hw *hw, u32 changed)
3358 3359 3360
{
	struct ieee80211_conf *conf = &hw->conf;
	struct mwl8k_priv *priv = hw->priv;
3361
	int rc;
3362

L
Lennert Buytenhek 已提交
3363
	if (conf->flags & IEEE80211_CONF_IDLE) {
3364
		mwl8k_cmd_radio_disable(hw);
3365
		return 0;
L
Lennert Buytenhek 已提交
3366 3367
	}

3368 3369 3370
	rc = mwl8k_fw_lock(hw);
	if (rc)
		return rc;
3371

3372
	rc = mwl8k_cmd_radio_enable(hw);
3373 3374
	if (rc)
		goto out;
3375

3376
	rc = mwl8k_cmd_set_rf_channel(hw, conf);
3377 3378 3379
	if (rc)
		goto out;

3380 3381
	if (conf->power_level > 18)
		conf->power_level = 18;
3382
	rc = mwl8k_cmd_rf_tx_power(hw, conf->power_level);
3383 3384
	if (rc)
		goto out;
3385

3386 3387 3388 3389 3390 3391 3392
	if (priv->ap_fw) {
		rc = mwl8k_cmd_rf_antenna(hw, MWL8K_RF_ANTENNA_RX, 0x7);
		if (!rc)
			rc = mwl8k_cmd_rf_antenna(hw, MWL8K_RF_ANTENNA_TX, 0x7);
	} else {
		rc = mwl8k_cmd_mimo_config(hw, 0x7, 0x7);
	}
3393

3394 3395
out:
	mwl8k_fw_unlock(hw);
3396

3397
	return rc;
3398 3399
}

3400 3401 3402
static void
mwl8k_bss_info_changed_sta(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			   struct ieee80211_bss_conf *info, u32 changed)
3403 3404
{
	struct mwl8k_priv *priv = hw->priv;
3405
	u32 ap_legacy_rates;
3406
	u8 ap_mcs_rates[16];
3407 3408
	int rc;

3409
	if (mwl8k_fw_lock(hw))
3410
		return;
3411

3412 3413 3414 3415 3416
	/*
	 * No need to capture a beacon if we're no longer associated.
	 */
	if ((changed & BSS_CHANGED_ASSOC) && !vif->bss_conf.assoc)
		priv->capture_beacon = false;
3417

3418
	/*
3419
	 * Get the AP's legacy and MCS rates.
3420
	 */
3421
	if (vif->bss_conf.assoc) {
L
Lennert Buytenhek 已提交
3422
		struct ieee80211_sta *ap;
3423

L
Lennert Buytenhek 已提交
3424 3425
		rcu_read_lock();

3426 3427 3428
		ap = ieee80211_find_sta(vif, vif->bss_conf.bssid);
		if (ap == NULL) {
			rcu_read_unlock();
L
Lennert Buytenhek 已提交
3429
			goto out;
3430 3431
		}

3432 3433 3434 3435 3436 3437
		if (hw->conf.channel->band == IEEE80211_BAND_2GHZ) {
			ap_legacy_rates = ap->supp_rates[IEEE80211_BAND_2GHZ];
		} else {
			ap_legacy_rates =
				ap->supp_rates[IEEE80211_BAND_5GHZ] << 5;
		}
3438
		memcpy(ap_mcs_rates, ap->ht_cap.mcs.rx_mask, 16);
3439 3440 3441

		rcu_read_unlock();
	}
L
Lennert Buytenhek 已提交
3442

3443
	if ((changed & BSS_CHANGED_ASSOC) && vif->bss_conf.assoc) {
3444
		rc = mwl8k_cmd_set_rate(hw, vif, ap_legacy_rates, ap_mcs_rates);
3445 3446
		if (rc)
			goto out;
3447

3448
		rc = mwl8k_cmd_use_fixed_rate_sta(hw);
3449 3450
		if (rc)
			goto out;
3451
	}
3452

3453
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3454 3455
		rc = mwl8k_set_radio_preamble(hw,
				vif->bss_conf.use_short_preamble);
3456 3457
		if (rc)
			goto out;
3458
	}
3459

3460
	if (changed & BSS_CHANGED_ERP_SLOT) {
3461
		rc = mwl8k_cmd_set_slot(hw, vif->bss_conf.use_short_slot);
3462 3463
		if (rc)
			goto out;
3464
	}
3465

3466 3467 3468
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_ERP_CTS_PROT |
			BSS_CHANGED_HT))) {
3469
		rc = mwl8k_cmd_set_aid(hw, vif, ap_legacy_rates);
3470 3471
		if (rc)
			goto out;
3472
	}
3473

3474 3475
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_BEACON_INT))) {
3476 3477 3478 3479
		/*
		 * Finalize the join.  Tell rx handler to process
		 * next beacon from our BSSID.
		 */
3480
		memcpy(priv->capture_bssid, vif->bss_conf.bssid, ETH_ALEN);
3481 3482 3483
		priv->capture_beacon = true;
	}

3484 3485
out:
	mwl8k_fw_unlock(hw);
3486 3487
}

3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513
static void
mwl8k_bss_info_changed_ap(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			  struct ieee80211_bss_conf *info, u32 changed)
{
	int rc;

	if (mwl8k_fw_lock(hw))
		return;

	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
		rc = mwl8k_set_radio_preamble(hw,
				vif->bss_conf.use_short_preamble);
		if (rc)
			goto out;
	}

	if (changed & BSS_CHANGED_BASIC_RATES) {
		int idx;
		int rate;

		/*
		 * Use lowest supported basic rate for multicasts
		 * and management frames (such as probe responses --
		 * beacons will always go out at 1 Mb/s).
		 */
		idx = ffs(vif->bss_conf.basic_rates);
3514 3515 3516 3517 3518 3519 3520
		if (idx)
			idx--;

		if (hw->conf.channel->band == IEEE80211_BAND_2GHZ)
			rate = mwl8k_rates_24[idx].hw_value;
		else
			rate = mwl8k_rates_50[idx].hw_value;
3521 3522 3523 3524 3525 3526 3527 3528 3529

		mwl8k_cmd_use_fixed_rate_ap(hw, rate, rate);
	}

	if (changed & (BSS_CHANGED_BEACON_INT | BSS_CHANGED_BEACON)) {
		struct sk_buff *skb;

		skb = ieee80211_beacon_get(hw, vif);
		if (skb != NULL) {
3530
			mwl8k_cmd_set_beacon(hw, vif, skb->data, skb->len);
3531 3532 3533 3534 3535
			kfree_skb(skb);
		}
	}

	if (changed & BSS_CHANGED_BEACON_ENABLED)
3536
		mwl8k_cmd_bss_start(hw, vif, info->enable_beacon);
3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553

out:
	mwl8k_fw_unlock(hw);
}

static void
mwl8k_bss_info_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		       struct ieee80211_bss_conf *info, u32 changed)
{
	struct mwl8k_priv *priv = hw->priv;

	if (!priv->ap_fw)
		mwl8k_bss_info_changed_sta(hw, vif, info, changed);
	else
		mwl8k_bss_info_changed_ap(hw, vif, info, changed);
}

3554 3555 3556 3557 3558
static u64 mwl8k_prepare_multicast(struct ieee80211_hw *hw,
				   int mc_count, struct dev_addr_list *mclist)
{
	struct mwl8k_cmd_pkt *cmd;

L
Lennert Buytenhek 已提交
3559 3560 3561 3562 3563 3564 3565 3566
	/*
	 * Synthesize and return a command packet that programs the
	 * hardware multicast address filter.  At this point we don't
	 * know whether FIF_ALLMULTI is being requested, but if it is,
	 * we'll end up throwing this packet away and creating a new
	 * one in mwl8k_configure_filter().
	 */
	cmd = __mwl8k_cmd_mac_multicast_adr(hw, 0, mc_count, mclist);
3567 3568 3569 3570

	return (unsigned long)cmd;
}

3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582
static int
mwl8k_configure_filter_sniffer(struct ieee80211_hw *hw,
			       unsigned int changed_flags,
			       unsigned int *total_flags)
{
	struct mwl8k_priv *priv = hw->priv;

	/*
	 * Hardware sniffer mode is mutually exclusive with STA
	 * operation, so refuse to enable sniffer mode if a STA
	 * interface is active.
	 */
3583
	if (!list_empty(&priv->vif_list)) {
3584 3585 3586 3587 3588 3589 3590 3591
		if (net_ratelimit())
			printk(KERN_INFO "%s: not enabling sniffer "
			       "mode because STA interface is active\n",
			       wiphy_name(hw->wiphy));
		return 0;
	}

	if (!priv->sniffer_enabled) {
3592
		if (mwl8k_cmd_enable_sniffer(hw, 1))
3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603
			return 0;
		priv->sniffer_enabled = true;
	}

	*total_flags &=	FIF_PROMISC_IN_BSS | FIF_ALLMULTI |
			FIF_BCN_PRBRESP_PROMISC | FIF_CONTROL |
			FIF_OTHER_BSS;

	return 1;
}

3604 3605 3606 3607 3608 3609 3610 3611
static struct mwl8k_vif *mwl8k_first_vif(struct mwl8k_priv *priv)
{
	if (!list_empty(&priv->vif_list))
		return list_entry(priv->vif_list.next, struct mwl8k_vif, list);

	return NULL;
}

3612 3613 3614 3615 3616 3617
static void mwl8k_configure_filter(struct ieee80211_hw *hw,
				   unsigned int changed_flags,
				   unsigned int *total_flags,
				   u64 multicast)
{
	struct mwl8k_priv *priv = hw->priv;
3618 3619
	struct mwl8k_cmd_pkt *cmd = (void *)(unsigned long)multicast;

3620 3621 3622 3623 3624 3625 3626 3627 3628 3629
	/*
	 * AP firmware doesn't allow fine-grained control over
	 * the receive filter.
	 */
	if (priv->ap_fw) {
		*total_flags &= FIF_ALLMULTI | FIF_BCN_PRBRESP_PROMISC;
		kfree(cmd);
		return;
	}

3630 3631 3632 3633 3634 3635 3636 3637 3638
	/*
	 * Enable hardware sniffer mode if FIF_CONTROL or
	 * FIF_OTHER_BSS is requested.
	 */
	if (*total_flags & (FIF_CONTROL | FIF_OTHER_BSS) &&
	    mwl8k_configure_filter_sniffer(hw, changed_flags, total_flags)) {
		kfree(cmd);
		return;
	}
3639

3640
	/* Clear unsupported feature flags */
L
Lennert Buytenhek 已提交
3641
	*total_flags &= FIF_ALLMULTI | FIF_BCN_PRBRESP_PROMISC;
3642

3643 3644
	if (mwl8k_fw_lock(hw)) {
		kfree(cmd);
3645
		return;
3646
	}
3647

3648
	if (priv->sniffer_enabled) {
3649
		mwl8k_cmd_enable_sniffer(hw, 0);
3650 3651 3652
		priv->sniffer_enabled = false;
	}

3653
	if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
3654 3655 3656 3657
		if (*total_flags & FIF_BCN_PRBRESP_PROMISC) {
			/*
			 * Disable the BSS filter.
			 */
3658
			mwl8k_cmd_set_pre_scan(hw);
3659
		} else {
3660
			struct mwl8k_vif *mwl8k_vif;
3661
			const u8 *bssid;
3662

3663 3664 3665 3666 3667 3668 3669 3670
			/*
			 * Enable the BSS filter.
			 *
			 * If there is an active STA interface, use that
			 * interface's BSSID, otherwise use a dummy one
			 * (where the OUI part needs to be nonzero for
			 * the BSSID to be accepted by POST_SCAN).
			 */
3671 3672 3673 3674 3675
			mwl8k_vif = mwl8k_first_vif(priv);
			if (mwl8k_vif != NULL)
				bssid = mwl8k_vif->vif->bss_conf.bssid;
			else
				bssid = "\x01\x00\x00\x00\x00\x00";
3676

3677
			mwl8k_cmd_set_post_scan(hw, bssid);
3678 3679 3680
		}
	}

L
Lennert Buytenhek 已提交
3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694
	/*
	 * If FIF_ALLMULTI is being requested, throw away the command
	 * packet that ->prepare_multicast() built and replace it with
	 * a command packet that enables reception of all multicast
	 * packets.
	 */
	if (*total_flags & FIF_ALLMULTI) {
		kfree(cmd);
		cmd = __mwl8k_cmd_mac_multicast_adr(hw, 1, 0, NULL);
	}

	if (cmd != NULL) {
		mwl8k_post_cmd(hw, cmd);
		kfree(cmd);
3695
	}
3696

3697
	mwl8k_fw_unlock(hw);
3698 3699 3700 3701
}

static int mwl8k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
{
L
Lennert Buytenhek 已提交
3702
	return mwl8k_cmd_set_rts_threshold(hw, value);
3703 3704
}

3705 3706 3707
static int mwl8k_sta_remove(struct ieee80211_hw *hw,
			    struct ieee80211_vif *vif,
			    struct ieee80211_sta *sta)
3708 3709 3710
{
	struct mwl8k_priv *priv = hw->priv;

3711 3712 3713 3714
	if (priv->ap_fw)
		return mwl8k_cmd_set_new_stn_del(hw, vif, sta->addr);
	else
		return mwl8k_cmd_update_stadb_del(hw, vif, sta->addr);
3715 3716
}

3717 3718 3719
static int mwl8k_sta_add(struct ieee80211_hw *hw,
			 struct ieee80211_vif *vif,
			 struct ieee80211_sta *sta)
3720 3721
{
	struct mwl8k_priv *priv = hw->priv;
3722
	int ret;
3723

3724 3725 3726 3727 3728 3729
	if (!priv->ap_fw) {
		ret = mwl8k_cmd_update_stadb_add(hw, vif, sta);
		if (ret >= 0) {
			MWL8K_STA(sta)->peer_id = ret;
			return 0;
		}
3730

3731
		return ret;
3732
	}
3733 3734

	return mwl8k_cmd_set_new_stn_add(hw, vif, sta);
3735 3736
}

3737 3738 3739
static int mwl8k_conf_tx(struct ieee80211_hw *hw, u16 queue,
			 const struct ieee80211_tx_queue_params *params)
{
3740
	struct mwl8k_priv *priv = hw->priv;
3741 3742
	int rc;

3743 3744 3745
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
		if (!priv->wmm_enabled)
3746
			rc = mwl8k_cmd_set_wmm_mode(hw, 1);
3747

3748
		if (!rc)
3749 3750 3751 3752 3753
			rc = mwl8k_cmd_set_edca_params(hw, queue,
						       params->cw_min,
						       params->cw_max,
						       params->aifs,
						       params->txop);
3754 3755

		mwl8k_fw_unlock(hw);
3756
	}
3757

3758 3759 3760 3761 3762 3763
	return rc;
}

static int mwl8k_get_stats(struct ieee80211_hw *hw,
			   struct ieee80211_low_level_stats *stats)
{
3764
	return mwl8k_cmd_get_stat(hw, stats);
3765 3766
}

3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782
static int
mwl8k_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		   enum ieee80211_ampdu_mlme_action action,
		   struct ieee80211_sta *sta, u16 tid, u16 *ssn)
{
	switch (action) {
	case IEEE80211_AMPDU_RX_START:
	case IEEE80211_AMPDU_RX_STOP:
		if (!(hw->flags & IEEE80211_HW_AMPDU_AGGREGATION))
			return -ENOTSUPP;
		return 0;
	default:
		return -ENOTSUPP;
	}
}

3783 3784 3785 3786 3787 3788 3789 3790
static const struct ieee80211_ops mwl8k_ops = {
	.tx			= mwl8k_tx,
	.start			= mwl8k_start,
	.stop			= mwl8k_stop,
	.add_interface		= mwl8k_add_interface,
	.remove_interface	= mwl8k_remove_interface,
	.config			= mwl8k_config,
	.bss_info_changed	= mwl8k_bss_info_changed,
3791
	.prepare_multicast	= mwl8k_prepare_multicast,
3792 3793
	.configure_filter	= mwl8k_configure_filter,
	.set_rts_threshold	= mwl8k_set_rts_threshold,
3794 3795
	.sta_add		= mwl8k_sta_add,
	.sta_remove		= mwl8k_sta_remove,
3796 3797
	.conf_tx		= mwl8k_conf_tx,
	.get_stats		= mwl8k_get_stats,
3798
	.ampdu_action		= mwl8k_ampdu_action,
3799 3800 3801 3802 3803 3804 3805
};

static void mwl8k_finalize_join_worker(struct work_struct *work)
{
	struct mwl8k_priv *priv =
		container_of(work, struct mwl8k_priv, finalize_join_worker);
	struct sk_buff *skb = priv->beacon_skb;
3806 3807 3808 3809 3810 3811 3812 3813
	struct ieee80211_mgmt *mgmt = (void *)skb->data;
	int len = skb->len - offsetof(struct ieee80211_mgmt, u.beacon.variable);
	const u8 *tim = cfg80211_find_ie(WLAN_EID_TIM,
					 mgmt->u.beacon.variable, len);
	int dtim_period = 1;

	if (tim && tim[1] >= 2)
		dtim_period = tim[3];
3814

3815
	mwl8k_cmd_finalize_join(priv->hw, skb->data, skb->len, dtim_period);
3816

3817
	dev_kfree_skb(skb);
3818 3819 3820
	priv->beacon_skb = NULL;
}

3821
enum {
3822 3823
	MWL8363 = 0,
	MWL8687,
3824
	MWL8366,
3825 3826
};

3827
static struct mwl8k_device_info mwl8k_info_tbl[] __devinitdata = {
3828 3829 3830 3831 3832
	[MWL8363] = {
		.part_name	= "88w8363",
		.helper_image	= "mwl8k/helper_8363.fw",
		.fw_image	= "mwl8k/fmimage_8363.fw",
	},
3833
	[MWL8687] = {
3834 3835 3836 3837
		.part_name	= "88w8687",
		.helper_image	= "mwl8k/helper_8687.fw",
		.fw_image	= "mwl8k/fmimage_8687.fw",
	},
3838
	[MWL8366] = {
3839 3840 3841
		.part_name	= "88w8366",
		.helper_image	= "mwl8k/helper_8366.fw",
		.fw_image	= "mwl8k/fmimage_8366.fw",
3842
		.ap_rxd_ops	= &rxd_8366_ap_ops,
3843
	},
3844 3845
};

3846 3847 3848 3849 3850 3851 3852
MODULE_FIRMWARE("mwl8k/helper_8363.fw");
MODULE_FIRMWARE("mwl8k/fmimage_8363.fw");
MODULE_FIRMWARE("mwl8k/helper_8687.fw");
MODULE_FIRMWARE("mwl8k/fmimage_8687.fw");
MODULE_FIRMWARE("mwl8k/helper_8366.fw");
MODULE_FIRMWARE("mwl8k/fmimage_8366.fw");

3853
static DEFINE_PCI_DEVICE_TABLE(mwl8k_pci_id_table) = {
3854 3855
	{ PCI_VDEVICE(MARVELL, 0x2a0c), .driver_data = MWL8363, },
	{ PCI_VDEVICE(MARVELL, 0x2a24), .driver_data = MWL8363, },
3856 3857 3858
	{ PCI_VDEVICE(MARVELL, 0x2a2b), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a30), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a40), .driver_data = MWL8366, },
3859
	{ PCI_VDEVICE(MARVELL, 0x2a43), .driver_data = MWL8366, },
3860
	{ },
3861 3862 3863
};
MODULE_DEVICE_TABLE(pci, mwl8k_pci_id_table);

3864 3865 3866
static int __devinit mwl8k_probe(struct pci_dev *pdev,
				 const struct pci_device_id *id)
{
3867
	static int printed_version = 0;
3868 3869 3870 3871
	struct ieee80211_hw *hw;
	struct mwl8k_priv *priv;
	int rc;
	int i;
3872 3873 3874 3875 3876

	if (!printed_version) {
		printk(KERN_INFO "%s version %s\n", MWL8K_DESC, MWL8K_VERSION);
		printed_version = 1;
	}
3877

3878

3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889
	rc = pci_enable_device(pdev);
	if (rc) {
		printk(KERN_ERR "%s: Cannot enable new PCI device\n",
		       MWL8K_NAME);
		return rc;
	}

	rc = pci_request_regions(pdev, MWL8K_NAME);
	if (rc) {
		printk(KERN_ERR "%s: Cannot obtain PCI resources\n",
		       MWL8K_NAME);
3890
		goto err_disable_device;
3891 3892 3893 3894
	}

	pci_set_master(pdev);

3895

3896 3897 3898 3899 3900 3901 3902
	hw = ieee80211_alloc_hw(sizeof(*priv), &mwl8k_ops);
	if (hw == NULL) {
		printk(KERN_ERR "%s: ieee80211 alloc failed\n", MWL8K_NAME);
		rc = -ENOMEM;
		goto err_free_reg;
	}

3903 3904 3905
	SET_IEEE80211_DEV(hw, &pdev->dev);
	pci_set_drvdata(pdev, hw);

3906 3907 3908
	priv = hw->priv;
	priv->hw = hw;
	priv->pdev = pdev;
3909
	priv->device_info = &mwl8k_info_tbl[id->driver_data];
3910 3911


L
Lennert Buytenhek 已提交
3912 3913 3914
	priv->sram = pci_iomap(pdev, 0, 0x10000);
	if (priv->sram == NULL) {
		printk(KERN_ERR "%s: Cannot map device SRAM\n",
L
Lennert Buytenhek 已提交
3915
		       wiphy_name(hw->wiphy));
3916 3917 3918
		goto err_iounmap;
	}

L
Lennert Buytenhek 已提交
3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932
	/*
	 * If BAR0 is a 32 bit BAR, the register BAR will be BAR1.
	 * If BAR0 is a 64 bit BAR, the register BAR will be BAR2.
	 */
	priv->regs = pci_iomap(pdev, 1, 0x10000);
	if (priv->regs == NULL) {
		priv->regs = pci_iomap(pdev, 2, 0x10000);
		if (priv->regs == NULL) {
			printk(KERN_ERR "%s: Cannot map device registers\n",
			       wiphy_name(hw->wiphy));
			goto err_iounmap;
		}
	}

3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956

	/* Reset firmware and hardware */
	mwl8k_hw_reset(priv);

	/* Ask userland hotplug daemon for the device firmware */
	rc = mwl8k_request_firmware(priv);
	if (rc) {
		printk(KERN_ERR "%s: Firmware files not found\n",
		       wiphy_name(hw->wiphy));
		goto err_stop_firmware;
	}

	/* Load firmware into hardware */
	rc = mwl8k_load_firmware(hw);
	if (rc) {
		printk(KERN_ERR "%s: Cannot start firmware\n",
		       wiphy_name(hw->wiphy));
		goto err_stop_firmware;
	}

	/* Reclaim memory once firmware is successfully loaded */
	mwl8k_release_firmware(priv);


3957
	if (priv->ap_fw) {
3958
		priv->rxd_ops = priv->device_info->ap_rxd_ops;
3959 3960 3961 3962 3963 3964 3965
		if (priv->rxd_ops == NULL) {
			printk(KERN_ERR "%s: Driver does not have AP "
			       "firmware image support for this hardware\n",
			       wiphy_name(hw->wiphy));
			goto err_stop_firmware;
		}
	} else {
3966
		priv->rxd_ops = &rxd_sta_ops;
3967
	}
3968 3969 3970 3971 3972 3973

	priv->sniffer_enabled = false;
	priv->wmm_enabled = false;
	priv->pending_tx_pkts = 0;


3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985
	/*
	 * Extra headroom is the size of the required DMA header
	 * minus the size of the smallest 802.11 frame (CTS frame).
	 */
	hw->extra_tx_headroom =
		sizeof(struct mwl8k_dma_data) - sizeof(struct ieee80211_cts);

	hw->channel_change_time = 10;

	hw->queues = MWL8K_TX_QUEUES;

	/* Set rssi and noise values to dBm */
3986
	hw->flags |= IEEE80211_HW_SIGNAL_DBM | IEEE80211_HW_NOISE_DBM;
3987
	hw->vif_data_size = sizeof(struct mwl8k_vif);
3988
	hw->sta_data_size = sizeof(struct mwl8k_sta);
3989

3990
	priv->macids_used = 0;
3991
	INIT_LIST_HEAD(&priv->vif_list);
3992 3993

	/* Set default radio state and preamble */
3994
	priv->radio_on = 0;
3995
	priv->radio_short_preamble = 0;
3996 3997 3998 3999

	/* Finalize join worker */
	INIT_WORK(&priv->finalize_join_worker, mwl8k_finalize_join_worker);

4000
	/* TX reclaim and RX tasklets.  */
4001 4002
	tasklet_init(&priv->poll_tx_task, mwl8k_tx_poll, (unsigned long)hw);
	tasklet_disable(&priv->poll_tx_task);
4003 4004
	tasklet_init(&priv->poll_rx_task, mwl8k_rx_poll, (unsigned long)hw);
	tasklet_disable(&priv->poll_rx_task);
4005 4006 4007 4008

	/* Power management cookie */
	priv->cookie = pci_alloc_consistent(priv->pdev, 4, &priv->cookie_dma);
	if (priv->cookie == NULL)
4009
		goto err_stop_firmware;
4010 4011 4012

	rc = mwl8k_rxq_init(hw, 0);
	if (rc)
4013
		goto err_free_cookie;
4014 4015
	rxq_refill(hw, 0, INT_MAX);

4016 4017 4018 4019 4020
	mutex_init(&priv->fw_mutex);
	priv->fw_mutex_owner = NULL;
	priv->fw_mutex_depth = 0;
	priv->hostcmd_wait = NULL;

4021 4022
	spin_lock_init(&priv->tx_lock);

4023 4024
	priv->tx_wait = NULL;

4025 4026 4027 4028 4029 4030 4031
	for (i = 0; i < MWL8K_TX_QUEUES; i++) {
		rc = mwl8k_txq_init(hw, i);
		if (rc)
			goto err_free_queues;
	}

	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
4032
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4033
	iowrite32(MWL8K_A2H_INT_TX_DONE | MWL8K_A2H_INT_RX_READY,
4034
		  priv->regs + MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL);
4035 4036
	iowrite32(0xffffffff, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);

4037
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
4038 4039 4040
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
		printk(KERN_ERR "%s: failed to register IRQ handler\n",
L
Lennert Buytenhek 已提交
4041
		       wiphy_name(hw->wiphy));
4042 4043 4044 4045 4046
		goto err_free_queues;
	}

	/*
	 * Temporarily enable interrupts.  Initial firmware host
L
Lennert Buytenhek 已提交
4047
	 * commands use interrupts and avoid polling.  Disable
4048 4049
	 * interrupts when done.
	 */
4050
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4051 4052

	/* Get config data, mac addrs etc */
4053 4054 4055 4056 4057 4058 4059
	if (priv->ap_fw) {
		rc = mwl8k_cmd_get_hw_spec_ap(hw);
		if (!rc)
			rc = mwl8k_cmd_set_hw_spec(hw);
	} else {
		rc = mwl8k_cmd_get_hw_spec_sta(hw);
	}
4060
	if (rc) {
L
Lennert Buytenhek 已提交
4061 4062
		printk(KERN_ERR "%s: Cannot initialise firmware\n",
		       wiphy_name(hw->wiphy));
4063
		goto err_free_irq;
4064 4065
	}

4066 4067 4068 4069 4070 4071 4072
	hw->wiphy->interface_modes = 0;
	if (priv->ap_macids_supported)
		hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP);
	if (priv->sta_macids_supported)
		hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_STATION);


4073
	/* Turn radio off */
4074
	rc = mwl8k_cmd_radio_disable(hw);
4075
	if (rc) {
L
Lennert Buytenhek 已提交
4076
		printk(KERN_ERR "%s: Cannot disable\n", wiphy_name(hw->wiphy));
4077
		goto err_free_irq;
4078 4079
	}

4080
	/* Clear MAC address */
4081
	rc = mwl8k_cmd_set_mac_addr(hw, NULL, "\x00\x00\x00\x00\x00\x00");
4082 4083 4084
	if (rc) {
		printk(KERN_ERR "%s: Cannot clear MAC address\n",
		       wiphy_name(hw->wiphy));
4085
		goto err_free_irq;
4086 4087
	}

4088 4089 4090 4091 4092 4093
	/* Disable interrupts */
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
	free_irq(priv->pdev->irq, hw);

	rc = ieee80211_register_hw(hw);
	if (rc) {
L
Lennert Buytenhek 已提交
4094 4095
		printk(KERN_ERR "%s: Cannot register device\n",
		       wiphy_name(hw->wiphy));
4096
		goto err_free_queues;
4097 4098
	}

4099
	printk(KERN_INFO "%s: %s v%d, %pM, %s firmware %u.%u.%u.%u\n",
4100
	       wiphy_name(hw->wiphy), priv->device_info->part_name,
4101
	       priv->hw_rev, hw->wiphy->perm_addr,
4102
	       priv->ap_fw ? "AP" : "STA",
4103 4104
	       (priv->fw_rev >> 24) & 0xff, (priv->fw_rev >> 16) & 0xff,
	       (priv->fw_rev >> 8) & 0xff, priv->fw_rev & 0xff);
4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116

	return 0;

err_free_irq:
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
	free_irq(priv->pdev->irq, hw);

err_free_queues:
	for (i = 0; i < MWL8K_TX_QUEUES; i++)
		mwl8k_txq_deinit(hw, i);
	mwl8k_rxq_deinit(hw, 0);

4117
err_free_cookie:
4118 4119 4120 4121
	if (priv->cookie != NULL)
		pci_free_consistent(priv->pdev, 4,
				priv->cookie, priv->cookie_dma);

4122 4123 4124 4125 4126
err_stop_firmware:
	mwl8k_hw_reset(priv);
	mwl8k_release_firmware(priv);

err_iounmap:
4127 4128 4129
	if (priv->regs != NULL)
		pci_iounmap(pdev, priv->regs);

L
Lennert Buytenhek 已提交
4130 4131 4132
	if (priv->sram != NULL)
		pci_iounmap(pdev, priv->sram);

4133 4134 4135 4136 4137
	pci_set_drvdata(pdev, NULL);
	ieee80211_free_hw(hw);

err_free_reg:
	pci_release_regions(pdev);
4138 4139

err_disable_device:
4140 4141 4142 4143 4144
	pci_disable_device(pdev);

	return rc;
}

4145
static void __devexit mwl8k_shutdown(struct pci_dev *pdev)
4146 4147 4148 4149
{
	printk(KERN_ERR "===>%s(%u)\n", __func__, __LINE__);
}

4150
static void __devexit mwl8k_remove(struct pci_dev *pdev)
4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161
{
	struct ieee80211_hw *hw = pci_get_drvdata(pdev);
	struct mwl8k_priv *priv;
	int i;

	if (hw == NULL)
		return;
	priv = hw->priv;

	ieee80211_stop_queues(hw);

4162 4163
	ieee80211_unregister_hw(hw);

4164
	/* Remove TX reclaim and RX tasklets.  */
4165
	tasklet_kill(&priv->poll_tx_task);
4166
	tasklet_kill(&priv->poll_rx_task);
4167 4168 4169 4170 4171 4172

	/* Stop hardware */
	mwl8k_hw_reset(priv);

	/* Return all skbs to mac80211 */
	for (i = 0; i < MWL8K_TX_QUEUES; i++)
4173
		mwl8k_txq_reclaim(hw, i, INT_MAX, 1);
4174 4175 4176 4177 4178 4179

	for (i = 0; i < MWL8K_TX_QUEUES; i++)
		mwl8k_txq_deinit(hw, i);

	mwl8k_rxq_deinit(hw, 0);

L
Lennert Buytenhek 已提交
4180
	pci_free_consistent(priv->pdev, 4, priv->cookie, priv->cookie_dma);
4181 4182

	pci_iounmap(pdev, priv->regs);
L
Lennert Buytenhek 已提交
4183
	pci_iounmap(pdev, priv->sram);
4184 4185 4186 4187 4188 4189 4190 4191
	pci_set_drvdata(pdev, NULL);
	ieee80211_free_hw(hw);
	pci_release_regions(pdev);
	pci_disable_device(pdev);
}

static struct pci_driver mwl8k_driver = {
	.name		= MWL8K_NAME,
4192
	.id_table	= mwl8k_pci_id_table,
4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209
	.probe		= mwl8k_probe,
	.remove		= __devexit_p(mwl8k_remove),
	.shutdown	= __devexit_p(mwl8k_shutdown),
};

static int __init mwl8k_init(void)
{
	return pci_register_driver(&mwl8k_driver);
}

static void __exit mwl8k_exit(void)
{
	pci_unregister_driver(&mwl8k_driver);
}

module_init(mwl8k_init);
module_exit(mwl8k_exit);
L
Lennert Buytenhek 已提交
4210 4211 4212 4213 4214

MODULE_DESCRIPTION(MWL8K_DESC);
MODULE_VERSION(MWL8K_VERSION);
MODULE_AUTHOR("Lennert Buytenhek <buytenh@marvell.com>");
MODULE_LICENSE("GPL");