mwl8k.c 95.4 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 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.11"
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 123 124 125
	struct ieee80211_tx_queue_stats stats;
	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 144
	/* hardware/firmware parameters */
	bool ap_fw;
	struct rxd_ops *rxd_ops;

145 146 147 148 149 150
	/* firmware access */
	struct mutex fw_mutex;
	struct task_struct *fw_mutex_owner;
	int fw_mutex_depth;
	struct completion *hostcmd_wait;

151 152 153
	/* lock held over TX and TX reap */
	spinlock_t tx_lock;

154 155 156
	/* TX quiesce completion, protected by fw_mutex and tx_lock */
	struct completion *tx_wait;

157 158 159 160 161 162 163 164 165 166
	struct ieee80211_vif *vif;

	struct ieee80211_channel *current_channel;

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

	u16 num_mcaddrs;
	u8 hw_rev;
167
	u32 fw_rev;
168 169 170 171 172 173 174 175 176 177 178 179 180

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

	/* PHY parameters */
	struct ieee80211_supported_band band;
	struct ieee80211_channel channels[14];
181
	struct ieee80211_rate rates[14];
182

183
	bool radio_on;
184
	bool radio_short_preamble;
185
	bool sniffer_enabled;
186
	bool wmm_enabled;
187

188 189 190 191
	struct work_struct sta_notify_worker;
	spinlock_t sta_notify_list_lock;
	struct list_head sta_notify_list;

192 193
	/* XXX need to convert this to handle multiple interfaces */
	bool capture_beacon;
194
	u8 capture_bssid[ETH_ALEN];
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
	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;

	/* Tasklet to reclaim TX descriptors and buffers after tx */
	struct tasklet_struct tx_reclaim_task;
};

/* Per interface specific private data */
struct mwl8k_vif {
L
Lennert Buytenhek 已提交
211
	/* Non AMPDU sequence number assigned by driver.  */
212
	u16 seqno;
213
};
214
#define MWL8K_VIF(_vif) ((struct mwl8k_vif *)&((_vif)->drv_priv))
215

216 217 218 219 220 221
struct mwl8k_sta {
	/* Index into station database. Returned by UPDATE_STADB.  */
	u8 peer_id;
};
#define MWL8K_STA(_sta) ((struct mwl8k_sta *)&((_sta)->drv_priv))

222 223 224 225 226 227 228 229 230 231 232 233
static const struct ieee80211_channel mwl8k_channels[] = {
	{ .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, },
234 235 236
	{ .center_freq = 2467, .hw_value = 12, },
	{ .center_freq = 2472, .hw_value = 13, },
	{ .center_freq = 2484, .hw_value = 14, },
237 238 239 240 241 242
};

static const struct ieee80211_rate mwl8k_rates[] = {
	{ .bitrate = 10, .hw_value = 2, },
	{ .bitrate = 20, .hw_value = 4, },
	{ .bitrate = 55, .hw_value = 11, },
243 244
	{ .bitrate = 110, .hw_value = 22, },
	{ .bitrate = 220, .hw_value = 44, },
245 246 247 248 249 250 251 252
	{ .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, },
253 254 255
	{ .bitrate = 720, .hw_value = 144, },
};

256 257 258 259 260 261 262
/* 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
263
#define MWL8K_CMD_SET_HW_SPEC		0x0004
264 265
#define MWL8K_CMD_MAC_MULTICAST_ADR	0x0010
#define MWL8K_CMD_GET_STAT		0x0014
266 267
#define MWL8K_CMD_RADIO_CONTROL		0x001c
#define MWL8K_CMD_RF_TX_POWER		0x001e
268
#define MWL8K_CMD_RF_ANTENNA		0x0020
269
#define MWL8K_CMD_SET_BEACON		0x0100
270 271
#define MWL8K_CMD_SET_PRE_SCAN		0x0107
#define MWL8K_CMD_SET_POST_SCAN		0x0108
272 273 274 275 276
#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
277
#define MWL8K_CMD_SET_SLOT		0x0114
278 279
#define MWL8K_CMD_SET_EDCA_PARAMS	0x0115
#define MWL8K_CMD_SET_WMM_MODE		0x0123
280
#define MWL8K_CMD_MIMO_CONFIG		0x0125
281
#define MWL8K_CMD_USE_FIXED_RATE	0x0126
282
#define MWL8K_CMD_ENABLE_SNIFFER	0x0150
283
#define MWL8K_CMD_SET_MAC_ADDR		0x0202
284
#define MWL8K_CMD_SET_RATEADAPT_MODE	0x0203
285
#define MWL8K_CMD_BSS_START		0x1100
286
#define MWL8K_CMD_SET_NEW_STN		0x1111
287
#define MWL8K_CMD_UPDATE_STADB		0x1123
288 289 290 291 292 293 294

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)
295
	switch (cmd & ~0x8000) {
296 297
		MWL8K_CMDNAME(CODE_DNLD);
		MWL8K_CMDNAME(GET_HW_SPEC);
298
		MWL8K_CMDNAME(SET_HW_SPEC);
299 300 301 302
		MWL8K_CMDNAME(MAC_MULTICAST_ADR);
		MWL8K_CMDNAME(GET_STAT);
		MWL8K_CMDNAME(RADIO_CONTROL);
		MWL8K_CMDNAME(RF_TX_POWER);
303
		MWL8K_CMDNAME(RF_ANTENNA);
304
		MWL8K_CMDNAME(SET_BEACON);
305 306 307
		MWL8K_CMDNAME(SET_PRE_SCAN);
		MWL8K_CMDNAME(SET_POST_SCAN);
		MWL8K_CMDNAME(SET_RF_CHANNEL);
308 309 310 311
		MWL8K_CMDNAME(SET_AID);
		MWL8K_CMDNAME(SET_RATE);
		MWL8K_CMDNAME(SET_FINALIZE_JOIN);
		MWL8K_CMDNAME(RTS_THRESHOLD);
312
		MWL8K_CMDNAME(SET_SLOT);
313 314
		MWL8K_CMDNAME(SET_EDCA_PARAMS);
		MWL8K_CMDNAME(SET_WMM_MODE);
315
		MWL8K_CMDNAME(MIMO_CONFIG);
316
		MWL8K_CMDNAME(USE_FIXED_RATE);
317
		MWL8K_CMDNAME(ENABLE_SNIFFER);
318
		MWL8K_CMDNAME(SET_MAC_ADDR);
319
		MWL8K_CMDNAME(SET_RATEADAPT_MODE);
320
		MWL8K_CMDNAME(BSS_START);
321
		MWL8K_CMDNAME(SET_NEW_STN);
322
		MWL8K_CMDNAME(UPDATE_STADB);
323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351
	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)
{
352 353
	mwl8k_release_fw(&priv->fw_ucode);
	mwl8k_release_fw(&priv->fw_helper);
354 355 356 357
}

/* Request fw image */
static int mwl8k_request_fw(struct mwl8k_priv *priv,
L
Lennert Buytenhek 已提交
358
			    const char *fname, struct firmware **fw)
359 360 361 362 363 364
{
	/* release current image */
	if (*fw != NULL)
		mwl8k_release_fw(fw);

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

368
static int mwl8k_request_firmware(struct mwl8k_priv *priv)
369
{
370
	struct mwl8k_device_info *di = priv->device_info;
371 372
	int rc;

373
	if (di->helper_image != NULL) {
374
		rc = mwl8k_request_fw(priv, di->helper_image, &priv->fw_helper);
375 376 377 378 379 380
		if (rc) {
			printk(KERN_ERR "%s: Error requesting helper "
			       "firmware file %s\n", pci_name(priv->pdev),
			       di->helper_image);
			return rc;
		}
381 382
	}

383
	rc = mwl8k_request_fw(priv, di->fw_image, &priv->fw_ucode);
384
	if (rc) {
L
Lennert Buytenhek 已提交
385
		printk(KERN_ERR "%s: Error requesting firmware file %s\n",
386
		       pci_name(priv->pdev), di->fw_image);
387
		mwl8k_release_fw(&priv->fw_helper);
388 389 390 391 392 393
		return rc;
	}

	return 0;
}

B
Ben Hutchings 已提交
394 395 396
MODULE_FIRMWARE("mwl8k/helper_8687.fw");
MODULE_FIRMWARE("mwl8k/fmimage_8687.fw");

397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435
struct mwl8k_cmd_pkt {
	__le16	code;
	__le16	length;
	__le16	seq_num;
	__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;
		}

436
		cond_resched();
437 438 439 440 441
		udelay(1);
	} while (--loops);

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

442
	return loops ? 0 : -ETIMEDOUT;
443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 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
}

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;
	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 已提交
545
static int mwl8k_load_firmware(struct ieee80211_hw *hw)
546
{
L
Lennert Buytenhek 已提交
547
	struct mwl8k_priv *priv = hw->priv;
548
	struct firmware *fw = priv->fw_ucode;
L
Lennert Buytenhek 已提交
549 550 551 552
	int rc;
	int loops;

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

L
Lennert Buytenhek 已提交
555 556 557 558 559
		if (helper == NULL) {
			printk(KERN_ERR "%s: helper image needed but none "
			       "given\n", pci_name(priv->pdev));
			return -EINVAL;
		}
560

L
Lennert Buytenhek 已提交
561
		rc = mwl8k_load_fw_image(priv, helper->data, helper->size);
562 563
		if (rc) {
			printk(KERN_ERR "%s: unable to load firmware "
L
Lennert Buytenhek 已提交
564
			       "helper image\n", pci_name(priv->pdev));
565 566
			return rc;
		}
567
		msleep(5);
568

L
Lennert Buytenhek 已提交
569
		rc = mwl8k_feed_fw_image(priv, fw->data, fw->size);
570
	} else {
L
Lennert Buytenhek 已提交
571
		rc = mwl8k_load_fw_image(priv, fw->data, fw->size);
572 573 574
	}

	if (rc) {
L
Lennert Buytenhek 已提交
575 576
		printk(KERN_ERR "%s: unable to load firmware image\n",
		       pci_name(priv->pdev));
577 578 579
		return rc;
	}

580
	iowrite32(MWL8K_MODE_STA, priv->regs + MWL8K_HIU_GEN_PTR);
581

582
	loops = 500000;
583
	do {
584 585 586 587 588 589 590 591
		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;
592
			break;
593 594 595
		}

		cond_resched();
596 597 598 599 600 601 602 603 604 605 606
		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;
607
	char data[0];
608 609 610
} __attribute__((packed));

/* Routines to add/remove DMA header from skb.  */
611
static inline void mwl8k_remove_dma_header(struct sk_buff *skb, __le16 qos)
612
{
613 614 615 616 617 618 619 620 621 622 623 624 625
	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);
		}
626
	}
627 628 629

	if (hdrlen != sizeof(*tr))
		skb_pull(skb, sizeof(*tr) - hdrlen);
630 631
}

632
static inline void mwl8k_add_dma_header(struct sk_buff *skb)
633 634
{
	struct ieee80211_hdr *wh;
635
	int hdrlen;
636 637
	struct mwl8k_dma_data *tr;

638 639 640 641 642 643
	/*
	 * 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).
	 */
644
	wh = (struct ieee80211_hdr *)skb->data;
645

646
	hdrlen = ieee80211_hdrlen(wh->frame_control);
647 648
	if (hdrlen != sizeof(*tr))
		skb_push(skb, sizeof(*tr) - hdrlen);
649

650 651
	if (ieee80211_is_data_qos(wh->frame_control))
		hdrlen -= 2;
652 653 654 655

	tr = (struct mwl8k_dma_data *)skb->data;
	if (wh != &tr->wh)
		memmove(&tr->wh, wh, hdrlen);
656 657
	if (hdrlen != sizeof(tr->wh))
		memset(((void *)&tr->wh) + hdrlen, 0, sizeof(tr->wh) - hdrlen);
658 659 660 661 662 663

	/*
	 * 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.
	 */
664
	tr->fwlen = cpu_to_le16(skb->len - sizeof(*tr));
665 666 667 668
}


/*
669
 * Packet reception for 88w8366 AP firmware.
670
 */
671
struct mwl8k_rxd_8366_ap {
672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688
	__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));

689 690 691
#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)
692

693
#define MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST	0x80
694

695
static void mwl8k_rxd_8366_ap_init(void *_rxd, dma_addr_t next_dma_addr)
696
{
697
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
698 699

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
700
	rxd->rx_ctrl = MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST;
701 702
}

703
static void mwl8k_rxd_8366_ap_refill(void *_rxd, dma_addr_t addr, int len)
704
{
705
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
706 707 708 709 710 711 712 713

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

static int
714 715
mwl8k_rxd_8366_ap_process(void *_rxd, struct ieee80211_rx_status *status,
			  __le16 *qos)
716
{
717
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
718

719
	if (!(rxd->rx_ctrl & MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST))
720 721 722 723 724 725 726 727
		return -1;
	rmb();

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

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

728
	if (rxd->rate & MWL8K_8366_AP_RATE_INFO_MCS_FORMAT) {
729
		status->flag |= RX_FLAG_HT;
730
		if (rxd->rate & MWL8K_8366_AP_RATE_INFO_40MHZ)
731
			status->flag |= RX_FLAG_40MHZ;
732
		status->rate_idx = MWL8K_8366_AP_RATE_INFO_RATEID(rxd->rate);
733 734 735 736 737 738 739 740 741 742 743 744 745 746
	} else {
		int i;

		for (i = 0; i < ARRAY_SIZE(mwl8k_rates); i++) {
			if (mwl8k_rates[i].hw_value == rxd->rate) {
				status->rate_idx = i;
				break;
			}
		}
	}

	status->band = IEEE80211_BAND_2GHZ;
	status->freq = ieee80211_channel_to_frequency(rxd->channel);

747 748
	*qos = rxd->qos_control;

749 750 751
	return le16_to_cpu(rxd->pkt_len);
}

752 753 754 755 756
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,
757 758 759
};

/*
760
 * Packet reception for STA firmware.
761
 */
762
struct mwl8k_rxd_sta {
763 764 765 766
	__le16 pkt_len;
	__u8 link_quality;
	__u8 noise_level;
	__le32 pkt_phys_addr;
767
	__le32 next_rxd_phys_addr;
768 769 770 771 772 773 774 775 776 777 778
	__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));

779 780 781 782 783 784
#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
785

786
#define MWL8K_STA_RX_CTRL_OWNED_BY_HOST		0x02
787

788
static void mwl8k_rxd_sta_init(void *_rxd, dma_addr_t next_dma_addr)
789
{
790
	struct mwl8k_rxd_sta *rxd = _rxd;
791 792

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
793
	rxd->rx_ctrl = MWL8K_STA_RX_CTRL_OWNED_BY_HOST;
794 795
}

796
static void mwl8k_rxd_sta_refill(void *_rxd, dma_addr_t addr, int len)
797
{
798
	struct mwl8k_rxd_sta *rxd = _rxd;
799 800 801 802 803 804 805 806

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

static int
807
mwl8k_rxd_sta_process(void *_rxd, struct ieee80211_rx_status *status,
808
		       __le16 *qos)
809
{
810
	struct mwl8k_rxd_sta *rxd = _rxd;
811 812
	u16 rate_info;

813
	if (!(rxd->rx_ctrl & MWL8K_STA_RX_CTRL_OWNED_BY_HOST))
814 815 816 817 818 819 820 821 822
		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;
823 824
	status->antenna = MWL8K_STA_RATE_INFO_ANTSELECT(rate_info);
	status->rate_idx = MWL8K_STA_RATE_INFO_RATEID(rate_info);
825

826
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTPRE)
827
		status->flag |= RX_FLAG_SHORTPRE;
828
	if (rate_info & MWL8K_STA_RATE_INFO_40MHZ)
829
		status->flag |= RX_FLAG_40MHZ;
830
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTGI)
831
		status->flag |= RX_FLAG_SHORT_GI;
832
	if (rate_info & MWL8K_STA_RATE_INFO_MCS_FORMAT)
833 834 835 836 837
		status->flag |= RX_FLAG_HT;

	status->band = IEEE80211_BAND_2GHZ;
	status->freq = ieee80211_channel_to_frequency(rxd->channel);

838 839
	*qos = rxd->qos_control;

840 841 842
	return le16_to_cpu(rxd->pkt_len);
}

843 844 845 846 847
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,
848 849 850
};


851 852 853 854 855 856 857 858 859 860
#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;

861 862 863
	rxq->rxd_count = 0;
	rxq->head = 0;
	rxq->tail = 0;
864

865
	size = MWL8K_RX_DESCS * priv->rxd_ops->rxd_size;
866

867 868
	rxq->rxd = pci_alloc_consistent(priv->pdev, size, &rxq->rxd_dma);
	if (rxq->rxd == NULL) {
869
		printk(KERN_ERR "%s: failed to alloc RX descriptors\n",
L
Lennert Buytenhek 已提交
870
		       wiphy_name(hw->wiphy));
871 872
		return -ENOMEM;
	}
873
	memset(rxq->rxd, 0, size);
874

875 876
	rxq->buf = kmalloc(MWL8K_RX_DESCS * sizeof(*rxq->buf), GFP_KERNEL);
	if (rxq->buf == NULL) {
877
		printk(KERN_ERR "%s: failed to alloc RX skbuff list\n",
L
Lennert Buytenhek 已提交
878
		       wiphy_name(hw->wiphy));
879
		pci_free_consistent(priv->pdev, size, rxq->rxd, rxq->rxd_dma);
880 881
		return -ENOMEM;
	}
882
	memset(rxq->buf, 0, MWL8K_RX_DESCS * sizeof(*rxq->buf));
883 884

	for (i = 0; i < MWL8K_RX_DESCS; i++) {
885 886
		int desc_size;
		void *rxd;
887
		int nexti;
888 889 890 891
		dma_addr_t next_dma_addr;

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

893 894 895 896
		nexti = i + 1;
		if (nexti == MWL8K_RX_DESCS)
			nexti = 0;
		next_dma_addr = rxq->rxd_dma + (nexti * desc_size);
897

898
		priv->rxd_ops->rxd_init(rxd, next_dma_addr);
899 900 901 902 903 904 905 906 907 908 909 910
	}

	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;
911
	while (rxq->rxd_count < MWL8K_RX_DESCS && limit--) {
912
		struct sk_buff *skb;
913
		dma_addr_t addr;
914
		int rx;
915
		void *rxd;
916 917 918 919 920

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

921 922
		addr = pci_map_single(priv->pdev, skb->data,
				      MWL8K_RX_MAXSZ, DMA_FROM_DEVICE);
923

924 925 926 927
		rxq->rxd_count++;
		rx = rxq->tail++;
		if (rxq->tail == MWL8K_RX_DESCS)
			rxq->tail = 0;
928 929
		rxq->buf[rx].skb = skb;
		pci_unmap_addr_set(&rxq->buf[rx], dma, addr);
930 931 932

		rxd = rxq->rxd + (rx * priv->rxd_ops->rxd_size);
		priv->rxd_ops->rxd_refill(rxd, addr, MWL8K_RX_MAXSZ);
933 934 935 936 937 938 939 940 941 942 943 944 945 946 947

		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++) {
948 949 950 951 952 953 954 955
		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;
956 957 958
		}
	}

959 960
	kfree(rxq->buf);
	rxq->buf = NULL;
961 962

	pci_free_consistent(priv->pdev,
963
			    MWL8K_RX_DESCS * priv->rxd_ops->rxd_size,
964 965
			    rxq->rxd, rxq->rxd_dma);
	rxq->rxd = NULL;
966 967 968 969 970 971 972 973 974 975 976 977 978 979 980
}


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

981 982
static inline void mwl8k_save_beacon(struct ieee80211_hw *hw,
				     struct sk_buff *skb)
983
{
984 985
	struct mwl8k_priv *priv = hw->priv;

986
	priv->capture_beacon = false;
987
	memset(priv->capture_bssid, 0, ETH_ALEN);
988 989 990 991 992 993 994 995

	/*
	 * 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)
996
		ieee80211_queue_work(hw, &priv->finalize_join_worker);
997 998 999 1000 1001 1002 1003 1004 1005
}

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;
1006
	while (rxq->rxd_count && limit--) {
1007
		struct sk_buff *skb;
1008 1009
		void *rxd;
		int pkt_len;
1010
		struct ieee80211_rx_status status;
1011
		__le16 qos;
1012

1013
		skb = rxq->buf[rxq->head].skb;
1014 1015
		if (skb == NULL)
			break;
1016 1017 1018

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

1019
		pkt_len = priv->rxd_ops->rxd_process(rxd, &status, &qos);
1020 1021 1022
		if (pkt_len < 0)
			break;

1023 1024 1025 1026 1027 1028
		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);
1029

1030 1031 1032 1033
		rxq->head++;
		if (rxq->head == MWL8K_RX_DESCS)
			rxq->head = 0;

1034
		rxq->rxd_count--;
1035

1036
		skb_put(skb, pkt_len);
1037
		mwl8k_remove_dma_header(skb, qos);
1038 1039

		/*
L
Lennert Buytenhek 已提交
1040 1041 1042
		 * 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.
1043
		 */
1044
		if (mwl8k_capture_bssid(priv, (void *)skb->data))
1045
			mwl8k_save_beacon(hw, skb);
1046

1047 1048
		memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
		ieee80211_rx_irqsafe(hw, skb);
1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066

		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

1067 1068 1069 1070 1071 1072
#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

1073 1074 1075 1076 1077 1078 1079
struct mwl8k_tx_desc {
	__le32 status;
	__u8 data_rate;
	__u8 tx_priority;
	__le16 qos_control;
	__le32 pkt_phys_addr;
	__le16 pkt_len;
1080
	__u8 dest_MAC_addr[ETH_ALEN];
1081
	__le32 next_txd_phys_addr;
1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096
	__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;

1097 1098 1099 1100
	memset(&txq->stats, 0, sizeof(struct ieee80211_tx_queue_stats));
	txq->stats.limit = MWL8K_TX_DESCS;
	txq->head = 0;
	txq->tail = 0;
1101 1102 1103

	size = MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc);

1104 1105
	txq->txd = pci_alloc_consistent(priv->pdev, size, &txq->txd_dma);
	if (txq->txd == NULL) {
1106
		printk(KERN_ERR "%s: failed to alloc TX descriptors\n",
L
Lennert Buytenhek 已提交
1107
		       wiphy_name(hw->wiphy));
1108 1109
		return -ENOMEM;
	}
1110
	memset(txq->txd, 0, size);
1111

1112 1113
	txq->skb = kmalloc(MWL8K_TX_DESCS * sizeof(*txq->skb), GFP_KERNEL);
	if (txq->skb == NULL) {
1114
		printk(KERN_ERR "%s: failed to alloc TX skbuff list\n",
L
Lennert Buytenhek 已提交
1115
		       wiphy_name(hw->wiphy));
1116
		pci_free_consistent(priv->pdev, size, txq->txd, txq->txd_dma);
1117 1118
		return -ENOMEM;
	}
1119
	memset(txq->skb, 0, MWL8K_TX_DESCS * sizeof(*txq->skb));
1120 1121 1122 1123 1124

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

1125
		tx_desc = txq->txd + i;
1126 1127 1128
		nexti = (i + 1) % MWL8K_TX_DESCS;

		tx_desc->status = 0;
1129 1130
		tx_desc->next_txd_phys_addr =
			cpu_to_le32(txq->txd_dma + nexti * sizeof(*tx_desc));
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144
	}

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

1145
static void mwl8k_dump_tx_rings(struct ieee80211_hw *hw)
1146
{
1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
	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;

1157
		for (desc = 0; desc < MWL8K_TX_DESCS; desc++) {
1158 1159
			struct mwl8k_tx_desc *tx_desc = txq->txd + desc;
			u32 status;
1160

1161
			status = le32_to_cpu(tx_desc->status);
1162
			if (status & MWL8K_TXD_STATUS_FW_OWNED)
1163
				fw_owned++;
1164
			else
1165
				drv_owned++;
1166 1167

			if (tx_desc->pkt_len == 0)
1168
				unused++;
1169 1170
		}

1171 1172 1173 1174 1175 1176
		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,
		       txq->stats.len, txq->head, txq->tail,
		       fw_owned, drv_owned, unused);
	}
1177 1178
}

1179
/*
1180
 * Must be called with priv->fw_mutex held and tx queues stopped.
1181
 */
1182
#define MWL8K_TX_WAIT_TIMEOUT_MS	5000
1183

1184
static int mwl8k_tx_wait_empty(struct ieee80211_hw *hw)
1185 1186
{
	struct mwl8k_priv *priv = hw->priv;
1187
	DECLARE_COMPLETION_ONSTACK(tx_wait);
1188 1189
	int retry;
	int rc;
1190 1191 1192

	might_sleep();

1193 1194 1195 1196 1197 1198 1199 1200 1201 1202
	/*
	 * 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;

1203
	spin_lock_bh(&priv->tx_lock);
1204 1205 1206 1207
	priv->tx_wait = &tx_wait;
	while (!rc) {
		int oldcount;
		unsigned long timeout;
1208

1209
		oldcount = priv->pending_tx_pkts;
1210

1211
		spin_unlock_bh(&priv->tx_lock);
1212
		timeout = wait_for_completion_timeout(&tx_wait,
1213
			    msecs_to_jiffies(MWL8K_TX_WAIT_TIMEOUT_MS));
1214
		spin_lock_bh(&priv->tx_lock);
1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225

		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) {
1226 1227
			printk(KERN_NOTICE "%s: waiting for tx rings "
			       "to drain (%d -> %d pkts)\n",
1228 1229 1230 1231 1232 1233
			       wiphy_name(hw->wiphy), oldcount,
			       priv->pending_tx_pkts);
			retry = 1;
			continue;
		}

1234 1235
		priv->tx_wait = NULL;

1236 1237 1238 1239 1240
		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;
1241
	}
1242
	spin_unlock_bh(&priv->tx_lock);
1243

1244
	return rc;
1245 1246
}

1247 1248 1249 1250
#define MWL8K_TXD_SUCCESS(status)				\
	((status) & (MWL8K_TXD_STATUS_OK |			\
		     MWL8K_TXD_STATUS_OK_RETRY |		\
		     MWL8K_TXD_STATUS_OK_MORE_RETRY))
1251 1252 1253 1254 1255 1256 1257

static void mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int force)
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_tx_queue *txq = priv->txq + index;
	int wake = 0;

1258
	while (txq->stats.len > 0) {
1259 1260 1261
		int tx;
		struct mwl8k_tx_desc *tx_desc;
		unsigned long addr;
1262
		int size;
1263 1264 1265 1266
		struct sk_buff *skb;
		struct ieee80211_tx_info *info;
		u32 status;

1267 1268
		tx = txq->head;
		tx_desc = txq->txd + tx;
1269 1270 1271 1272 1273 1274 1275 1276 1277 1278

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

1279 1280 1281
		txq->head = (tx + 1) % MWL8K_TX_DESCS;
		BUG_ON(txq->stats.len == 0);
		txq->stats.len--;
1282 1283 1284
		priv->pending_tx_pkts--;

		addr = le32_to_cpu(tx_desc->pkt_phys_addr);
1285
		size = le16_to_cpu(tx_desc->pkt_len);
1286 1287
		skb = txq->skb[tx];
		txq->skb[tx] = NULL;
1288 1289 1290 1291

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

1292
		mwl8k_remove_dma_header(skb, tx_desc->qos_control);
1293 1294 1295 1296 1297 1298 1299

		/* 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);
1300
		if (MWL8K_TXD_SUCCESS(status))
1301 1302 1303 1304
			info->flags |= IEEE80211_TX_STAT_ACK;

		ieee80211_tx_status_irqsafe(hw, skb);

1305
		wake = 1;
1306 1307
	}

1308
	if (wake && priv->radio_on && !mutex_is_locked(&priv->fw_mutex))
1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319
		ieee80211_wake_queue(hw, index);
}

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

	mwl8k_txq_reclaim(hw, index, 1);

1320 1321
	kfree(txq->skb);
	txq->skb = NULL;
1322 1323 1324

	pci_free_consistent(priv->pdev,
			    MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc),
1325 1326
			    txq->txd, txq->txd_dma);
	txq->txd = NULL;
1327 1328 1329 1330 1331 1332 1333
}

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;
1334
	struct mwl8k_vif *mwl8k_vif;
1335 1336 1337 1338
	struct ieee80211_hdr *wh;
	struct mwl8k_tx_queue *txq;
	struct mwl8k_tx_desc *tx;
	dma_addr_t dma;
1339 1340 1341
	u32 txstatus;
	u8 txdatarate;
	u16 qos;
1342

1343 1344 1345 1346 1347
	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;
1348

1349
	mwl8k_add_dma_header(skb);
1350
	wh = &((struct mwl8k_dma_data *)skb->data)->wh;
1351 1352 1353 1354 1355 1356

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

	if (tx_info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
		u16 seqno = mwl8k_vif->seqno;
1357

1358 1359 1360 1361 1362
		wh->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
		wh->seq_ctrl |= cpu_to_le16(seqno << 4);
		mwl8k_vif->seqno = seqno++ % 4096;
	}

1363 1364 1365 1366 1367 1368
	/* 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;
1369
		qos |= MWL8K_QOS_QLEN_UNSPEC | MWL8K_QOS_EOSP;
1370 1371 1372 1373 1374
	} else if (ieee80211_is_data(wh->frame_control)) {
		txdatarate = 1;
		if (is_multicast_ether_addr(wh->addr1))
			txstatus |= MWL8K_TXD_STATUS_MULTICAST_TX;

1375
		qos &= ~MWL8K_QOS_ACK_POLICY_MASK;
1376
		if (tx_info->flags & IEEE80211_TX_CTL_AMPDU)
1377
			qos |= MWL8K_QOS_ACK_POLICY_BLOCKACK;
1378
		else
1379
			qos |= MWL8K_QOS_ACK_POLICY_NORMAL;
1380
	}
1381 1382 1383 1384 1385 1386

	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 已提交
1387
		       "dropping TX frame.\n", wiphy_name(hw->wiphy));
1388
		dev_kfree_skb(skb);
1389 1390 1391
		return NETDEV_TX_OK;
	}

1392
	spin_lock_bh(&priv->tx_lock);
1393

1394
	txq = priv->txq + index;
1395

1396 1397
	BUG_ON(txq->skb[txq->tail] != NULL);
	txq->skb[txq->tail] = skb;
1398

1399
	tx = txq->txd + txq->tail;
1400 1401
	tx->data_rate = txdatarate;
	tx->tx_priority = index;
1402 1403 1404
	tx->qos_control = cpu_to_le16(qos);
	tx->pkt_phys_addr = cpu_to_le32(dma);
	tx->pkt_len = cpu_to_le16(skb->len);
1405
	tx->rate_info = 0;
1406 1407 1408 1409
	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;
1410
	wmb();
1411 1412
	tx->status = cpu_to_le32(MWL8K_TXD_STATUS_FW_OWNED | txstatus);

1413 1414
	txq->stats.count++;
	txq->stats.len++;
1415 1416
	priv->pending_tx_pkts++;

1417 1418 1419
	txq->tail++;
	if (txq->tail == MWL8K_TX_DESCS)
		txq->tail = 0;
1420

1421
	if (txq->head == txq->tail)
1422 1423
		ieee80211_stop_queue(hw, index);

1424
	mwl8k_tx_start(priv);
1425 1426 1427 1428 1429 1430 1431

	spin_unlock_bh(&priv->tx_lock);

	return NETDEV_TX_OK;
}


1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485
/*
 * 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);
	}
}


1486 1487 1488 1489
/*
 * Command processing.
 */

1490 1491
/* Timeout firmware commands after 10s */
#define MWL8K_CMD_TIMEOUT_MS	10000
1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503

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 已提交
1504
	cmd->result = 0xffff;
1505 1506 1507 1508 1509 1510
	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;

1511
	rc = mwl8k_fw_lock(hw);
1512 1513 1514
	if (rc) {
		pci_unmap_single(priv->pdev, dma_addr, dma_size,
						PCI_DMA_BIDIRECTIONAL);
1515
		return rc;
1516
	}
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527

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

1528 1529 1530 1531
	priv->hostcmd_wait = NULL;

	mwl8k_fw_unlock(hw);

1532 1533 1534
	pci_unmap_single(priv->pdev, dma_addr, dma_size,
					PCI_DMA_BIDIRECTIONAL);

1535 1536
	if (!timeout) {
		printk(KERN_ERR "%s: Command %s timeout after %u ms\n",
L
Lennert Buytenhek 已提交
1537
		       wiphy_name(hw->wiphy),
1538 1539 1540 1541
		       mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
		       MWL8K_CMD_TIMEOUT_MS);
		rc = -ETIMEDOUT;
	} else {
1542 1543 1544 1545
		int ms;

		ms = MWL8K_CMD_TIMEOUT_MS - jiffies_to_msecs(timeout);

1546
		rc = cmd->result ? -EINVAL : 0;
1547 1548
		if (rc)
			printk(KERN_ERR "%s: Command %s error 0x%x\n",
L
Lennert Buytenhek 已提交
1549
			       wiphy_name(hw->wiphy),
1550
			       mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
1551
			       le16_to_cpu(cmd->result));
1552 1553 1554 1555 1556
		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);
1557 1558 1559 1560 1561 1562
	}

	return rc;
}

/*
1563
 * CMD_GET_HW_SPEC (STA version).
1564
 */
1565
struct mwl8k_cmd_get_hw_spec_sta {
1566 1567 1568 1569
	struct mwl8k_cmd_pkt header;
	__u8 hw_rev;
	__u8 host_interface;
	__le16 num_mcaddrs;
1570
	__u8 perm_addr[ETH_ALEN];
1571 1572 1573 1574 1575 1576 1577 1578 1579 1580
	__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;
1581
	__le32 total_rxd;
1582 1583
} __attribute__((packed));

1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645
#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

static void mwl8k_set_ht_caps(struct ieee80211_hw *hw, u32 cap)
{
	struct mwl8k_priv *priv = hw->priv;
	int rx_streams;
	int tx_streams;

	priv->band.ht_cap.ht_supported = 1;

	if (cap & MWL8K_CAP_MAX_AMSDU)
		priv->band.ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
	if (cap & MWL8K_CAP_GREENFIELD)
		priv->band.ht_cap.cap |= IEEE80211_HT_CAP_GRN_FLD;
	if (cap & MWL8K_CAP_AMPDU) {
		hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
		priv->band.ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
		priv->band.ht_cap.ampdu_density =
				IEEE80211_HT_MPDU_DENSITY_NONE;
	}
	if (cap & MWL8K_CAP_RX_STBC)
		priv->band.ht_cap.cap |= IEEE80211_HT_CAP_RX_STBC;
	if (cap & MWL8K_CAP_TX_STBC)
		priv->band.ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
	if (cap & MWL8K_CAP_SHORTGI_40MHZ)
		priv->band.ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
	if (cap & MWL8K_CAP_SHORTGI_20MHZ)
		priv->band.ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
	if (cap & MWL8K_CAP_DELAY_BA)
		priv->band.ht_cap.cap |= IEEE80211_HT_CAP_DELAY_BA;
	if (cap & MWL8K_CAP_40MHZ)
		priv->band.ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;

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

	priv->band.ht_cap.mcs.rx_mask[0] = 0xff;
	if (rx_streams >= 2)
		priv->band.ht_cap.mcs.rx_mask[1] = 0xff;
	if (rx_streams >= 3)
		priv->band.ht_cap.mcs.rx_mask[2] = 0xff;
	priv->band.ht_cap.mcs.rx_mask[4] = 0x01;
	priv->band.ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;

	if (rx_streams != tx_streams) {
		priv->band.ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
		priv->band.ht_cap.mcs.tx_params |= (tx_streams - 1) <<
				IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
	}
}

1646
static int mwl8k_cmd_get_hw_spec_sta(struct ieee80211_hw *hw)
1647 1648
{
	struct mwl8k_priv *priv = hw->priv;
1649
	struct mwl8k_cmd_get_hw_spec_sta *cmd;
1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661
	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);
1662
	cmd->rx_queue_ptr = cpu_to_le32(priv->rxq[0].rxd_dma);
1663
	cmd->num_tx_queues = cpu_to_le32(MWL8K_TX_QUEUES);
1664
	for (i = 0; i < MWL8K_TX_QUEUES; i++)
1665
		cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[i].txd_dma);
1666
	cmd->num_tx_desc_per_queue = cpu_to_le32(MWL8K_TX_DESCS);
1667
	cmd->total_rxd = cpu_to_le32(MWL8K_RX_DESCS);
1668 1669 1670 1671 1672 1673

	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);
1674
		priv->fw_rev = le32_to_cpu(cmd->fw_rev);
1675
		priv->hw_rev = cmd->hw_rev;
1676 1677
		if (cmd->caps & cpu_to_le32(MWL8K_CAP_MIMO))
			mwl8k_set_ht_caps(hw, le32_to_cpu(cmd->caps));
1678 1679 1680 1681 1682 1683
	}

	kfree(cmd);
	return rc;
}

1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775
/*
 * 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;

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

1776 1777 1778
#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
1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798

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);
1799 1800 1801
	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);
1802 1803 1804 1805 1806 1807 1808 1809 1810
	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;
}

1811 1812 1813 1814 1815 1816 1817
/*
 * CMD_MAC_MULTICAST_ADR.
 */
struct mwl8k_cmd_mac_multicast_adr {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 numaddr;
1818
	__u8 addr[0][ETH_ALEN];
1819 1820
};

1821 1822 1823 1824
#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
1825

1826
static struct mwl8k_cmd_pkt *
L
Lennert Buytenhek 已提交
1827
__mwl8k_cmd_mac_multicast_adr(struct ieee80211_hw *hw, int allmulti,
1828
			      int mc_count, struct dev_addr_list *mclist)
1829
{
1830
	struct mwl8k_priv *priv = hw->priv;
1831
	struct mwl8k_cmd_mac_multicast_adr *cmd;
1832 1833
	int size;

L
Lennert Buytenhek 已提交
1834
	if (allmulti || mc_count > priv->num_mcaddrs) {
1835 1836 1837
		allmulti = 1;
		mc_count = 0;
	}
1838 1839

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

1841
	cmd = kzalloc(size, GFP_ATOMIC);
1842
	if (cmd == NULL)
1843
		return NULL;
1844 1845 1846

	cmd->header.code = cpu_to_le16(MWL8K_CMD_MAC_MULTICAST_ADR);
	cmd->header.length = cpu_to_le16(size);
1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863
	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;
1864 1865 1866
		}
	}

1867
	return &cmd->header;
1868 1869 1870
}

/*
1871
 * CMD_GET_STAT.
1872
 */
1873
struct mwl8k_cmd_get_stat {
1874 1875 1876 1877 1878 1879 1880 1881 1882
	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

1883 1884
static int mwl8k_cmd_get_stat(struct ieee80211_hw *hw,
			      struct ieee80211_low_level_stats *stats)
1885
{
1886
	struct mwl8k_cmd_get_stat *cmd;
1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912
	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;
}

/*
1913
 * CMD_RADIO_CONTROL.
1914
 */
1915
struct mwl8k_cmd_radio_control {
1916 1917 1918 1919 1920 1921
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 control;
	__le16 radio_on;
} __attribute__((packed));

1922
static int
1923
mwl8k_cmd_radio_control(struct ieee80211_hw *hw, bool enable, bool force)
1924 1925
{
	struct mwl8k_priv *priv = hw->priv;
1926
	struct mwl8k_cmd_radio_control *cmd;
1927 1928
	int rc;

1929
	if (enable == priv->radio_on && !force)
1930 1931 1932 1933 1934 1935 1936 1937 1938
		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);
1939
	cmd->control = cpu_to_le16(priv->radio_short_preamble ? 3 : 1);
1940 1941 1942 1943 1944 1945
	cmd->radio_on = cpu_to_le16(enable ? 0x0001 : 0x0000);

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

	if (!rc)
1946
		priv->radio_on = enable;
1947 1948 1949 1950

	return rc;
}

1951
static int mwl8k_cmd_radio_disable(struct ieee80211_hw *hw)
1952
{
1953
	return mwl8k_cmd_radio_control(hw, 0, 0);
1954 1955
}

1956
static int mwl8k_cmd_radio_enable(struct ieee80211_hw *hw)
1957
{
1958
	return mwl8k_cmd_radio_control(hw, 1, 0);
1959 1960
}

1961 1962 1963
static int
mwl8k_set_radio_preamble(struct ieee80211_hw *hw, bool short_preamble)
{
1964
	struct mwl8k_priv *priv = hw->priv;
1965

1966
	priv->radio_short_preamble = short_preamble;
1967

1968
	return mwl8k_cmd_radio_control(hw, 1, 1);
1969 1970 1971
}

/*
1972
 * CMD_RF_TX_POWER.
1973 1974 1975
 */
#define MWL8K_TX_POWER_LEVEL_TOTAL	8

1976
struct mwl8k_cmd_rf_tx_power {
1977 1978 1979 1980 1981 1982 1983 1984
	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));

1985
static int mwl8k_cmd_rf_tx_power(struct ieee80211_hw *hw, int dBm)
1986
{
1987
	struct mwl8k_cmd_rf_tx_power *cmd;
1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004
	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;
}

2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037
/*
 * 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;
}

2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066
/*
 * CMD_SET_BEACON.
 */
struct mwl8k_cmd_set_beacon {
	struct mwl8k_cmd_pkt header;
	__le16 beacon_len;
	__u8 beacon[0];
};

static int mwl8k_cmd_set_beacon(struct ieee80211_hw *hw, u8 *beacon, int len)
{
	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);

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

	return rc;
}

2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097
/*
 * 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;
2098
	__u8 bssid[ETH_ALEN];
2099 2100 2101
} __attribute__((packed));

static int
2102
mwl8k_cmd_set_post_scan(struct ieee80211_hw *hw, const __u8 *mac)
2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113
{
	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;
2114
	memcpy(cmd->bssid, mac, ETH_ALEN);
2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132

	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,
2133
				    struct ieee80211_conf *conf)
2134
{
2135
	struct ieee80211_channel *channel = conf->channel;
2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146
	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;
2147

2148
	if (channel->band == IEEE80211_BAND_2GHZ)
2149 2150 2151 2152 2153 2154 2155 2156 2157
		cmd->channel_flags |= cpu_to_le32(0x00000001);

	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);
2158 2159 2160 2161 2162 2163 2164 2165

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

	return rc;
}

/*
2166
 * CMD_SET_AID.
2167
 */
2168 2169 2170 2171
#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
2172

2173 2174 2175
struct mwl8k_cmd_update_set_aid {
	struct	mwl8k_cmd_pkt header;
	__le16	aid;
2176

2177 2178 2179 2180
	 /* AP's MAC address (BSSID) */
	__u8	bssid[ETH_ALEN];
	__le16	protection_mode;
	__u8	supp_rates[14];
2181 2182
} __attribute__((packed));

L
Lennert Buytenhek 已提交
2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198
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))
			rates[j++] = mwl8k_rates[i].hw_value;
	}
}

2199
static int
L
Lennert Buytenhek 已提交
2200 2201
mwl8k_cmd_set_aid(struct ieee80211_hw *hw,
		  struct ieee80211_vif *vif, u32 legacy_rate_mask)
2202
{
2203 2204
	struct mwl8k_cmd_update_set_aid *cmd;
	u16 prot_mode;
2205 2206 2207 2208 2209 2210
	int rc;

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

2211
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_AID);
2212
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2213
	cmd->aid = cpu_to_le16(vif->bss_conf.aid);
2214
	memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN);
2215

2216
	if (vif->bss_conf.use_cts_prot) {
2217 2218
		prot_mode = MWL8K_FRAME_PROT_11G;
	} else {
2219
		switch (vif->bss_conf.ht_operation_mode &
2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232
			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);
2233

L
Lennert Buytenhek 已提交
2234
	legacy_rate_mask_to_array(cmd->supp_rates, legacy_rate_mask);
2235 2236 2237 2238 2239 2240 2241

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

	return rc;
}

2242
/*
2243
 * CMD_SET_RATE.
2244
 */
2245 2246 2247 2248 2249 2250 2251
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];
2252 2253
} __attribute__((packed));

2254
static int
L
Lennert Buytenhek 已提交
2255
mwl8k_cmd_set_rate(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2256
		   u32 legacy_rate_mask, u8 *mcs_rates)
2257
{
2258
	struct mwl8k_cmd_set_rate *cmd;
2259 2260 2261 2262 2263 2264
	int rc;

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

2265
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATE);
2266
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
2267
	legacy_rate_mask_to_array(cmd->legacy_rates, legacy_rate_mask);
2268
	memcpy(cmd->mcs_set, mcs_rates, 16);
2269 2270 2271 2272 2273 2274 2275

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

	return rc;
}

2276
/*
2277
 * CMD_FINALIZE_JOIN.
2278
 */
2279 2280 2281
#define MWL8K_FJ_BEACON_MAXLEN	128

struct mwl8k_cmd_finalize_join {
2282
	struct mwl8k_cmd_pkt header;
2283 2284
	__le32 sleep_interval;	/* Number of beacon periods to sleep */
	__u8 beacon_data[MWL8K_FJ_BEACON_MAXLEN];
2285 2286
} __attribute__((packed));

2287 2288
static int mwl8k_cmd_finalize_join(struct ieee80211_hw *hw, void *frame,
				   int framelen, int dtim)
2289
{
2290 2291 2292
	struct mwl8k_cmd_finalize_join *cmd;
	struct ieee80211_mgmt *payload = frame;
	int payload_len;
2293 2294 2295 2296 2297 2298
	int rc;

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

2299
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_FINALIZE_JOIN);
2300
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2301 2302 2303 2304 2305 2306 2307 2308 2309
	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);
2310 2311 2312 2313 2314 2315 2316 2317

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

	return rc;
}

/*
2318
 * CMD_SET_RTS_THRESHOLD.
2319
 */
2320
struct mwl8k_cmd_set_rts_threshold {
2321 2322
	struct mwl8k_cmd_pkt header;
	__le16 action;
2323
	__le16 threshold;
2324 2325
} __attribute__((packed));

L
Lennert Buytenhek 已提交
2326 2327
static int
mwl8k_cmd_set_rts_threshold(struct ieee80211_hw *hw, int rts_thresh)
2328
{
2329
	struct mwl8k_cmd_set_rts_threshold *cmd;
2330 2331 2332 2333 2334 2335
	int rc;

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

2336
	cmd->header.code = cpu_to_le16(MWL8K_CMD_RTS_THRESHOLD);
2337
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
2338 2339
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->threshold = cpu_to_le16(rts_thresh);
2340 2341 2342 2343 2344 2345 2346 2347

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

	return rc;
}

/*
2348
 * CMD_SET_SLOT.
2349
 */
2350
struct mwl8k_cmd_set_slot {
2351 2352
	struct mwl8k_cmd_pkt header;
	__le16 action;
2353
	__u8 short_slot;
2354 2355
} __attribute__((packed));

2356
static int mwl8k_cmd_set_slot(struct ieee80211_hw *hw, bool short_slot_time)
2357
{
2358
	struct mwl8k_cmd_set_slot *cmd;
2359 2360 2361 2362 2363 2364
	int rc;

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

2365
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_SLOT);
2366
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2367 2368
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->short_slot = short_slot_time;
2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387

	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;

2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404
	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;
2405

2406 2407
			/* Log exponent of min contention period: 0...15 */
			__u8 log_cw_min;
2408

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

2412 2413 2414 2415
			/* TX queue to configure */
			__u8 txq;
		} sta;
	};
2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426
} __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
2427 2428 2429
mwl8k_cmd_set_edca_params(struct ieee80211_hw *hw, __u8 qnum,
			  __u16 cw_min, __u16 cw_max,
			  __u8 aifs, __u16 txop)
2430
{
2431
	struct mwl8k_priv *priv = hw->priv;
2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442
	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);
2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453
	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;
	}
2454 2455 2456 2457 2458 2459 2460 2461

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

	return rc;
}

/*
2462
 * CMD_SET_WMM_MODE.
2463
 */
2464
struct mwl8k_cmd_set_wmm_mode {
2465
	struct mwl8k_cmd_pkt header;
2466
	__le16 action;
2467 2468
} __attribute__((packed));

2469
static int mwl8k_cmd_set_wmm_mode(struct ieee80211_hw *hw, bool enable)
2470
{
2471 2472
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_cmd_set_wmm_mode *cmd;
2473 2474 2475 2476 2477 2478
	int rc;

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

2479
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_WMM_MODE);
2480
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2481
	cmd->action = cpu_to_le16(!!enable);
2482 2483 2484

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

2486 2487
	if (!rc)
		priv->wmm_enabled = enable;
2488 2489 2490 2491 2492

	return rc;
}

/*
2493
 * CMD_MIMO_CONFIG.
2494
 */
2495 2496 2497 2498 2499
struct mwl8k_cmd_mimo_config {
	struct mwl8k_cmd_pkt header;
	__le32 action;
	__u8 rx_antenna_map;
	__u8 tx_antenna_map;
2500 2501
} __attribute__((packed));

2502
static int mwl8k_cmd_mimo_config(struct ieee80211_hw *hw, __u8 rx, __u8 tx)
2503
{
2504
	struct mwl8k_cmd_mimo_config *cmd;
2505 2506 2507 2508 2509 2510
	int rc;

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

2511
	cmd->header.code = cpu_to_le16(MWL8K_CMD_MIMO_CONFIG);
2512
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2513 2514 2515
	cmd->action = cpu_to_le32((u32)MWL8K_CMD_SET);
	cmd->rx_antenna_map = rx;
	cmd->tx_antenna_map = tx;
2516 2517 2518 2519 2520 2521 2522 2523

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

	return rc;
}

/*
2524
 * CMD_USE_FIXED_RATE (STA version).
2525
 */
2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539
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;
2540 2541
} __attribute__((packed));

2542 2543
#define MWL8K_USE_AUTO_RATE	0x0002
#define MWL8K_UCAST_RATE	0
2544

2545
static int mwl8k_cmd_use_fixed_rate_sta(struct ieee80211_hw *hw)
2546
{
2547
	struct mwl8k_cmd_use_fixed_rate_sta *cmd;
2548 2549 2550 2551 2552 2553 2554 2555
	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));
2556 2557
	cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE);
	cmd->rate_type = cpu_to_le32(MWL8K_UCAST_RATE);
2558 2559 2560 2561 2562 2563 2564

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

	return rc;
}

2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605
/*
 * 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;
}

2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646
/*
 * 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));

2647 2648 2649
#define MWL8K_MAC_TYPE_PRIMARY_CLIENT	0
#define MWL8K_MAC_TYPE_PRIMARY_AP	2

2650 2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661 2662
static int mwl8k_cmd_set_mac_addr(struct ieee80211_hw *hw, u8 *mac)
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_cmd_set_mac_addr *cmd;
	int rc;

	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) {
2663
		cmd->mbss.mac_type = cpu_to_le16(MWL8K_MAC_TYPE_PRIMARY_AP);
2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703
		memcpy(cmd->mbss.mac_addr, mac, ETH_ALEN);
	} else {
		memcpy(cmd->mac_addr, mac, ETH_ALEN);
	}

	rc = mwl8k_post_cmd(hw, &cmd->header);
	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;
}

2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 2730
/*
 * CMD_BSS_START.
 */
struct mwl8k_cmd_bss_start {
	struct mwl8k_cmd_pkt header;
	__le32 enable;
} __attribute__((packed));

static int mwl8k_cmd_bss_start(struct ieee80211_hw *hw, int enable)
{
	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);

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

	return rc;
}

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 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793
/*
 * 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;
	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);
	cmd->legacy_rates = cpu_to_le32(sta->supp_rates[IEEE80211_BAND_2GHZ]);
	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;
	}

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

	return rc;
}

2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812 2813
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);

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

	return rc;
}

2814 2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834
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);

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

	return rc;
}

2835 2836 2837
/*
 * CMD_UPDATE_STADB.
 */
2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872
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));

2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887
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));

2888 2889 2890 2891 2892 2893 2894
#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 已提交
2895
				      struct ieee80211_vif *vif,
2896
				      struct ieee80211_sta *sta)
2897 2898
{
	struct mwl8k_cmd_update_stadb *cmd;
2899
	struct peer_capability_info *p;
2900 2901 2902 2903 2904 2905 2906 2907
	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));
2908
	cmd->action = cpu_to_le32(MWL8K_STA_DB_MODIFY_ENTRY);
2909
	memcpy(cmd->peer_addr, sta->addr, ETH_ALEN);
2910

2911 2912 2913
	p = &cmd->peer_info;
	p->peer_type = MWL8K_PEER_TYPE_ACCESSPOINT;
	p->basic_caps = cpu_to_le16(vif->bss_conf.assoc_capability);
2914 2915 2916 2917 2918 2919 2920
	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);
	legacy_rate_mask_to_array(p->legacy_rates,
				  sta->supp_rates[IEEE80211_BAND_2GHZ]);
	memcpy(p->ht_rates, sta->ht_cap.mcs.rx_mask, 16);
2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942
	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);
2943
	memcpy(cmd->peer_addr, addr, ETH_ALEN);
2944

2945
	rc = mwl8k_post_cmd(hw, &cmd->header);
2946 2947 2948 2949 2950
	kfree(cmd);

	return rc;
}

2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975

/*
 * 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);
	iowrite32(~status, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);

	if (!status)
		return IRQ_NONE;

	if (status & MWL8K_A2H_INT_TX_DONE)
		tasklet_schedule(&priv->tx_reclaim_task);

	if (status & MWL8K_A2H_INT_RX_READY) {
		while (rxq_process(hw, 0, 1))
			rxq_refill(hw, 0, 1);
	}

	if (status & MWL8K_A2H_INT_OPC_DONE) {
2976
		if (priv->hostcmd_wait != NULL)
2977 2978 2979 2980
			complete(priv->hostcmd_wait);
	}

	if (status & MWL8K_A2H_INT_QUEUE_EMPTY) {
2981
		if (!mutex_is_locked(&priv->fw_mutex) &&
2982
		    priv->radio_on && priv->pending_tx_pkts)
2983
			mwl8k_tx_start(priv);
2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000
	}

	return IRQ_HANDLED;
}


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

	if (priv->current_channel == NULL) {
		printk(KERN_DEBUG "%s: dropped TX frame since radio "
L
Lennert Buytenhek 已提交
3001
		       "disabled\n", wiphy_name(hw->wiphy));
3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015
		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;

3016
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
3017 3018 3019
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
		printk(KERN_ERR "%s: failed to register IRQ handler\n",
L
Lennert Buytenhek 已提交
3020
		       wiphy_name(hw->wiphy));
3021
		return -EIO;
3022 3023
	}

3024 3025 3026
	/* Enable tx reclaim tasklet */
	tasklet_enable(&priv->tx_reclaim_task);

3027
	/* Enable interrupts */
3028
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
3029

3030 3031
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
3032
		rc = mwl8k_cmd_radio_enable(hw);
3033

3034 3035
		if (!priv->ap_fw) {
			if (!rc)
3036
				rc = mwl8k_cmd_enable_sniffer(hw, 0);
3037

3038 3039 3040 3041 3042 3043 3044
			if (!rc)
				rc = mwl8k_cmd_set_pre_scan(hw);

			if (!rc)
				rc = mwl8k_cmd_set_post_scan(hw,
						"\x00\x00\x00\x00\x00\x00");
		}
3045 3046

		if (!rc)
3047
			rc = mwl8k_cmd_set_rateadapt_mode(hw, 0);
3048

3049
		if (!rc)
3050
			rc = mwl8k_cmd_set_wmm_mode(hw, 0);
3051

3052 3053 3054 3055 3056 3057 3058 3059
		mwl8k_fw_unlock(hw);
	}

	if (rc) {
		iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
		free_irq(priv->pdev->irq, hw);
		tasklet_disable(&priv->tx_reclaim_task);
	}
3060 3061 3062 3063 3064 3065 3066 3067 3068

	return rc;
}

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

3069
	mwl8k_cmd_radio_disable(hw);
3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088 3089 3090

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

	/* Stop tx reclaim tasklet */
	tasklet_disable(&priv->tx_reclaim_task);

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

static int mwl8k_add_interface(struct ieee80211_hw *hw,
3091
				struct ieee80211_vif *vif)
3092 3093 3094 3095 3096 3097 3098 3099 3100 3101
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_vif *mwl8k_vif;

	/*
	 * We only support one active interface at a time.
	 */
	if (priv->vif != NULL)
		return -EBUSY;

3102 3103 3104
	/*
	 * Reject interface creation if sniffer mode is active, as
	 * STA operation is mutually exclusive with hardware sniffer
3105
	 * mode.  (Sniffer mode is only used on STA firmware.)
3106 3107 3108 3109 3110 3111 3112 3113
	 */
	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;
	}

L
Lennert Buytenhek 已提交
3114 3115 3116
	/* Set the mac address.  */
	mwl8k_cmd_set_mac_addr(hw, vif->addr);

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

3120
	/* Clean out driver private area */
3121
	mwl8k_vif = MWL8K_VIF(vif);
3122 3123 3124 3125 3126
	memset(mwl8k_vif, 0, sizeof(*mwl8k_vif));

	/* Set Initial sequence number to zero */
	mwl8k_vif->seqno = 0;

3127
	priv->vif = vif;
3128 3129 3130 3131 3132 3133
	priv->current_channel = NULL;

	return 0;
}

static void mwl8k_remove_interface(struct ieee80211_hw *hw,
3134
				   struct ieee80211_vif *vif)
3135 3136 3137
{
	struct mwl8k_priv *priv = hw->priv;

3138 3139 3140
	if (priv->ap_fw)
		mwl8k_cmd_set_new_stn_del(hw, vif, vif->addr);

3141
	mwl8k_cmd_set_mac_addr(hw, "\x00\x00\x00\x00\x00\x00");
3142

3143 3144 3145
	priv->vif = NULL;
}

3146
static int mwl8k_config(struct ieee80211_hw *hw, u32 changed)
3147 3148 3149
{
	struct ieee80211_conf *conf = &hw->conf;
	struct mwl8k_priv *priv = hw->priv;
3150
	int rc;
3151

L
Lennert Buytenhek 已提交
3152
	if (conf->flags & IEEE80211_CONF_IDLE) {
3153
		mwl8k_cmd_radio_disable(hw);
L
Lennert Buytenhek 已提交
3154
		priv->current_channel = NULL;
3155
		return 0;
L
Lennert Buytenhek 已提交
3156 3157
	}

3158 3159 3160
	rc = mwl8k_fw_lock(hw);
	if (rc)
		return rc;
3161

3162
	rc = mwl8k_cmd_radio_enable(hw);
3163 3164
	if (rc)
		goto out;
3165

3166
	rc = mwl8k_cmd_set_rf_channel(hw, conf);
3167 3168 3169 3170
	if (rc)
		goto out;

	priv->current_channel = conf->channel;
3171 3172 3173

	if (conf->power_level > 18)
		conf->power_level = 18;
3174
	rc = mwl8k_cmd_rf_tx_power(hw, conf->power_level);
3175 3176
	if (rc)
		goto out;
3177

3178 3179 3180 3181 3182 3183 3184
	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);
	}
3185

3186 3187
out:
	mwl8k_fw_unlock(hw);
3188

3189
	return rc;
3190 3191
}

3192 3193 3194
static void
mwl8k_bss_info_changed_sta(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			   struct ieee80211_bss_conf *info, u32 changed)
3195 3196
{
	struct mwl8k_priv *priv = hw->priv;
3197
	u32 ap_legacy_rates;
3198
	u8 ap_mcs_rates[16];
3199 3200
	int rc;

3201
	if (mwl8k_fw_lock(hw))
3202
		return;
3203

3204 3205 3206 3207 3208
	/*
	 * 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;
3209

3210
	/*
3211
	 * Get the AP's legacy and MCS rates.
3212 3213
	 */
	ap_legacy_rates = 0;
3214
	if (vif->bss_conf.assoc) {
L
Lennert Buytenhek 已提交
3215 3216 3217
		struct ieee80211_sta *ap;
		rcu_read_lock();

3218 3219 3220
		ap = ieee80211_find_sta(vif, vif->bss_conf.bssid);
		if (ap == NULL) {
			rcu_read_unlock();
L
Lennert Buytenhek 已提交
3221
			goto out;
3222 3223 3224
		}

		ap_legacy_rates = ap->supp_rates[IEEE80211_BAND_2GHZ];
3225
		memcpy(ap_mcs_rates, ap->ht_cap.mcs.rx_mask, 16);
3226 3227 3228

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

3230
	if ((changed & BSS_CHANGED_ASSOC) && vif->bss_conf.assoc) {
3231
		rc = mwl8k_cmd_set_rate(hw, vif, ap_legacy_rates, ap_mcs_rates);
3232 3233
		if (rc)
			goto out;
3234

3235
		rc = mwl8k_cmd_use_fixed_rate_sta(hw);
3236 3237
		if (rc)
			goto out;
3238
	}
3239

3240
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3241 3242
		rc = mwl8k_set_radio_preamble(hw,
				vif->bss_conf.use_short_preamble);
3243 3244
		if (rc)
			goto out;
3245
	}
3246

3247
	if (changed & BSS_CHANGED_ERP_SLOT) {
3248
		rc = mwl8k_cmd_set_slot(hw, vif->bss_conf.use_short_slot);
3249 3250
		if (rc)
			goto out;
3251
	}
3252

3253 3254 3255
	if (((changed & BSS_CHANGED_ASSOC) && vif->bss_conf.assoc) ||
	    (changed & (BSS_CHANGED_ERP_CTS_PROT | BSS_CHANGED_HT))) {
		rc = mwl8k_cmd_set_aid(hw, vif, ap_legacy_rates);
3256 3257
		if (rc)
			goto out;
3258
	}
3259

3260 3261
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_BEACON_INT))) {
3262 3263 3264 3265
		/*
		 * Finalize the join.  Tell rx handler to process
		 * next beacon from our BSSID.
		 */
3266
		memcpy(priv->capture_bssid, vif->bss_conf.bssid, ETH_ALEN);
3267 3268 3269
		priv->capture_beacon = true;
	}

3270 3271
out:
	mwl8k_fw_unlock(hw);
3272 3273
}

3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333
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);
		rate = idx ? mwl8k_rates[idx - 1].hw_value : 2;

		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) {
			mwl8k_cmd_set_beacon(hw, skb->data, skb->len);
			kfree_skb(skb);
		}
	}

	if (changed & BSS_CHANGED_BEACON_ENABLED)
		mwl8k_cmd_bss_start(hw, info->enable_beacon);

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

3334 3335 3336 3337 3338
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 已提交
3339 3340 3341 3342 3343 3344 3345 3346
	/*
	 * 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);
3347 3348 3349 3350

	return (unsigned long)cmd;
}

3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371
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.
	 */
	if (priv->vif != NULL) {
		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) {
3372
		if (mwl8k_cmd_enable_sniffer(hw, 1))
3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383
			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;
}

3384 3385 3386 3387 3388 3389
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;
3390 3391
	struct mwl8k_cmd_pkt *cmd = (void *)(unsigned long)multicast;

3392 3393 3394 3395 3396 3397 3398 3399 3400 3401
	/*
	 * 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;
	}

3402 3403 3404 3405 3406 3407 3408 3409 3410
	/*
	 * 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;
	}
3411

3412
	/* Clear unsupported feature flags */
L
Lennert Buytenhek 已提交
3413
	*total_flags &= FIF_ALLMULTI | FIF_BCN_PRBRESP_PROMISC;
3414

3415 3416
	if (mwl8k_fw_lock(hw)) {
		kfree(cmd);
3417
		return;
3418
	}
3419

3420
	if (priv->sniffer_enabled) {
3421
		mwl8k_cmd_enable_sniffer(hw, 0);
3422 3423 3424
		priv->sniffer_enabled = false;
	}

3425
	if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
3426 3427 3428 3429
		if (*total_flags & FIF_BCN_PRBRESP_PROMISC) {
			/*
			 * Disable the BSS filter.
			 */
3430
			mwl8k_cmd_set_pre_scan(hw);
3431
		} else {
3432
			const u8 *bssid;
3433

3434 3435 3436 3437 3438 3439 3440 3441 3442
			/*
			 * 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).
			 */
			bssid = "\x01\x00\x00\x00\x00\x00";
3443
			if (priv->vif != NULL)
3444
				bssid = priv->vif->bss_conf.bssid;
3445

3446
			mwl8k_cmd_set_post_scan(hw, bssid);
3447 3448 3449
		}
	}

L
Lennert Buytenhek 已提交
3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463
	/*
	 * 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);
3464
	}
3465

3466
	mwl8k_fw_unlock(hw);
3467 3468 3469 3470
}

static int mwl8k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
{
L
Lennert Buytenhek 已提交
3471
	return mwl8k_cmd_set_rts_threshold(hw, value);
3472 3473
}

3474 3475 3476 3477 3478
struct mwl8k_sta_notify_item
{
	struct list_head list;
	struct ieee80211_vif *vif;
	enum sta_notify_cmd cmd;
3479
	struct ieee80211_sta sta;
3480 3481
};

3482 3483 3484 3485 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
static void
mwl8k_do_sta_notify(struct ieee80211_hw *hw, struct mwl8k_sta_notify_item *s)
{
	struct mwl8k_priv *priv = hw->priv;

	/*
	 * STA firmware uses UPDATE_STADB, AP firmware uses SET_NEW_STN.
	 */
	if (!priv->ap_fw && s->cmd == STA_NOTIFY_ADD) {
		int rc;

		rc = mwl8k_cmd_update_stadb_add(hw, s->vif, &s->sta);
		if (rc >= 0) {
			struct ieee80211_sta *sta;

			rcu_read_lock();
			sta = ieee80211_find_sta(s->vif, s->sta.addr);
			if (sta != NULL)
				MWL8K_STA(sta)->peer_id = rc;
			rcu_read_unlock();
		}
	} else if (!priv->ap_fw && s->cmd == STA_NOTIFY_REMOVE) {
		mwl8k_cmd_update_stadb_del(hw, s->vif, s->sta.addr);
	} else if (priv->ap_fw && s->cmd == STA_NOTIFY_ADD) {
		mwl8k_cmd_set_new_stn_add(hw, s->vif, &s->sta);
	} else if (priv->ap_fw && s->cmd == STA_NOTIFY_REMOVE) {
		mwl8k_cmd_set_new_stn_del(hw, s->vif, s->sta.addr);
	}
}

3512 3513 3514 3515
static void mwl8k_sta_notify_worker(struct work_struct *work)
{
	struct mwl8k_priv *priv =
		container_of(work, struct mwl8k_priv, sta_notify_worker);
3516
	struct ieee80211_hw *hw = priv->hw;
3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527

	spin_lock_bh(&priv->sta_notify_list_lock);
	while (!list_empty(&priv->sta_notify_list)) {
		struct mwl8k_sta_notify_item *s;

		s = list_entry(priv->sta_notify_list.next,
			       struct mwl8k_sta_notify_item, list);
		list_del(&s->list);

		spin_unlock_bh(&priv->sta_notify_list_lock);

3528
		mwl8k_do_sta_notify(hw, s);
3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549
		kfree(s);

		spin_lock_bh(&priv->sta_notify_list_lock);
	}
	spin_unlock_bh(&priv->sta_notify_list_lock);
}

static void
mwl8k_sta_notify(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		 enum sta_notify_cmd cmd, struct ieee80211_sta *sta)
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_sta_notify_item *s;

	if (cmd != STA_NOTIFY_ADD && cmd != STA_NOTIFY_REMOVE)
		return;

	s = kmalloc(sizeof(*s), GFP_ATOMIC);
	if (s != NULL) {
		s->vif = vif;
		s->cmd = cmd;
3550
		s->sta = *sta;
3551 3552 3553 3554 3555 3556 3557 3558 3559

		spin_lock(&priv->sta_notify_list_lock);
		list_add_tail(&s->list, &priv->sta_notify_list);
		spin_unlock(&priv->sta_notify_list_lock);

		ieee80211_queue_work(hw, &priv->sta_notify_worker);
	}
}

3560 3561 3562
static int mwl8k_conf_tx(struct ieee80211_hw *hw, u16 queue,
			 const struct ieee80211_tx_queue_params *params)
{
3563
	struct mwl8k_priv *priv = hw->priv;
3564 3565
	int rc;

3566 3567 3568
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
		if (!priv->wmm_enabled)
3569
			rc = mwl8k_cmd_set_wmm_mode(hw, 1);
3570

3571
		if (!rc)
3572 3573 3574 3575 3576
			rc = mwl8k_cmd_set_edca_params(hw, queue,
						       params->cw_min,
						       params->cw_max,
						       params->aifs,
						       params->txop);
3577 3578

		mwl8k_fw_unlock(hw);
3579
	}
3580

3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593
	return rc;
}

static int mwl8k_get_tx_stats(struct ieee80211_hw *hw,
			      struct ieee80211_tx_queue_stats *stats)
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_tx_queue *txq;
	int index;

	spin_lock_bh(&priv->tx_lock);
	for (index = 0; index < MWL8K_TX_QUEUES; index++) {
		txq = priv->txq + index;
3594
		memcpy(&stats[index], &txq->stats,
3595 3596 3597 3598
			sizeof(struct ieee80211_tx_queue_stats));
	}
	spin_unlock_bh(&priv->tx_lock);

3599
	return 0;
3600 3601 3602 3603 3604
}

static int mwl8k_get_stats(struct ieee80211_hw *hw,
			   struct ieee80211_low_level_stats *stats)
{
3605
	return mwl8k_cmd_get_stat(hw, stats);
3606 3607
}

3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623
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;
	}
}

3624 3625 3626 3627 3628 3629 3630 3631
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,
3632
	.prepare_multicast	= mwl8k_prepare_multicast,
3633 3634
	.configure_filter	= mwl8k_configure_filter,
	.set_rts_threshold	= mwl8k_set_rts_threshold,
3635
	.sta_notify		= mwl8k_sta_notify,
3636 3637 3638
	.conf_tx		= mwl8k_conf_tx,
	.get_tx_stats		= mwl8k_get_tx_stats,
	.get_stats		= mwl8k_get_stats,
3639
	.ampdu_action		= mwl8k_ampdu_action,
3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651
};

static void mwl8k_tx_reclaim_handler(unsigned long data)
{
	int i;
	struct ieee80211_hw *hw = (struct ieee80211_hw *) data;
	struct mwl8k_priv *priv = hw->priv;

	spin_lock_bh(&priv->tx_lock);
	for (i = 0; i < MWL8K_TX_QUEUES; i++)
		mwl8k_txq_reclaim(hw, i, 0);

3652
	if (priv->tx_wait != NULL && !priv->pending_tx_pkts) {
3653 3654
		complete(priv->tx_wait);
		priv->tx_wait = NULL;
3655 3656 3657 3658 3659 3660 3661 3662 3663 3664
	}
	spin_unlock_bh(&priv->tx_lock);
}

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;

3665 3666
	mwl8k_cmd_finalize_join(priv->hw, skb->data, skb->len,
				priv->vif->bss_conf.dtim_period);
3667 3668 3669 3670 3671
	dev_kfree_skb(skb);

	priv->beacon_skb = NULL;
}

3672
enum {
3673 3674
	MWL8363 = 0,
	MWL8687,
3675
	MWL8366,
3676 3677
};

3678
static struct mwl8k_device_info mwl8k_info_tbl[] __devinitdata = {
3679 3680 3681 3682 3683
	[MWL8363] = {
		.part_name	= "88w8363",
		.helper_image	= "mwl8k/helper_8363.fw",
		.fw_image	= "mwl8k/fmimage_8363.fw",
	},
3684
	[MWL8687] = {
3685 3686 3687 3688
		.part_name	= "88w8687",
		.helper_image	= "mwl8k/helper_8687.fw",
		.fw_image	= "mwl8k/fmimage_8687.fw",
	},
3689
	[MWL8366] = {
3690 3691 3692
		.part_name	= "88w8366",
		.helper_image	= "mwl8k/helper_8366.fw",
		.fw_image	= "mwl8k/fmimage_8366.fw",
3693
		.ap_rxd_ops	= &rxd_8366_ap_ops,
3694
	},
3695 3696 3697
};

static DEFINE_PCI_DEVICE_TABLE(mwl8k_pci_id_table) = {
3698 3699
	{ PCI_VDEVICE(MARVELL, 0x2a0c), .driver_data = MWL8363, },
	{ PCI_VDEVICE(MARVELL, 0x2a24), .driver_data = MWL8363, },
3700 3701 3702 3703
	{ PCI_VDEVICE(MARVELL, 0x2a2b), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a30), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a40), .driver_data = MWL8366, },
	{ },
3704 3705 3706
};
MODULE_DEVICE_TABLE(pci, mwl8k_pci_id_table);

3707 3708 3709
static int __devinit mwl8k_probe(struct pci_dev *pdev,
				 const struct pci_device_id *id)
{
3710
	static int printed_version = 0;
3711 3712 3713 3714
	struct ieee80211_hw *hw;
	struct mwl8k_priv *priv;
	int rc;
	int i;
3715 3716 3717 3718 3719

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

3721

3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732
	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);
3733
		goto err_disable_device;
3734 3735 3736 3737
	}

	pci_set_master(pdev);

3738

3739 3740 3741 3742 3743 3744 3745
	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;
	}

3746 3747 3748
	SET_IEEE80211_DEV(hw, &pdev->dev);
	pci_set_drvdata(pdev, hw);

3749 3750 3751
	priv = hw->priv;
	priv->hw = hw;
	priv->pdev = pdev;
3752
	priv->device_info = &mwl8k_info_tbl[id->driver_data];
3753 3754


L
Lennert Buytenhek 已提交
3755 3756 3757
	priv->sram = pci_iomap(pdev, 0, 0x10000);
	if (priv->sram == NULL) {
		printk(KERN_ERR "%s: Cannot map device SRAM\n",
L
Lennert Buytenhek 已提交
3758
		       wiphy_name(hw->wiphy));
3759 3760 3761
		goto err_iounmap;
	}

L
Lennert Buytenhek 已提交
3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775
	/*
	 * 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;
		}
	}

3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790 3791 3792 3793 3794 3795 3796 3797 3798 3799

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


3800
	if (priv->ap_fw) {
3801
		priv->rxd_ops = priv->device_info->ap_rxd_ops;
3802 3803 3804 3805 3806 3807 3808
		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 {
3809
		priv->rxd_ops = &rxd_sta_ops;
3810
	}
3811 3812 3813 3814 3815 3816

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


3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839
	memcpy(priv->channels, mwl8k_channels, sizeof(mwl8k_channels));
	priv->band.band = IEEE80211_BAND_2GHZ;
	priv->band.channels = priv->channels;
	priv->band.n_channels = ARRAY_SIZE(mwl8k_channels);
	priv->band.bitrates = priv->rates;
	priv->band.n_bitrates = ARRAY_SIZE(mwl8k_rates);
	hw->wiphy->bands[IEEE80211_BAND_2GHZ] = &priv->band;

	BUILD_BUG_ON(sizeof(priv->rates) != sizeof(mwl8k_rates));
	memcpy(priv->rates, mwl8k_rates, sizeof(mwl8k_rates));

	/*
	 * 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 */
3840
	hw->flags |= IEEE80211_HW_SIGNAL_DBM | IEEE80211_HW_NOISE_DBM;
3841
	hw->vif_data_size = sizeof(struct mwl8k_vif);
3842
	hw->sta_data_size = sizeof(struct mwl8k_sta);
3843 3844 3845
	priv->vif = NULL;

	/* Set default radio state and preamble */
3846
	priv->radio_on = 0;
3847
	priv->radio_short_preamble = 0;
3848

3849 3850 3851 3852 3853
	/* Station database handling */
	INIT_WORK(&priv->sta_notify_worker, mwl8k_sta_notify_worker);
	spin_lock_init(&priv->sta_notify_list_lock);
	INIT_LIST_HEAD(&priv->sta_notify_list);

3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864
	/* Finalize join worker */
	INIT_WORK(&priv->finalize_join_worker, mwl8k_finalize_join_worker);

	/* TX reclaim tasklet */
	tasklet_init(&priv->tx_reclaim_task,
			mwl8k_tx_reclaim_handler, (unsigned long)hw);
	tasklet_disable(&priv->tx_reclaim_task);

	/* Power management cookie */
	priv->cookie = pci_alloc_consistent(priv->pdev, 4, &priv->cookie_dma);
	if (priv->cookie == NULL)
3865
		goto err_stop_firmware;
3866 3867 3868

	rc = mwl8k_rxq_init(hw, 0);
	if (rc)
3869
		goto err_free_cookie;
3870 3871
	rxq_refill(hw, 0, INT_MAX);

3872 3873 3874 3875 3876
	mutex_init(&priv->fw_mutex);
	priv->fw_mutex_owner = NULL;
	priv->fw_mutex_depth = 0;
	priv->hostcmd_wait = NULL;

3877 3878
	spin_lock_init(&priv->tx_lock);

3879 3880
	priv->tx_wait = NULL;

3881 3882 3883 3884 3885 3886 3887
	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);
3888
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
3889 3890 3891
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL);
	iowrite32(0xffffffff, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);

3892
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
3893 3894 3895
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
		printk(KERN_ERR "%s: failed to register IRQ handler\n",
L
Lennert Buytenhek 已提交
3896
		       wiphy_name(hw->wiphy));
3897 3898 3899 3900 3901
		goto err_free_queues;
	}

	/*
	 * Temporarily enable interrupts.  Initial firmware host
L
Lennert Buytenhek 已提交
3902
	 * commands use interrupts and avoid polling.  Disable
3903 3904
	 * interrupts when done.
	 */
3905
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
3906 3907

	/* Get config data, mac addrs etc */
3908 3909 3910 3911
	if (priv->ap_fw) {
		rc = mwl8k_cmd_get_hw_spec_ap(hw);
		if (!rc)
			rc = mwl8k_cmd_set_hw_spec(hw);
3912 3913

		hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_AP);
3914 3915
	} else {
		rc = mwl8k_cmd_get_hw_spec_sta(hw);
3916 3917

		hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
3918
	}
3919
	if (rc) {
L
Lennert Buytenhek 已提交
3920 3921
		printk(KERN_ERR "%s: Cannot initialise firmware\n",
		       wiphy_name(hw->wiphy));
3922
		goto err_free_irq;
3923 3924 3925
	}

	/* Turn radio off */
3926
	rc = mwl8k_cmd_radio_disable(hw);
3927
	if (rc) {
L
Lennert Buytenhek 已提交
3928
		printk(KERN_ERR "%s: Cannot disable\n", wiphy_name(hw->wiphy));
3929
		goto err_free_irq;
3930 3931
	}

3932
	/* Clear MAC address */
3933
	rc = mwl8k_cmd_set_mac_addr(hw, "\x00\x00\x00\x00\x00\x00");
3934 3935 3936
	if (rc) {
		printk(KERN_ERR "%s: Cannot clear MAC address\n",
		       wiphy_name(hw->wiphy));
3937
		goto err_free_irq;
3938 3939
	}

3940 3941 3942 3943 3944 3945
	/* 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 已提交
3946 3947
		printk(KERN_ERR "%s: Cannot register device\n",
		       wiphy_name(hw->wiphy));
3948
		goto err_free_queues;
3949 3950
	}

3951
	printk(KERN_INFO "%s: %s v%d, %pM, %s firmware %u.%u.%u.%u\n",
3952
	       wiphy_name(hw->wiphy), priv->device_info->part_name,
3953
	       priv->hw_rev, hw->wiphy->perm_addr,
3954
	       priv->ap_fw ? "AP" : "STA",
3955 3956
	       (priv->fw_rev >> 24) & 0xff, (priv->fw_rev >> 16) & 0xff,
	       (priv->fw_rev >> 8) & 0xff, priv->fw_rev & 0xff);
3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968

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

3969
err_free_cookie:
3970 3971 3972 3973
	if (priv->cookie != NULL)
		pci_free_consistent(priv->pdev, 4,
				priv->cookie, priv->cookie_dma);

3974 3975 3976 3977 3978
err_stop_firmware:
	mwl8k_hw_reset(priv);
	mwl8k_release_firmware(priv);

err_iounmap:
3979 3980 3981
	if (priv->regs != NULL)
		pci_iounmap(pdev, priv->regs);

L
Lennert Buytenhek 已提交
3982 3983 3984
	if (priv->sram != NULL)
		pci_iounmap(pdev, priv->sram);

3985 3986 3987 3988 3989
	pci_set_drvdata(pdev, NULL);
	ieee80211_free_hw(hw);

err_free_reg:
	pci_release_regions(pdev);
3990 3991

err_disable_device:
3992 3993 3994 3995 3996
	pci_disable_device(pdev);

	return rc;
}

3997
static void __devexit mwl8k_shutdown(struct pci_dev *pdev)
3998 3999 4000 4001
{
	printk(KERN_ERR "===>%s(%u)\n", __func__, __LINE__);
}

4002
static void __devexit mwl8k_remove(struct pci_dev *pdev)
4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013
{
	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);

4014 4015
	ieee80211_unregister_hw(hw);

4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030
	/* Remove tx reclaim tasklet */
	tasklet_kill(&priv->tx_reclaim_task);

	/* Stop hardware */
	mwl8k_hw_reset(priv);

	/* Return all skbs to mac80211 */
	for (i = 0; i < MWL8K_TX_QUEUES; i++)
		mwl8k_txq_reclaim(hw, i, 1);

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

	mwl8k_rxq_deinit(hw, 0);

L
Lennert Buytenhek 已提交
4031
	pci_free_consistent(priv->pdev, 4, priv->cookie, priv->cookie_dma);
4032 4033

	pci_iounmap(pdev, priv->regs);
L
Lennert Buytenhek 已提交
4034
	pci_iounmap(pdev, priv->sram);
4035 4036 4037 4038 4039 4040 4041 4042
	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,
4043
	.id_table	= mwl8k_pci_id_table,
4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060
	.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 已提交
4061 4062 4063 4064 4065

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