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

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
15
#include <linux/sched.h>
16 17 18 19 20 21
#include <linux/spinlock.h>
#include <linux/list.h>
#include <linux/pci.h>
#include <linux/delay.h>
#include <linux/completion.h>
#include <linux/etherdevice.h>
22
#include <linux/slab.h>
23 24 25 26 27 28 29
#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
30
#define MWL8K_VERSION	"0.12"
31

32 33 34 35 36 37
/* Module parameters */
static unsigned ap_mode_default;
module_param(ap_mode_default, bool, 0);
MODULE_PARM_DESC(ap_mode_default,
		 "Set to 1 to make ap mode the default instead of sta mode");

38 39
/* Register definitions */
#define MWL8K_HIU_GEN_PTR			0x00000c10
40 41
#define  MWL8K_MODE_STA				 0x0000005a
#define  MWL8K_MODE_AP				 0x000000a5
42
#define MWL8K_HIU_INT_CODE			0x00000c14
43 44 45
#define  MWL8K_FWSTA_READY			 0xf0f1f2f4
#define  MWL8K_FWAP_READY			 0xf1f2f4a5
#define  MWL8K_INT_CODE_CMD_FINISHED		 0x00000005
46 47 48 49 50 51 52 53
#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
54 55 56 57
#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)
58 59 60 61 62 63 64

/* 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
65 66 67 68 69 70 71 72 73 74
#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)
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

#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

90 91 92 93
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);
94
	int (*rxd_process)(void *rxd, struct ieee80211_rx_status *status,
95
			   __le16 *qos, s8 *noise);
96 97
};

98
struct mwl8k_device_info {
99 100
	char *part_name;
	char *helper_image;
101 102
	char *fw_image_sta;
	char *fw_image_ap;
103
	struct rxd_ops *ap_rxd_ops;
104
	u32 fw_api_ap;
105 106
};

107
struct mwl8k_rx_queue {
108
	int rxd_count;
109 110

	/* hw receives here */
111
	int head;
112 113

	/* refill descs here */
114
	int tail;
115

116
	void *rxd;
117
	dma_addr_t rxd_dma;
118 119
	struct {
		struct sk_buff *skb;
120
		DEFINE_DMA_UNMAP_ADDR(dma);
121
	} *buf;
122 123 124 125
};

struct mwl8k_tx_queue {
	/* hw transmits here */
126
	int head;
127 128

	/* sw appends here */
129
	int tail;
130

131
	unsigned int len;
132 133 134
	struct mwl8k_tx_desc *txd;
	dma_addr_t txd_dma;
	struct sk_buff **skb;
135 136 137 138 139 140
};

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

141 142
	struct mwl8k_device_info *device_info;

143 144 145 146
	void __iomem *sram;
	void __iomem *regs;

	/* firmware */
147 148
	const struct firmware *fw_helper;
	const struct firmware *fw_ucode;
149

150 151 152
	/* hardware/firmware parameters */
	bool ap_fw;
	struct rxd_ops *rxd_ops;
153 154 155
	struct ieee80211_supported_band band_24;
	struct ieee80211_channel channels_24[14];
	struct ieee80211_rate rates_24[14];
156 157 158
	struct ieee80211_supported_band band_50;
	struct ieee80211_channel channels_50[4];
	struct ieee80211_rate rates_50[9];
159 160
	u32 ap_macids_supported;
	u32 sta_macids_supported;
161

162 163 164 165 166 167
	/* firmware access */
	struct mutex fw_mutex;
	struct task_struct *fw_mutex_owner;
	int fw_mutex_depth;
	struct completion *hostcmd_wait;

168 169 170
	/* lock held over TX and TX reap */
	spinlock_t tx_lock;

171 172 173
	/* TX quiesce completion, protected by fw_mutex and tx_lock */
	struct completion *tx_wait;

174
	/* List of interfaces.  */
175
	u32 macids_used;
176
	struct list_head vif_list;
177 178 179 180 181 182 183

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

	u16 num_mcaddrs;
	u8 hw_rev;
184
	u32 fw_rev;
185 186 187 188 189 190 191 192 193 194

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

195
	bool radio_on;
196
	bool radio_short_preamble;
197
	bool sniffer_enabled;
198
	bool wmm_enabled;
199 200 201

	/* XXX need to convert this to handle multiple interfaces */
	bool capture_beacon;
202
	u8 capture_bssid[ETH_ALEN];
203 204 205 206 207 208 209 210 211 212
	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;

213 214
	/* Tasklet to perform TX reclaim.  */
	struct tasklet_struct poll_tx_task;
215 216 217

	/* Tasklet to perform RX.  */
	struct tasklet_struct poll_rx_task;
218 219 220

	/* Most recently reported noise in dBm */
	s8 noise;
221 222 223 224 225 226

	/*
	 * preserve the queue configurations so they can be restored if/when
	 * the firmware image is swapped.
	 */
	struct ieee80211_tx_queue_params wmm_params[MWL8K_TX_QUEUES];
227 228 229 230 231 232

	/* async firmware loading state */
	unsigned fw_state;
	char *fw_pref;
	char *fw_alt;
	struct completion firmware_loading_complete;
233 234
};

235 236 237
#define MAX_WEP_KEY_LEN         13
#define NUM_WEP_KEYS            4

238 239
/* Per interface specific private data */
struct mwl8k_vif {
240 241 242
	struct list_head list;
	struct ieee80211_vif *vif;

243 244 245
	/* Firmware macid for this vif.  */
	int macid;

Lennert Buytenhek's avatar
Lennert Buytenhek committed
246
	/* Non AMPDU sequence number assigned by driver.  */
247
	u16 seqno;
248 249 250 251 252 253

	/* Saved WEP keys */
	struct {
		u8 enabled;
		u8 key[sizeof(struct ieee80211_key_conf) + MAX_WEP_KEY_LEN];
	} wep_key_conf[NUM_WEP_KEYS];
254
};
255
#define MWL8K_VIF(_vif) ((struct mwl8k_vif *)&((_vif)->drv_priv))
256

257 258 259 260 261 262
struct mwl8k_sta {
	/* Index into station database. Returned by UPDATE_STADB.  */
	u8 peer_id;
};
#define MWL8K_STA(_sta) ((struct mwl8k_sta *)&((_sta)->drv_priv))

263
static const struct ieee80211_channel mwl8k_channels_24[] = {
264 265 266 267 268 269 270 271 272 273 274
	{ .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, },
275 276 277
	{ .center_freq = 2467, .hw_value = 12, },
	{ .center_freq = 2472, .hw_value = 13, },
	{ .center_freq = 2484, .hw_value = 14, },
278 279
};

280
static const struct ieee80211_rate mwl8k_rates_24[] = {
281 282 283
	{ .bitrate = 10, .hw_value = 2, },
	{ .bitrate = 20, .hw_value = 4, },
	{ .bitrate = 55, .hw_value = 11, },
284 285
	{ .bitrate = 110, .hw_value = 22, },
	{ .bitrate = 220, .hw_value = 44, },
286 287 288 289 290 291 292 293
	{ .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, },
294 295 296
	{ .bitrate = 720, .hw_value = 144, },
};

297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315
static const struct ieee80211_channel mwl8k_channels_50[] = {
	{ .center_freq = 5180, .hw_value = 36, },
	{ .center_freq = 5200, .hw_value = 40, },
	{ .center_freq = 5220, .hw_value = 44, },
	{ .center_freq = 5240, .hw_value = 48, },
};

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

316 317
/* Set or get info from Firmware */
#define MWL8K_CMD_GET			0x0000
318 319
#define MWL8K_CMD_SET			0x0001
#define MWL8K_CMD_SET_LIST		0x0002
320 321 322 323

/* Firmware command codes */
#define MWL8K_CMD_CODE_DNLD		0x0001
#define MWL8K_CMD_GET_HW_SPEC		0x0003
324
#define MWL8K_CMD_SET_HW_SPEC		0x0004
325 326
#define MWL8K_CMD_MAC_MULTICAST_ADR	0x0010
#define MWL8K_CMD_GET_STAT		0x0014
327 328
#define MWL8K_CMD_RADIO_CONTROL		0x001c
#define MWL8K_CMD_RF_TX_POWER		0x001e
329
#define MWL8K_CMD_TX_POWER		0x001f
330
#define MWL8K_CMD_RF_ANTENNA		0x0020
331
#define MWL8K_CMD_SET_BEACON		0x0100		/* per-vif */
332 333
#define MWL8K_CMD_SET_PRE_SCAN		0x0107
#define MWL8K_CMD_SET_POST_SCAN		0x0108
334 335 336 337 338
#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
339
#define MWL8K_CMD_SET_SLOT		0x0114
340 341
#define MWL8K_CMD_SET_EDCA_PARAMS	0x0115
#define MWL8K_CMD_SET_WMM_MODE		0x0123
342
#define MWL8K_CMD_MIMO_CONFIG		0x0125
343
#define MWL8K_CMD_USE_FIXED_RATE	0x0126
344
#define MWL8K_CMD_ENABLE_SNIFFER	0x0150
345
#define MWL8K_CMD_SET_MAC_ADDR		0x0202		/* per-vif */
346
#define MWL8K_CMD_SET_RATEADAPT_MODE	0x0203
347 348
#define MWL8K_CMD_BSS_START		0x1100		/* per-vif */
#define MWL8K_CMD_SET_NEW_STN		0x1111		/* per-vif */
349
#define MWL8K_CMD_UPDATE_STADB		0x1123
350

351
static const char *mwl8k_cmd_name(__le16 cmd, char *buf, int bufsize)
352
{
353 354
	u16 command = le16_to_cpu(cmd);

355 356 357 358
#define MWL8K_CMDNAME(x)	case MWL8K_CMD_##x: do {\
					snprintf(buf, bufsize, "%s", #x);\
					return buf;\
					} while (0)
359
	switch (command & ~0x8000) {
360 361
		MWL8K_CMDNAME(CODE_DNLD);
		MWL8K_CMDNAME(GET_HW_SPEC);
362
		MWL8K_CMDNAME(SET_HW_SPEC);
363 364 365 366
		MWL8K_CMDNAME(MAC_MULTICAST_ADR);
		MWL8K_CMDNAME(GET_STAT);
		MWL8K_CMDNAME(RADIO_CONTROL);
		MWL8K_CMDNAME(RF_TX_POWER);
367
		MWL8K_CMDNAME(TX_POWER);
368
		MWL8K_CMDNAME(RF_ANTENNA);
369
		MWL8K_CMDNAME(SET_BEACON);
370 371 372
		MWL8K_CMDNAME(SET_PRE_SCAN);
		MWL8K_CMDNAME(SET_POST_SCAN);
		MWL8K_CMDNAME(SET_RF_CHANNEL);
373 374 375 376
		MWL8K_CMDNAME(SET_AID);
		MWL8K_CMDNAME(SET_RATE);
		MWL8K_CMDNAME(SET_FINALIZE_JOIN);
		MWL8K_CMDNAME(RTS_THRESHOLD);
377
		MWL8K_CMDNAME(SET_SLOT);
378 379
		MWL8K_CMDNAME(SET_EDCA_PARAMS);
		MWL8K_CMDNAME(SET_WMM_MODE);
380
		MWL8K_CMDNAME(MIMO_CONFIG);
381
		MWL8K_CMDNAME(USE_FIXED_RATE);
382
		MWL8K_CMDNAME(ENABLE_SNIFFER);
383
		MWL8K_CMDNAME(SET_MAC_ADDR);
384
		MWL8K_CMDNAME(SET_RATEADAPT_MODE);
385
		MWL8K_CMDNAME(BSS_START);
386
		MWL8K_CMDNAME(SET_NEW_STN);
387
		MWL8K_CMDNAME(UPDATE_STADB);
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406
	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 */
407
static void mwl8k_release_fw(const struct firmware **fw)
408 409 410 411 412 413 414 415 416
{
	if (*fw == NULL)
		return;
	release_firmware(*fw);
	*fw = NULL;
}

static void mwl8k_release_firmware(struct mwl8k_priv *priv)
{
417 418
	mwl8k_release_fw(&priv->fw_ucode);
	mwl8k_release_fw(&priv->fw_helper);
419 420
}

421 422 423 424 425 426 427 428 429
/* states for asynchronous f/w loading */
static void mwl8k_fw_state_machine(const struct firmware *fw, void *context);
enum {
	FW_STATE_INIT = 0,
	FW_STATE_LOADING_PREF,
	FW_STATE_LOADING_ALT,
	FW_STATE_ERROR,
};

430 431
/* Request fw image */
static int mwl8k_request_fw(struct mwl8k_priv *priv,
432
			    const char *fname, const struct firmware **fw,
433
			    bool nowait)
434 435 436 437 438
{
	/* release current image */
	if (*fw != NULL)
		mwl8k_release_fw(fw);

439 440 441 442 443
	if (nowait)
		return request_firmware_nowait(THIS_MODULE, 1, fname,
					       &priv->pdev->dev, GFP_KERNEL,
					       priv, mwl8k_fw_state_machine);
	else
444
		return request_firmware(fw, fname, &priv->pdev->dev);
445 446
}

447 448
static int mwl8k_request_firmware(struct mwl8k_priv *priv, char *fw_image,
				  bool nowait)
449
{
450
	struct mwl8k_device_info *di = priv->device_info;
451 452
	int rc;

453
	if (di->helper_image != NULL) {
454 455 456 457 458 459 460 461 462 463 464
		if (nowait)
			rc = mwl8k_request_fw(priv, di->helper_image,
					      &priv->fw_helper, true);
		else
			rc = mwl8k_request_fw(priv, di->helper_image,
					      &priv->fw_helper, false);
		if (rc)
			printk(KERN_ERR "%s: Error requesting helper fw %s\n",
			       pci_name(priv->pdev), di->helper_image);

		if (rc || nowait)
465
			return rc;
466 467
	}

468 469 470 471 472 473 474 475 476 477 478 479
	if (nowait) {
		/*
		 * if we get here, no helper image is needed.  Skip the
		 * FW_STATE_INIT state.
		 */
		priv->fw_state = FW_STATE_LOADING_PREF;
		rc = mwl8k_request_fw(priv, fw_image,
				      &priv->fw_ucode,
				      true);
	} else
		rc = mwl8k_request_fw(priv, fw_image,
				      &priv->fw_ucode, false);
480
	if (rc) {
481
		printk(KERN_ERR "%s: Error requesting firmware file %s\n",
482
		       pci_name(priv->pdev), fw_image);
483
		mwl8k_release_fw(&priv->fw_helper);
484 485 486 487 488 489 490 491 492
		return rc;
	}

	return 0;
}

struct mwl8k_cmd_pkt {
	__le16	code;
	__le16	length;
493 494
	__u8	seq_num;
	__u8	macid;
495 496
	__le16	result;
	char	payload[0];
497
} __packed;
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

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

530
		cond_resched();
531 532 533 534 535
		udelay(1);
	} while (--loops);

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

536
	return loops ? 0 : -ETIMEDOUT;
537 538 539 540 541 542 543 544 545 546 547 548 549 550 551
}

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;
552
	cmd->macid = 0;
553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639
	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;
}

640
static int mwl8k_load_firmware(struct ieee80211_hw *hw)
641
{
642
	struct mwl8k_priv *priv = hw->priv;
643
	const struct firmware *fw = priv->fw_ucode;
644 645 646 647
	int rc;
	int loops;

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

650 651 652 653 654
		if (helper == NULL) {
			printk(KERN_ERR "%s: helper image needed but none "
			       "given\n", pci_name(priv->pdev));
			return -EINVAL;
		}
655

656
		rc = mwl8k_load_fw_image(priv, helper->data, helper->size);
657 658
		if (rc) {
			printk(KERN_ERR "%s: unable to load firmware "
659
			       "helper image\n", pci_name(priv->pdev));
660 661
			return rc;
		}
662
		msleep(5);
663

664
		rc = mwl8k_feed_fw_image(priv, fw->data, fw->size);
665
	} else {
666
		rc = mwl8k_load_fw_image(priv, fw->data, fw->size);
667 668 669
	}

	if (rc) {
670 671
		printk(KERN_ERR "%s: unable to load firmware image\n",
		       pci_name(priv->pdev));
672 673 674
		return rc;
	}

675
	iowrite32(MWL8K_MODE_STA, priv->regs + MWL8K_HIU_GEN_PTR);
676

677
	loops = 500000;
678
	do {
679 680 681 682 683 684 685 686
		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;
687
			break;
688 689 690
		}

		cond_resched();
691 692 693 694 695 696 697 698 699 700 701
		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;
702
	char data[0];
703
} __packed;
704 705

/* Routines to add/remove DMA header from skb.  */
706
static inline void mwl8k_remove_dma_header(struct sk_buff *skb, __le16 qos)
707
{
708 709 710 711 712 713 714 715 716 717 718 719 720
	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);
		}
721
	}
722 723 724

	if (hdrlen != sizeof(*tr))
		skb_pull(skb, sizeof(*tr) - hdrlen);
725 726
}

727 728
static void
mwl8k_add_dma_header(struct sk_buff *skb, int tail_pad)
729 730
{
	struct ieee80211_hdr *wh;
731
	int hdrlen;
732
	int reqd_hdrlen;
733 734
	struct mwl8k_dma_data *tr;

735 736 737 738 739 740
	/*
	 * 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).
	 */
741
	wh = (struct ieee80211_hdr *)skb->data;
742

743
	hdrlen = ieee80211_hdrlen(wh->frame_control);
744 745 746 747
	reqd_hdrlen = sizeof(*tr);

	if (hdrlen != reqd_hdrlen)
		skb_push(skb, reqd_hdrlen - hdrlen);
748

749
	if (ieee80211_is_data_qos(wh->frame_control))
750
		hdrlen -= IEEE80211_QOS_CTL_LEN;
751 752 753 754

	tr = (struct mwl8k_dma_data *)skb->data;
	if (wh != &tr->wh)
		memmove(&tr->wh, wh, hdrlen);
755 756
	if (hdrlen != sizeof(tr->wh))
		memset(((void *)&tr->wh) + hdrlen, 0, sizeof(tr->wh) - hdrlen);
757 758 759 760 761 762

	/*
	 * 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.
	 */
763
	tr->fwlen = cpu_to_le16(skb->len - sizeof(*tr) + tail_pad);
764 765
}

766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808
static void mwl8k_encapsulate_tx_frame(struct sk_buff *skb)
{
	struct ieee80211_hdr *wh;
	struct ieee80211_tx_info *tx_info;
	struct ieee80211_key_conf *key_conf;
	int data_pad;

	wh = (struct ieee80211_hdr *)skb->data;

	tx_info = IEEE80211_SKB_CB(skb);

	key_conf = NULL;
	if (ieee80211_is_data(wh->frame_control))
		key_conf = tx_info->control.hw_key;

	/*
	 * Make sure the packet header is in the DMA header format (4-address
	 * without QoS), the necessary crypto padding between the header and the
	 * payload has already been provided by mac80211, but it doesn't add tail
	 * padding when HW crypto is enabled.
	 *
	 * We have the following trailer padding requirements:
	 * - WEP: 4 trailer bytes (ICV)
	 * - TKIP: 12 trailer bytes (8 MIC + 4 ICV)
	 * - CCMP: 8 trailer bytes (MIC)
	 */
	data_pad = 0;
	if (key_conf != NULL) {
		switch (key_conf->cipher) {
		case WLAN_CIPHER_SUITE_WEP40:
		case WLAN_CIPHER_SUITE_WEP104:
			data_pad = 4;
			break;
		case WLAN_CIPHER_SUITE_TKIP:
			data_pad = 12;
			break;
		case WLAN_CIPHER_SUITE_CCMP:
			data_pad = 8;
			break;
		}
	}
	mwl8k_add_dma_header(skb, data_pad);
}
809 810

/*
811
 * Packet reception for 88w8366 AP firmware.
812
 */
813
struct mwl8k_rxd_8366_ap {
814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
	__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;
829
} __packed;
830

831 832 833
#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)
834

835
#define MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST	0x80
836

837
static void mwl8k_rxd_8366_ap_init(void *_rxd, dma_addr_t next_dma_addr)
838
{
839
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
840 841

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
842
	rxd->rx_ctrl = MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST;
843 844
}

845
static void mwl8k_rxd_8366_ap_refill(void *_rxd, dma_addr_t addr, int len)
846
{
847
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
848 849 850 851 852 853 854 855

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

static int
856
mwl8k_rxd_8366_ap_process(void *_rxd, struct ieee80211_rx_status *status,
857
			  __le16 *qos, s8 *noise)
858
{
859
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
860

861
	if (!(rxd->rx_ctrl & MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST))
862 863 864 865 866 867
		return -1;
	rmb();

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

	status->signal = -rxd->rssi;
868
	*noise = -rxd->noise_floor;
869

870
	if (rxd->rate & MWL8K_8366_AP_RATE_INFO_MCS_FORMAT) {
871
		status->flag |= RX_FLAG_HT;
872
		if (rxd->rate & MWL8K_8366_AP_RATE_INFO_40MHZ)
873
			status->flag |= RX_FLAG_40MHZ;
874
		status->rate_idx = MWL8K_8366_AP_RATE_INFO_RATEID(rxd->rate);
875 876 877
	} else {
		int i;

878 879
		for (i = 0; i < ARRAY_SIZE(mwl8k_rates_24); i++) {
			if (mwl8k_rates_24[i].hw_value == rxd->rate) {
880 881 882 883 884 885
				status->rate_idx = i;
				break;
			}
		}
	}

886 887 888 889 890 891 892
	if (rxd->channel > 14) {
		status->band = IEEE80211_BAND_5GHZ;
		if (!(status->flag & RX_FLAG_HT))
			status->rate_idx -= 5;
	} else {
		status->band = IEEE80211_BAND_2GHZ;
	}
893 894
	status->freq = ieee80211_channel_to_frequency(rxd->channel);

895 896
	*qos = rxd->qos_control;

897 898 899
	return le16_to_cpu(rxd->pkt_len);
}

900 901 902 903 904
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,
905 906 907
};

/*
908
 * Packet reception for STA firmware.
909
 */
910
struct mwl8k_rxd_sta {
911 912 913 914
	__le16 pkt_len;
	__u8 link_quality;
	__u8 noise_level;
	__le32 pkt_phys_addr;
915
	__le32 next_rxd_phys_addr;
916 917 918 919 920 921 922 923 924
	__le16 qos_control;
	__le16 rate_info;
	__le32 pad0[4];
	__u8 rssi;
	__u8 channel;
	__le16 pad1;
	__u8 rx_ctrl;
	__u8 rx_status;
	__u8 pad2[2];
925
} __packed;
926

927 928 929 930 931 932
#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
933

934
#define MWL8K_STA_RX_CTRL_OWNED_BY_HOST		0x02
935

936
static void mwl8k_rxd_sta_init(void *_rxd, dma_addr_t next_dma_addr)
937
{
938
	struct mwl8k_rxd_sta *rxd = _rxd;
939 940

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
941
	rxd->rx_ctrl = MWL8K_STA_RX_CTRL_OWNED_BY_HOST;
942 943
}

944
static void mwl8k_rxd_sta_refill(void *_rxd, dma_addr_t addr, int len)
945
{
946
	struct mwl8k_rxd_sta *rxd = _rxd;
947 948 949 950 951 952 953 954

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

static int
955
mwl8k_rxd_sta_process(void *_rxd, struct ieee80211_rx_status *status,
956
		       __le16 *qos, s8 *noise)
957
{
958
	struct mwl8k_rxd_sta *rxd = _rxd;
959 960
	u16 rate_info;

961
	if (!(rxd->rx_ctrl & MWL8K_STA_RX_CTRL_OWNED_BY_HOST))
962 963 964 965 966 967 968 969
		return -1;
	rmb();

	rate_info = le16_to_cpu(rxd->rate_info);

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

	status->signal = -rxd->rssi;
970
	*noise = -rxd->noise_level;
971 972
	status->antenna = MWL8K_STA_RATE_INFO_ANTSELECT(rate_info);
	status->rate_idx = MWL8K_STA_RATE_INFO_RATEID(rate_info);
973

974
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTPRE)
975
		status->flag |= RX_FLAG_SHORTPRE;
976
	if (rate_info & MWL8K_STA_RATE_INFO_40MHZ)
977
		status->flag |= RX_FLAG_40MHZ;
978
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTGI)
979
		status->flag |= RX_FLAG_SHORT_GI;
980
	if (rate_info & MWL8K_STA_RATE_INFO_MCS_FORMAT)
981 982
		status->flag |= RX_FLAG_HT;

983 984 985 986 987 988 989
	if (rxd->channel > 14) {
		status->band = IEEE80211_BAND_5GHZ;
		if (!(status->flag & RX_FLAG_HT))
			status->rate_idx -= 5;
	} else {
		status->band = IEEE80211_BAND_2GHZ;
	}
990 991
	status->freq = ieee80211_channel_to_frequency(rxd->channel);

992 993
	*qos = rxd->qos_control;

994 995 996
	return le16_to_cpu(rxd->pkt_len);
}

997 998 999 1000 1001
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,
1002 1003 1004
};


1005 1006 1007 1008 1009 1010 1011 1012 1013 1014
#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;

1015 1016 1017
	rxq->rxd_count = 0;
	rxq->head = 0;
	rxq->tail = 0;
1018

1019
	size = MWL8K_RX_DESCS * priv->rxd_ops->rxd_size;
1020

1021 1022
	rxq->rxd = pci_alloc_consistent(priv->pdev, size, &rxq->rxd_dma);
	if (rxq->rxd == NULL) {
1023
		wiphy_err(hw->wiphy, "failed to alloc RX descriptors\n");
1024 1025
		return -ENOMEM;
	}
1026
	memset(rxq->rxd, 0, size);
1027

1028 1029
	rxq->buf = kmalloc(MWL8K_RX_DESCS * sizeof(*rxq->buf), GFP_KERNEL);
	if (rxq->buf == NULL) {
1030
		wiphy_err(hw->wiphy, "failed to alloc RX skbuff list\n");
1031
		pci_free_consistent(priv->pdev, size, rxq->rxd, rxq->rxd_dma);
1032 1033
		return -ENOMEM;
	}
1034
	memset(rxq->buf, 0, MWL8K_RX_DESCS * sizeof(*rxq->buf));
1035 1036

	for (i = 0; i < MWL8K_RX_DESCS; i++) {
1037 1038
		int desc_size;
		void *rxd;
1039
		int nexti;
1040 1041 1042 1043
		dma_addr_t next_dma_addr;

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

1045 1046 1047 1048
		nexti = i + 1;
		if (nexti == MWL8K_RX_DESCS)
			nexti = 0;
		next_dma_addr = rxq->rxd_dma + (nexti * desc_size);
1049

1050
		priv->rxd_ops->rxd_init(rxd, next_dma_addr);
1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
	}

	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;
1063
	while (rxq->rxd_count < MWL8K_RX_DESCS && limit--) {
1064
		struct sk_buff *skb;
1065
		dma_addr_t addr;
1066
		int rx;
1067
		void *rxd;
1068 1069 1070 1071 1072

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

1073 1074
		addr = pci_map_single(priv->pdev, skb->data,
				      MWL8K_RX_MAXSZ, DMA_FROM_DEVICE);
1075

1076 1077 1078 1079
		rxq->rxd_count++;
		rx = rxq->tail++;
		if (rxq->tail == MWL8K_RX_DESCS)
			rxq->tail = 0;
1080
		rxq->buf[rx].skb = skb;
1081
		dma_unmap_addr_set(&rxq->buf[rx], dma, addr);
1082 1083 1084

		rxd = rxq->rxd + (rx * priv->rxd_ops->rxd_size);
		priv->rxd_ops->rxd_refill(rxd, addr, MWL8K_RX_MAXSZ);
1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099

		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++) {
1100 1101
		if (rxq->buf[i].skb != NULL) {
			pci_unmap_single(priv->pdev,
1102
					 dma_unmap_addr(&rxq->buf[i], dma),
1103
					 MWL8K_RX_MAXSZ, PCI_DMA_FROMDEVICE);
1104
			dma_unmap_addr_set(&rxq->buf[i], dma, 0);
1105 1106 1107

			kfree_skb(rxq->buf[i].skb);
			rxq->buf[i].skb = NULL;
1108 1109 1110
		}
	}

1111 1112
	kfree(rxq->buf);
	rxq->buf = NULL;
1113 1114

	pci_free_consistent(priv->pdev,
1115
			    MWL8K_RX_DESCS * priv->rxd_ops->rxd_size,
1116 1117
			    rxq->rxd, rxq->rxd_dma);
	rxq->rxd = NULL;
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132
}


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

1133 1134
static inline void mwl8k_save_beacon(struct ieee80211_hw *hw,
				     struct sk_buff *skb)
1135
{
1136 1137
	struct mwl8k_priv *priv = hw->priv;

1138
	priv->capture_beacon = false;
1139
	memset(priv->capture_bssid, 0, ETH_ALEN);
1140 1141 1142 1143 1144 1145 1146 1147

	/*
	 * 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)
1148
		ieee80211_queue_work(hw, &priv->finalize_join_worker);
1149 1150 1151 1152 1153 1154 1155 1156 1157
}

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;
1158
	while (rxq->rxd_count && limit--) {
1159
		struct sk_buff *skb;
1160 1161
		void *rxd;
		int pkt_len;
1162
		struct ieee80211_rx_status status;
1163
		__le16 qos;
1164

1165
		skb = rxq->buf[rxq->head].skb;
1166 1167
		if (skb == NULL)
			break;
1168 1169 1170

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

1171 1172
		pkt_len = priv->rxd_ops->rxd_process(rxd, &status, &qos,
							&priv->noise);
1173 1174 1175
		if (pkt_len < 0)
			break;

1176 1177 1178
		rxq->buf[rxq->head].skb = NULL;

		pci_unmap_single(priv->pdev,
1179
				 dma_unmap_addr(&rxq->buf[rxq->head], dma),
1180
				 MWL8K_RX_MAXSZ, PCI_DMA_FROMDEVICE);
1181
		dma_unmap_addr_set(&rxq->buf[rxq->head], dma, 0);
1182

1183 1184 1185 1186
		rxq->head++;
		if (rxq->head == MWL8K_RX_DESCS)
			rxq->head = 0;

1187
		rxq->rxd_count--;
1188

1189
		skb_put(skb, pkt_len);
1190
		mwl8k_remove_dma_header(skb, qos);
1191 1192

		/*
1193 1194 1195
		 * 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.
1196
		 */
1197
		if (mwl8k_capture_bssid(priv, (void *)skb->data))
1198
			mwl8k_save_beacon(hw, skb);
1199

1200 1201
		memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
		ieee80211_rx_irqsafe(hw, skb);
1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219

		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

1220 1221 1222 1223 1224 1225
#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

1226 1227 1228 1229 1230 1231 1232
struct mwl8k_tx_desc {
	__le32 status;
	__u8 data_rate;
	__u8 tx_priority;
	__le16 qos_control;
	__le32 pkt_phys_addr;
	__le16 pkt_len;
1233
	__u8 dest_MAC_addr[ETH_ALEN];
1234
	__le32 next_txd_phys_addr;
1235 1236 1237
	__le32 reserved;
	__le16 rate_info;
	__u8 peer_id;
1238
	__u8 tx_frag_cnt;
1239
} __packed;
1240 1241 1242 1243 1244 1245 1246 1247 1248 1249

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

1250
	txq->len = 0;
1251 1252
	txq->head = 0;
	txq->tail = 0;
1253 1254 1255

	size = MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc);

1256 1257
	txq->txd = pci_alloc_consistent(priv->pdev, size, &txq->txd_dma);
	if (txq->txd == NULL) {
1258
		wiphy_err(hw->wiphy, "failed to alloc TX descriptors\n");
1259 1260
		return -ENOMEM;
	}
1261
	memset(txq->txd, 0, size);
1262

1263 1264
	txq->skb = kmalloc(MWL8K_TX_DESCS * sizeof(*txq->skb), GFP_KERNEL);
	if (txq->skb == NULL) {
1265
		wiphy_err(hw->wiphy, "failed to alloc TX skbuff list\n");
1266
		pci_free_consistent(priv->pdev, size, txq->txd, txq->txd_dma);
1267 1268
		return -ENOMEM;
	}
1269
	memset(txq->skb, 0, MWL8K_TX_DESCS * sizeof(*txq->skb));
1270 1271 1272 1273 1274

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

1275
		tx_desc = txq->txd + i;
1276 1277 1278
		nexti = (i + 1) % MWL8K_TX_DESCS;

		tx_desc->status = 0;
1279 1280
		tx_desc->next_txd_phys_addr =
			cpu_to_le32(txq->txd_dma + nexti * sizeof(*tx_desc));
1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
	}

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

1295
static void mwl8k_dump_tx_rings(struct ieee80211_hw *hw)
1296
{
1297 1298 1299 1300 1301 1302 1303 1304 1305 1306
	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;

1307
		for (desc = 0; desc < MWL8K_TX_DESCS; desc++) {
1308 1309
			struct mwl8k_tx_desc *tx_desc = txq->txd + desc;
			u32 status;
1310

1311
			status = le32_to_cpu(tx_desc->status);
1312
			if (status & MWL8K_TXD_STATUS_FW_OWNED)
1313
				fw_owned++;
1314
			else
1315
				drv_owned++;
1316 1317

			if (tx_desc->pkt_len == 0)
1318
				unused++;
1319 1320
		}

1321 1322 1323 1324 1325 1326
		wiphy_err(hw->wiphy,
			  "txq[%d] len=%d head=%d tail=%d "
			  "fw_owned=%d drv_owned=%d unused=%d\n",
			  i,
			  txq->len, txq->head, txq->tail,
			  fw_owned, drv_owned, unused);
1327
	}
1328 1329
}

1330
/*
1331
 * Must be called with priv->fw_mutex held and tx queues stopped.
1332
 */
1333
#define MWL8K_TX_WAIT_TIMEOUT_MS	5000
1334

1335
static int mwl8k_tx_wait_empty(struct ieee80211_hw *hw)
1336 1337
{
	struct mwl8k_priv *priv = hw->priv;
1338
	DECLARE_COMPLETION_ONSTACK(tx_wait);
1339 1340
	int retry;
	int rc;
1341 1342 1343

	might_sleep();

1344 1345 1346 1347 1348 1349 1350 1351 1352 1353
	/*
	 * 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;

1354
	spin_lock_bh(&priv->tx_lock);
1355 1356 1357 1358
	priv->tx_wait = &tx_wait;
	while (!rc) {
		int oldcount;
		unsigned long timeout;
1359

1360
		oldcount = priv->pending_tx_pkts;
1361

1362
		spin_unlock_bh(&priv->tx_lock);
1363
		timeout = wait_for_completion_timeout(&tx_wait,
1364
			    msecs_to_jiffies(MWL8K_TX_WAIT_TIMEOUT_MS));
1365
		spin_lock_bh(&priv->tx_lock);
1366 1367 1368 1369

		if (timeout) {
			WARN_ON(priv->pending_tx_pkts);
			if (retry) {
1370
				wiphy_notice(hw->wiphy, "tx rings drained\n");
1371 1372 1373 1374 1375
			}
			break;
		}

		if (priv->pending_tx_pkts < oldcount) {
1376 1377 1378
			wiphy_notice(hw->wiphy,
				     "waiting for tx rings to drain (%d -> %d pkts)\n",
				     oldcount, priv->pending_tx_pkts);
1379 1380 1381 1382
			retry = 1;
			continue;
		}

1383 1384
		priv->tx_wait = NULL;

1385 1386
		wiphy_err(hw->wiphy, "tx rings stuck for %d ms\n",
			  MWL8K_TX_WAIT_TIMEOUT_MS);
1387 1388 1389
		mwl8k_dump_tx_rings(hw);

		rc = -ETIMEDOUT;
1390
	}
1391
	spin_unlock_bh(&priv->tx_lock);
1392

1393
	return rc;
1394 1395
}

1396 1397 1398 1399
#define MWL8K_TXD_SUCCESS(status)				\
	((status) & (MWL8K_TXD_STATUS_OK |			\
		     MWL8K_TXD_STATUS_OK_RETRY |		\
		     MWL8K_TXD_STATUS_OK_MORE_RETRY))
1400

1401 1402
static int
mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int limit, int force)
1403 1404 1405
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_tx_queue *txq = priv->txq + index;
1406
	int processed;
1407

1408
	processed = 0;
1409
	while (txq->len > 0 && limit--) {
1410 1411 1412
		int tx;
		struct mwl8k_tx_desc *tx_desc;
		unsigned long addr;
1413
		int size;
1414 1415 1416 1417
		struct sk_buff *skb;
		struct ieee80211_tx_info *info;
		u32 status;

1418 1419
		tx = txq->head;
		tx_desc = txq->txd + tx;
1420 1421 1422 1423 1424 1425 1426 1427 1428 1429

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

1430
		txq->head = (tx + 1) % MWL8K_TX_DESCS;
1431 1432
		BUG_ON(txq->len == 0);
		txq->len--;
1433 1434 1435
		priv->pending_tx_pkts--;

		addr = le32_to_cpu(tx_desc->pkt_phys_addr);
1436
		size = le16_to_cpu(tx_desc->pkt_len);
1437 1438
		skb = txq->skb[tx];
		txq->skb[tx] = NULL;
1439 1440 1441 1442

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

1443
		mwl8k_remove_dma_header(skb, tx_desc->qos_control);
1444 1445 1446 1447 1448 1449 1450

		/* 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);
1451
		if (MWL8K_TXD_SUCCESS(status))
1452 1453 1454 1455
			info->flags |= IEEE80211_TX_STAT_ACK;

		ieee80211_tx_status_irqsafe(hw, skb);

1456
		processed++;
1457 1458
	}

1459
	if (processed && priv->radio_on && !mutex_is_locked(&priv->fw_mutex))
1460
		ieee80211_wake_queue(hw, index);
1461 1462

	return processed;
1463 1464 1465 1466 1467 1468 1469 1470
}

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

1471
	mwl8k_txq_reclaim(hw, index, INT_MAX, 1);
1472

1473 1474
	kfree(txq->skb);
	txq->skb = NULL;
1475 1476 1477

	pci_free_consistent(priv->pdev,
			    MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc),
1478 1479
			    txq->txd, txq->txd_dma);
	txq->txd = NULL;
1480 1481 1482 1483 1484 1485 1486
}

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;
1487
	struct mwl8k_vif *mwl8k_vif;
1488 1489 1490 1491
	struct ieee80211_hdr *wh;
	struct mwl8k_tx_queue *txq;
	struct mwl8k_tx_desc *tx;
	dma_addr_t dma;
1492 1493 1494
	u32 txstatus;
	u8 txdatarate;
	u16 qos;
1495

1496 1497 1498 1499 1500
	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;
1501

1502
	mwl8k_encapsulate_tx_frame(skb);
1503
	wh = &((struct mwl8k_dma_data *)skb->data)->wh;
1504 1505 1506 1507 1508 1509

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

	if (tx_info->flags & IEEE80211_TX_CTL_ASSIGN_SEQ) {
		wh->seq_ctrl &= cpu_to_le16(IEEE80211_SCTL_FRAG);
1510 1511
		wh->seq_ctrl |= cpu_to_le16(mwl8k_vif->seqno);
		mwl8k_vif->seqno += 0x10;
1512 1513
	}

1514 1515 1516 1517 1518 1519
	/* 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;
1520
		qos |= MWL8K_QOS_QLEN_UNSPEC | MWL8K_QOS_EOSP;
1521 1522 1523 1524 1525
	} else if (ieee80211_is_data(wh->frame_control)) {
		txdatarate = 1;
		if (is_multicast_ether_addr(wh->addr1))
			txstatus |= MWL8K_TXD_STATUS_MULTICAST_TX;

1526
		qos &= ~MWL8K_QOS_ACK_POLICY_MASK;
1527
		if (tx_info->flags & IEEE80211_TX_CTL_AMPDU)
1528
			qos |= MWL8K_QOS_ACK_POLICY_BLOCKACK;
1529
		else
1530
			qos |= MWL8K_QOS_ACK_POLICY_NORMAL;
1531
	}
1532 1533 1534 1535 1536

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

	if (pci_dma_mapping_error(priv->pdev, dma)) {
1537 1538
		wiphy_debug(hw->wiphy,
			    "failed to dma map skb, dropping TX frame.\n");
1539
		dev_kfree_skb(skb);
1540 1541 1542
		return NETDEV_TX_OK;
	}

1543
	spin_lock_bh(&priv->tx_lock);
1544

1545
	txq = priv->txq + index;
1546

1547 1548
	BUG_ON(txq->skb[txq->tail] != NULL);
	txq->skb[txq->tail] = skb;
1549

1550
	tx = txq->txd + txq->tail;
1551 1552
	tx->data_rate = txdatarate;
	tx->tx_priority = index;
1553 1554 1555
	tx->qos_control = cpu_to_le16(qos);
	tx->pkt_phys_addr = cpu_to_le32(dma);
	tx->pkt_len = cpu_to_le16(skb->len);
1556
	tx->rate_info = 0;
1557 1558 1559 1560
	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;
1561
	wmb();
1562 1563
	tx->status = cpu_to_le32(MWL8K_TXD_STATUS_FW_OWNED | txstatus);

1564
	txq->len++;
1565 1566
	priv->pending_tx_pkts++;

1567 1568 1569
	txq->tail++;
	if (txq->tail == MWL8K_TX_DESCS)
		txq->tail = 0;
1570

1571
	if (txq->head == txq->tail)
1572 1573
		ieee80211_stop_queue(hw, index);

1574
	mwl8k_tx_start(priv);
1575 1576 1577 1578 1579 1580 1581

	spin_unlock_bh(&priv->tx_lock);

	return NETDEV_TX_OK;
}


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


1636 1637 1638 1639
/*
 * Command processing.
 */

1640 1641
/* Timeout firmware commands after 10s */
#define MWL8K_CMD_TIMEOUT_MS	10000
1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653

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

1654
	cmd->result = (__force __le16) 0xffff;
1655 1656 1657 1658 1659 1660
	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;

1661
	rc = mwl8k_fw_lock(hw);
1662 1663 1664
	if (rc) {
		pci_unmap_single(priv->pdev, dma_addr, dma_size,
						PCI_DMA_BIDIRECTIONAL);
1665
		return rc;
1666
	}
1667 1668 1669 1670 1671 1672 1673 1674 1675 1676 1677

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

1678 1679 1680 1681
	priv->hostcmd_wait = NULL;

	mwl8k_fw_unlock(hw);

1682 1683 1684
	pci_unmap_single(priv->pdev, dma_addr, dma_size,
					PCI_DMA_BIDIRECTIONAL);

1685
	if (!timeout) {
1686
		wiphy_err(hw->wiphy, "Command %s timeout after %u ms\n",
1687 1688
			  mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
			  MWL8K_CMD_TIMEOUT_MS);
1689 1690
		rc = -ETIMEDOUT;
	} else {
1691 1692 1693 1694
		int ms;

		ms = MWL8K_CMD_TIMEOUT_MS - jiffies_to_msecs(timeout);

1695
		rc = cmd->result ? -EINVAL : 0;
1696
		if (rc)
1697
			wiphy_err(hw->wiphy, "Command %s error 0x%x\n",
1698 1699
				  mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
				  le16_to_cpu(cmd->result));
1700
		else if (ms > 2000)
1701
			wiphy_notice(hw->wiphy, "Command %s took %d ms\n",
1702 1703 1704
				     mwl8k_cmd_name(cmd->code,
						    buf, sizeof(buf)),
				     ms);
1705 1706 1707 1708 1709
	}

	return rc;
}

1710 1711 1712 1713 1714 1715 1716 1717 1718
static int mwl8k_post_pervif_cmd(struct ieee80211_hw *hw,
				 struct ieee80211_vif *vif,
				 struct mwl8k_cmd_pkt *cmd)
{
	if (vif != NULL)
		cmd->macid = MWL8K_VIF(vif)->macid;
	return mwl8k_post_cmd(hw, cmd);
}

1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
/*
 * Setup code shared between STA and AP firmware images.
 */
static void mwl8k_setup_2ghz_band(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;

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

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

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

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

1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759
static void mwl8k_setup_5ghz_band(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;

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

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

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

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

1760
/*
1761
 * CMD_GET_HW_SPEC (STA version).
1762
 */
1763
struct mwl8k_cmd_get_hw_spec_sta {
1764 1765 1766 1767
	struct mwl8k_cmd_pkt header;
	__u8 hw_rev;
	__u8 host_interface;
	__le16 num_mcaddrs;
1768
	__u8 perm_addr[ETH_ALEN];
1769 1770 1771 1772 1773 1774 1775 1776 1777 1778
	__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;
1779
	__le32 total_rxd;
1780
} __packed;
1781

1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793
#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
1794 1795 1796
#define MWL8K_CAP_BAND_MASK		0x00000007
#define MWL8K_CAP_5GHZ			0x00000004
#define MWL8K_CAP_2GHZ4			0x00000001
1797

1798 1799 1800
static void
mwl8k_set_ht_caps(struct ieee80211_hw *hw,
		  struct ieee80211_supported_band *band, u32 cap)
1801 1802 1803 1804
{
	int rx_streams;
	int tx_streams;

1805
	band->ht_cap.ht_supported = 1;
1806 1807

	if (cap & MWL8K_CAP_MAX_AMSDU)
1808
		band->ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
1809
	if (cap & MWL8K_CAP_GREENFIELD)
1810
		band->ht_cap.cap |= IEEE80211_HT_CAP_GRN_FLD;
1811 1812
	if (cap & MWL8K_CAP_AMPDU) {
		hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
1813 1814
		band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
		band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
1815 1816
	}
	if (cap & MWL8K_CAP_RX_STBC)
1817
		band->ht_cap.cap |= IEEE80211_HT_CAP_RX_STBC;
1818
	if (cap & MWL8K_CAP_TX_STBC)
1819
		band->ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
1820
	if (cap & MWL8K_CAP_SHORTGI_40MHZ)
1821
		band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
1822
	if (cap & MWL8K_CAP_SHORTGI_20MHZ)
1823
		band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
1824
	if (cap & MWL8K_CAP_DELAY_BA)
1825
		band->ht_cap.cap |= IEEE80211_HT_CAP_DELAY_BA;
1826
	if (cap & MWL8K_CAP_40MHZ)
1827
		band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
1828 1829 1830 1831

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

1832
	band->ht_cap.mcs.rx_mask[0] = 0xff;
1833
	if (rx_streams >= 2)
1834
		band->ht_cap.mcs.rx_mask[1] = 0xff;
1835
	if (rx_streams >= 3)
1836 1837 1838
		band->ht_cap.mcs.rx_mask[2] = 0xff;
	band->ht_cap.mcs.rx_mask[4] = 0x01;
	band->ht_cap.mcs.tx_params = IEEE80211_HT_MCS_TX_DEFINED;
1839 1840

	if (rx_streams != tx_streams) {
1841 1842
		band->ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
		band->ht_cap.mcs.tx_params |= (tx_streams - 1) <<
1843 1844 1845 1846
				IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
	}
}

1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864
static void
mwl8k_set_caps(struct ieee80211_hw *hw, u32 caps)
{
	struct mwl8k_priv *priv = hw->priv;

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

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

1865
static int mwl8k_cmd_get_hw_spec_sta(struct ieee80211_hw *hw)
1866 1867
{
	struct mwl8k_priv *priv = hw->priv;
1868
	struct mwl8k_cmd_get_hw_spec_sta *cmd;
1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880
	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);
1881
	cmd->rx_queue_ptr = cpu_to_le32(priv->rxq[0].rxd_dma);
1882
	cmd->num_tx_queues = cpu_to_le32(MWL8K_TX_QUEUES);
1883
	for (i = 0; i < MWL8K_TX_QUEUES; i++)
1884
		cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[i].txd_dma);
1885
	cmd->num_tx_desc_per_queue = cpu_to_le32(MWL8K_TX_DESCS);
1886
	cmd->total_rxd = cpu_to_le32(MWL8K_RX_DESCS);
1887 1888 1889 1890 1891 1892

	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);
1893
		priv->fw_rev = le32_to_cpu(cmd->fw_rev);
1894
		priv->hw_rev = cmd->hw_rev;
1895
		mwl8k_set_caps(hw, le32_to_cpu(cmd->caps));
1896 1897
		priv->ap_macids_supported = 0x00000000;
		priv->sta_macids_supported = 0x00000001;
1898 1899 1900 1901 1902 1903
	}

	kfree(cmd);
	return rc;
}

1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923
/*
 * 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;
1924
	__le32 fw_api_version;
1925
} __packed;
1926 1927 1928 1929 1930 1931

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;
1932
	u32 api_version;
1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948

	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;

1949 1950 1951 1952 1953 1954 1955 1956 1957 1958
		api_version = le32_to_cpu(cmd->fw_api_version);
		if (priv->device_info->fw_api_ap != api_version) {
			printk(KERN_ERR "%s: Unsupported fw API version for %s."
			       "  Expected %d got %d.\n", MWL8K_NAME,
			       priv->device_info->part_name,
			       priv->device_info->fw_api_ap,
			       api_version);
			rc = -EINVAL;
			goto done;
		}
1959 1960 1961 1962
		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;
1963
		mwl8k_setup_2ghz_band(hw);
1964 1965
		priv->ap_macids_supported = 0x000000ff;
		priv->sta_macids_supported = 0x00000000;
1966 1967

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

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

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

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

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

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

1986
done:
1987 1988 1989 1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009
	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;
2010
} __packed;
2011

2012 2013 2014
#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
2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034

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);
2035 2036 2037
	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);
2038 2039 2040 2041 2042 2043 2044 2045 2046
	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;
}

2047 2048 2049 2050 2051 2052 2053
/*
 * CMD_MAC_MULTICAST_ADR.
 */
struct mwl8k_cmd_mac_multicast_adr {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 numaddr;
2054
	__u8 addr[0][ETH_ALEN];
2055 2056
};

2057 2058 2059 2060
#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
2061

2062
static struct mwl8k_cmd_pkt *
2063
__mwl8k_cmd_mac_multicast_adr(struct ieee80211_hw *hw, int allmulti,
2064
			      struct netdev_hw_addr_list *mc_list)
2065
{
2066
	struct mwl8k_priv *priv = hw->priv;
2067
	struct mwl8k_cmd_mac_multicast_adr *cmd;
2068
	int size;
2069 2070 2071 2072
	int mc_count = 0;

	if (mc_list)
		mc_count = netdev_hw_addr_list_count(mc_list);
2073

2074
	if (allmulti || mc_count > priv->num_mcaddrs) {
2075 2076 2077
		allmulti = 1;
		mc_count = 0;
	}
2078 2079

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

2081
	cmd = kzalloc(size, GFP_ATOMIC);
2082
	if (cmd == NULL)
2083
		return NULL;
2084 2085 2086

	cmd->header.code = cpu_to_le16(MWL8K_CMD_MAC_MULTICAST_ADR);
	cmd->header.length = cpu_to_le16(size);
2087 2088 2089 2090 2091 2092
	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) {
2093 2094
		struct netdev_hw_addr *ha;
		int i = 0;
2095 2096 2097

		cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_MULTICAST);
		cmd->numaddr = cpu_to_le16(mc_count);
2098 2099
		netdev_hw_addr_list_for_each(ha, mc_list) {
			memcpy(cmd->addr[i], ha->addr, ETH_ALEN);
2100 2101 2102
		}
	}

2103
	return &cmd->header;
2104 2105 2106
}

/*
2107
 * CMD_GET_STAT.
2108
 */
2109
struct mwl8k_cmd_get_stat {
2110 2111
	struct mwl8k_cmd_pkt header;
	__le32 stats[64];
2112
} __packed;
2113 2114 2115 2116 2117 2118

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

2119 2120
static int mwl8k_cmd_get_stat(struct ieee80211_hw *hw,
			      struct ieee80211_low_level_stats *stats)
2121
{
2122
	struct mwl8k_cmd_get_stat *cmd;
2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148
	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;
}

/*
2149
 * CMD_RADIO_CONTROL.
2150
 */
2151
struct mwl8k_cmd_radio_control {
2152 2153 2154 2155
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 control;
	__le16 radio_on;
2156
} __packed;
2157

2158
static int
2159
mwl8k_cmd_radio_control(struct ieee80211_hw *hw, bool enable, bool force)
2160 2161
{
	struct mwl8k_priv *priv = hw->priv;
2162
	struct mwl8k_cmd_radio_control *cmd;
2163 2164
	int rc;

2165
	if (enable == priv->radio_on && !force)
2166 2167 2168 2169 2170 2171 2172 2173 2174
		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);
2175
	cmd->control = cpu_to_le16(priv->radio_short_preamble ? 3 : 1);
2176 2177 2178 2179 2180 2181
	cmd->radio_on = cpu_to_le16(enable ? 0x0001 : 0x0000);

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

	if (!rc)
2182
		priv->radio_on = enable;
2183 2184 2185 2186

	return rc;
}

2187
static int mwl8k_cmd_radio_disable(struct ieee80211_hw *hw)
2188
{
2189
	return mwl8k_cmd_radio_control(hw, 0, 0);
2190 2191
}

2192
static int mwl8k_cmd_radio_enable(struct ieee80211_hw *hw)
2193
{
2194
	return mwl8k_cmd_radio_control(hw, 1, 0);
2195 2196
}

2197 2198 2199
static int
mwl8k_set_radio_preamble(struct ieee80211_hw *hw, bool short_preamble)
{
2200
	struct mwl8k_priv *priv = hw->priv;
2201

2202
	priv->radio_short_preamble = short_preamble;
2203

2204
	return mwl8k_cmd_radio_control(hw, 1, 1);
2205 2206 2207
}

/*
2208
 * CMD_RF_TX_POWER.
2209
 */
2210
#define MWL8K_RF_TX_POWER_LEVEL_TOTAL	8
2211

2212
struct mwl8k_cmd_rf_tx_power {
2213 2214 2215 2216 2217
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 support_level;
	__le16 current_level;
	__le16 reserved;
2218
	__le16 power_level_list[MWL8K_RF_TX_POWER_LEVEL_TOTAL];
2219
} __packed;
2220

2221
static int mwl8k_cmd_rf_tx_power(struct ieee80211_hw *hw, int dBm)
2222
{
2223
	struct mwl8k_cmd_rf_tx_power *cmd;
2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240
	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;
}

2241 2242 2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299
/*
 * CMD_TX_POWER.
 */
#define MWL8K_TX_POWER_LEVEL_TOTAL      12

struct mwl8k_cmd_tx_power {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 band;
	__le16 channel;
	__le16 bw;
	__le16 sub_ch;
	__le16 power_level_list[MWL8K_TX_POWER_LEVEL_TOTAL];
} __attribute__((packed));

static int mwl8k_cmd_tx_power(struct ieee80211_hw *hw,
				     struct ieee80211_conf *conf,
				     unsigned short pwr)
{
	struct ieee80211_channel *channel = conf->channel;
	struct mwl8k_cmd_tx_power *cmd;
	int rc;
	int i;

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

	cmd->header.code = cpu_to_le16(MWL8K_CMD_TX_POWER);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->action = cpu_to_le16(MWL8K_CMD_SET_LIST);

	if (channel->band == IEEE80211_BAND_2GHZ)
		cmd->band = cpu_to_le16(0x1);
	else if (channel->band == IEEE80211_BAND_5GHZ)
		cmd->band = cpu_to_le16(0x4);

	cmd->channel = channel->hw_value;

	if (conf->channel_type == NL80211_CHAN_NO_HT ||
	    conf->channel_type == NL80211_CHAN_HT20) {
		cmd->bw = cpu_to_le16(0x2);
	} else {
		cmd->bw = cpu_to_le16(0x4);
		if (conf->channel_type == NL80211_CHAN_HT40MINUS)
			cmd->sub_ch = cpu_to_le16(0x3);
		else if (conf->channel_type == NL80211_CHAN_HT40PLUS)
			cmd->sub_ch = cpu_to_le16(0x1);
	}

	for (i = 0; i < MWL8K_TX_POWER_LEVEL_TOTAL; i++)
		cmd->power_level_list[i] = cpu_to_le16(pwr);

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

	return rc;
}

2300 2301 2302 2303 2304 2305 2306
/*
 * CMD_RF_ANTENNA.
 */
struct mwl8k_cmd_rf_antenna {
	struct mwl8k_cmd_pkt header;
	__le16 antenna;
	__le16 mode;
2307
} __packed;
2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332

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

2333 2334 2335 2336 2337 2338 2339 2340 2341
/*
 * CMD_SET_BEACON.
 */
struct mwl8k_cmd_set_beacon {
	struct mwl8k_cmd_pkt header;
	__le16 beacon_len;
	__u8 beacon[0];
};

2342 2343
static int mwl8k_cmd_set_beacon(struct ieee80211_hw *hw,
				struct ieee80211_vif *vif, u8 *beacon, int len)
2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356
{
	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);

2357
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2358 2359 2360 2361 2362
	kfree(cmd);

	return rc;
}

2363 2364 2365 2366 2367
/*
 * CMD_SET_PRE_SCAN.
 */
struct mwl8k_cmd_set_pre_scan {
	struct mwl8k_cmd_pkt header;
2368
} __packed;
2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393

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;
2394
	__u8 bssid[ETH_ALEN];
2395
} __packed;
2396 2397

static int
2398
mwl8k_cmd_set_post_scan(struct ieee80211_hw *hw, const __u8 *mac)
2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409
{
	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;
2410
	memcpy(cmd->bssid, mac, ETH_ALEN);
2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425

	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;
2426
} __packed;
2427 2428

static int mwl8k_cmd_set_rf_channel(struct ieee80211_hw *hw,
2429
				    struct ieee80211_conf *conf)
2430
{
2431
	struct ieee80211_channel *channel = conf->channel;
2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442
	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;
2443

2444
	if (channel->band == IEEE80211_BAND_2GHZ)
2445
		cmd->channel_flags |= cpu_to_le32(0x00000001);
2446 2447
	else if (channel->band == IEEE80211_BAND_5GHZ)
		cmd->channel_flags |= cpu_to_le32(0x00000004);
2448 2449 2450 2451 2452 2453 2454 2455

	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);
2456 2457 2458 2459 2460 2461 2462 2463

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

	return rc;
}

/*
2464
 * CMD_SET_AID.
2465
 */
2466 2467 2468 2469
#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
2470

2471 2472 2473
struct mwl8k_cmd_update_set_aid {
	struct	mwl8k_cmd_pkt header;
	__le16	aid;
2474

2475 2476 2477 2478
	 /* AP's MAC address (BSSID) */
	__u8	bssid[ETH_ALEN];
	__le16	protection_mode;
	__u8	supp_rates[14];
2479
} __packed;
2480

2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492
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))
2493
			rates[j++] = mwl8k_rates_24[i].hw_value;
2494 2495 2496
	}
}

2497
static int
2498 2499
mwl8k_cmd_set_aid(struct ieee80211_hw *hw,
		  struct ieee80211_vif *vif, u32 legacy_rate_mask)
2500
{
2501 2502
	struct mwl8k_cmd_update_set_aid *cmd;
	u16 prot_mode;
2503 2504 2505 2506 2507 2508
	int rc;

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

2509
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_AID);
2510
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2511
	cmd->aid = cpu_to_le16(vif->bss_conf.aid);
2512
	memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN);
2513

2514
	if (vif->bss_conf.use_cts_prot) {
2515 2516
		prot_mode = MWL8K_FRAME_PROT_11G;
	} else {
2517
		switch (vif->bss_conf.ht_operation_mode &
2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530
			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);
2531

2532
	legacy_rate_mask_to_array(cmd->supp_rates, legacy_rate_mask);
2533 2534 2535 2536 2537 2538 2539

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

	return rc;
}

2540
/*
2541
 * CMD_SET_RATE.
2542
 */
2543 2544 2545 2546 2547 2548 2549
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];
2550
} __packed;
2551

2552
static int
2553
mwl8k_cmd_set_rate(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2554
		   u32 legacy_rate_mask, u8 *mcs_rates)
2555
{
2556
	struct mwl8k_cmd_set_rate *cmd;
2557 2558 2559 2560 2561 2562
	int rc;

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

2563
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATE);
2564
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2565
	legacy_rate_mask_to_array(cmd->legacy_rates, legacy_rate_mask);
2566
	memcpy(cmd->mcs_set, mcs_rates, 16);
2567 2568 2569 2570 2571 2572 2573

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

	return rc;
}

2574
/*
2575
 * CMD_FINALIZE_JOIN.
2576
 */
2577 2578 2579
#define MWL8K_FJ_BEACON_MAXLEN	128

struct mwl8k_cmd_finalize_join {
2580
	struct mwl8k_cmd_pkt header;
2581 2582
	__le32 sleep_interval;	/* Number of beacon periods to sleep */
	__u8 beacon_data[MWL8K_FJ_BEACON_MAXLEN];
2583
} __packed;
2584

2585 2586
static int mwl8k_cmd_finalize_join(struct ieee80211_hw *hw, void *frame,
				   int framelen, int dtim)
2587
{
2588 2589 2590
	struct mwl8k_cmd_finalize_join *cmd;
	struct ieee80211_mgmt *payload = frame;
	int payload_len;
2591 2592 2593 2594 2595 2596
	int rc;

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

2597
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_FINALIZE_JOIN);
2598
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2599 2600 2601 2602 2603 2604 2605 2606 2607
	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);
2608 2609 2610 2611 2612 2613 2614 2615

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

	return rc;
}

/*
2616
 * CMD_SET_RTS_THRESHOLD.
2617
 */
2618
struct mwl8k_cmd_set_rts_threshold {
2619 2620
	struct mwl8k_cmd_pkt header;
	__le16 action;
2621
	__le16 threshold;
2622
} __packed;
2623

Lennert Buytenhek's avatar
Lennert Buytenhek committed
2624 2625
static int
mwl8k_cmd_set_rts_threshold(struct ieee80211_hw *hw, int rts_thresh)
2626
{
2627
	struct mwl8k_cmd_set_rts_threshold *cmd;
2628 2629 2630 2631 2632 2633
	int rc;

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

2634
	cmd->header.code = cpu_to_le16(MWL8K_CMD_RTS_THRESHOLD);
2635
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
Lennert Buytenhek's avatar
Lennert Buytenhek committed
2636 2637
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->threshold = cpu_to_le16(rts_thresh);
2638 2639 2640 2641 2642 2643 2644 2645

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

	return rc;
}

/*
2646
 * CMD_SET_SLOT.
2647
 */
2648
struct mwl8k_cmd_set_slot {
2649 2650
	struct mwl8k_cmd_pkt header;
	__le16 action;
2651
	__u8 short_slot;
2652
} __packed;
2653

2654
static int mwl8k_cmd_set_slot(struct ieee80211_hw *hw, bool short_slot_time)
2655
{
2656
	struct mwl8k_cmd_set_slot *cmd;
2657 2658 2659 2660 2661 2662
	int rc;

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

2663
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_SLOT);
2664
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2665 2666
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->short_slot = short_slot_time;
2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685

	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;

2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702
	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;
2703

2704 2705
			/* Log exponent of min contention period: 0...15 */
			__u8 log_cw_min;
2706

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

2710 2711 2712 2713
			/* TX queue to configure */
			__u8 txq;
		} sta;
	};
2714
} __packed;
2715 2716 2717 2718 2719 2720 2721 2722 2723 2724

#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
2725 2726 2727
mwl8k_cmd_set_edca_params(struct ieee80211_hw *hw, __u8 qnum,
			  __u16 cw_min, __u16 cw_max,
			  __u8 aifs, __u16 txop)
2728
{
2729
	struct mwl8k_priv *priv = hw->priv;
2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740
	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);
2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751
	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;
	}
2752 2753 2754 2755 2756 2757 2758 2759

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

	return rc;
}

/*
2760
 * CMD_SET_WMM_MODE.
2761
 */
2762
struct mwl8k_cmd_set_wmm_mode {
2763
	struct mwl8k_cmd_pkt header;
2764
	__le16 action;
2765
} __packed;
2766

2767
static int mwl8k_cmd_set_wmm_mode(struct ieee80211_hw *hw, bool enable)
2768
{
2769 2770
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_cmd_set_wmm_mode *cmd;
2771 2772 2773 2774 2775 2776
	int rc;

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

2777
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_WMM_MODE);
2778
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2779
	cmd->action = cpu_to_le16(!!enable);
2780 2781 2782

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

2784 2785
	if (!rc)
		priv->wmm_enabled = enable;
2786 2787 2788 2789 2790

	return rc;
}

/*
2791
 * CMD_MIMO_CONFIG.
2792
 */
2793 2794 2795 2796 2797
struct mwl8k_cmd_mimo_config {
	struct mwl8k_cmd_pkt header;
	__le32 action;
	__u8 rx_antenna_map;
	__u8 tx_antenna_map;
2798
} __packed;
2799

2800
static int mwl8k_cmd_mimo_config(struct ieee80211_hw *hw, __u8 rx, __u8 tx)
2801
{
2802
	struct mwl8k_cmd_mimo_config *cmd;
2803 2804 2805 2806 2807 2808
	int rc;

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

2809
	cmd->header.code = cpu_to_le16(MWL8K_CMD_MIMO_CONFIG);
2810
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2811 2812 2813
	cmd->action = cpu_to_le32((u32)MWL8K_CMD_SET);
	cmd->rx_antenna_map = rx;
	cmd->tx_antenna_map = tx;
2814 2815 2816 2817 2818 2819 2820 2821

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

	return rc;
}

/*
2822
 * CMD_USE_FIXED_RATE (STA version).
2823
 */
2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837
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;
2838
} __packed;
2839

2840 2841
#define MWL8K_USE_AUTO_RATE	0x0002
#define MWL8K_UCAST_RATE	0
2842

2843
static int mwl8k_cmd_use_fixed_rate_sta(struct ieee80211_hw *hw)
2844
{
2845
	struct mwl8k_cmd_use_fixed_rate_sta *cmd;
2846 2847 2848 2849 2850 2851 2852 2853
	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));
2854 2855
	cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE);
	cmd->rate_type = cpu_to_le32(MWL8K_UCAST_RATE);
2856 2857 2858 2859 2860 2861 2862

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

	return rc;
}

2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879
/*
 * 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;
2880
} __packed;
2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903

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

2904 2905 2906 2907 2908 2909
/*
 * CMD_ENABLE_SNIFFER.
 */
struct mwl8k_cmd_enable_sniffer {
	struct mwl8k_cmd_pkt header;
	__le32 action;
2910
} __packed;
2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942

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];
	};
2943
} __packed;
2944

2945 2946 2947 2948
#define MWL8K_MAC_TYPE_PRIMARY_CLIENT		0
#define MWL8K_MAC_TYPE_SECONDARY_CLIENT		1
#define MWL8K_MAC_TYPE_PRIMARY_AP		2
#define MWL8K_MAC_TYPE_SECONDARY_AP		3
2949

2950 2951
static int mwl8k_cmd_set_mac_addr(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif, u8 *mac)
2952 2953
{
	struct mwl8k_priv *priv = hw->priv;
2954
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
2955
	struct mwl8k_cmd_set_mac_addr *cmd;
2956
	int mac_type;
2957 2958
	int rc;

2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971
	mac_type = MWL8K_MAC_TYPE_PRIMARY_AP;
	if (vif != NULL && vif->type == NL80211_IFTYPE_STATION) {
		if (mwl8k_vif->macid + 1 == ffs(priv->sta_macids_supported))
			mac_type = MWL8K_MAC_TYPE_PRIMARY_CLIENT;
		else
			mac_type = MWL8K_MAC_TYPE_SECONDARY_CLIENT;
	} else if (vif != NULL && vif->type == NL80211_IFTYPE_AP) {
		if (mwl8k_vif->macid + 1 == ffs(priv->ap_macids_supported))
			mac_type = MWL8K_MAC_TYPE_PRIMARY_AP;
		else
			mac_type = MWL8K_MAC_TYPE_SECONDARY_AP;
	}

2972 2973 2974 2975 2976 2977 2978
	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) {
2979
		cmd->mbss.mac_type = cpu_to_le16(mac_type);
2980 2981 2982 2983 2984
		memcpy(cmd->mbss.mac_addr, mac, ETH_ALEN);
	} else {
		memcpy(cmd->mac_addr, mac, ETH_ALEN);
	}

2985
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997
	kfree(cmd);

	return rc;
}

/*
 * CMD_SET_RATEADAPT_MODE.
 */
struct mwl8k_cmd_set_rate_adapt_mode {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 mode;
2998
} __packed;
2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019

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

3020 3021 3022 3023 3024 3025
/*
 * CMD_BSS_START.
 */
struct mwl8k_cmd_bss_start {
	struct mwl8k_cmd_pkt header;
	__le32 enable;
3026
} __packed;
3027

3028 3029
static int mwl8k_cmd_bss_start(struct ieee80211_hw *hw,
			       struct ieee80211_vif *vif, int enable)
3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040 3041
{
	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);

3042
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3043 3044 3045 3046 3047
	kfree(cmd);

	return rc;
}

3048 3049 3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069 3070
/*
 * 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;
3071
} __packed;
3072 3073 3074 3075 3076 3077 3078 3079 3080

#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;
3081
	u32 rates;
3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093
	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);
3094 3095 3096 3097 3098
	if (hw->conf.channel->band == IEEE80211_BAND_2GHZ)
		rates = sta->supp_rates[IEEE80211_BAND_2GHZ];
	else
		rates = sta->supp_rates[IEEE80211_BAND_5GHZ] << 5;
	cmd->legacy_rates = cpu_to_le32(rates);
3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109
	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;
	}

3110
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3111 3112 3113 3114 3115
	kfree(cmd);

	return rc;
}

3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126 3127 3128 3129
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);

3130
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3131 3132 3133 3134 3135
	kfree(cmd);

	return rc;
}

3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150
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);

3151
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3152 3153 3154 3155 3156
	kfree(cmd);

	return rc;
}

3157 3158 3159
/*
 * CMD_UPDATE_STADB.
 */
3160 3161 3162 3163
struct ewc_ht_info {
	__le16	control1;
	__le16	control2;
	__le16	control3;
3164
} __packed;
3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191 3192

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;
3193
} __packed;
3194

3195 3196 3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207
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;
3208
} __packed;
3209

3210 3211 3212 3213 3214 3215 3216
#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,
3217
				      struct ieee80211_vif *vif,
3218
				      struct ieee80211_sta *sta)
3219 3220
{
	struct mwl8k_cmd_update_stadb *cmd;
3221
	struct peer_capability_info *p;
3222
	u32 rates;
3223 3224 3225 3226 3227 3228 3229 3230
	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));
3231
	cmd->action = cpu_to_le32(MWL8K_STA_DB_MODIFY_ENTRY);
3232
	memcpy(cmd->peer_addr, sta->addr, ETH_ALEN);
3233

3234 3235 3236
	p = &cmd->peer_info;
	p->peer_type = MWL8K_PEER_TYPE_ACCESSPOINT;
	p->basic_caps = cpu_to_le16(vif->bss_conf.assoc_capability);
3237
	p->ht_support = sta->ht_cap.ht_supported;
3238
	p->ht_caps = cpu_to_le16(sta->ht_cap.cap);
3239 3240
	p->extended_ht_caps = (sta->ht_cap.ampdu_factor & 3) |
		((sta->ht_cap.ampdu_density & 7) << 2);
3241 3242 3243 3244 3245
	if (hw->conf.channel->band == IEEE80211_BAND_2GHZ)
		rates = sta->supp_rates[IEEE80211_BAND_2GHZ];
	else
		rates = sta->supp_rates[IEEE80211_BAND_5GHZ] << 5;
	legacy_rate_mask_to_array(p->legacy_rates, rates);
3246
	memcpy(p->ht_rates, sta->ht_cap.mcs.rx_mask, 16);
3247 3248 3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268
	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);
3269
	memcpy(cmd->peer_addr, addr, ETH_ALEN);
3270

3271
	rc = mwl8k_post_cmd(hw, &cmd->header);
3272 3273 3274 3275 3276
	kfree(cmd);

	return rc;
}

3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290

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

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

3291 3292 3293 3294 3295
	if (status & MWL8K_A2H_INT_TX_DONE) {
		status &= ~MWL8K_A2H_INT_TX_DONE;
		tasklet_schedule(&priv->poll_tx_task);
	}

3296
	if (status & MWL8K_A2H_INT_RX_READY) {
3297 3298
		status &= ~MWL8K_A2H_INT_RX_READY;
		tasklet_schedule(&priv->poll_rx_task);
3299 3300
	}

3301 3302 3303
	if (status)
		iowrite32(~status, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);

3304
	if (status & MWL8K_A2H_INT_OPC_DONE) {
3305
		if (priv->hostcmd_wait != NULL)
3306 3307 3308 3309
			complete(priv->hostcmd_wait);
	}

	if (status & MWL8K_A2H_INT_QUEUE_EMPTY) {
3310
		if (!mutex_is_locked(&priv->fw_mutex) &&
3311
		    priv->radio_on && priv->pending_tx_pkts)
3312
			mwl8k_tx_start(priv);
3313 3314 3315 3316 3317
	}

	return IRQ_HANDLED;
}

3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346
static void mwl8k_tx_poll(unsigned long data)
{
	struct ieee80211_hw *hw = (struct ieee80211_hw *)data;
	struct mwl8k_priv *priv = hw->priv;
	int limit;
	int i;

	limit = 32;

	spin_lock_bh(&priv->tx_lock);

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

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

	spin_unlock_bh(&priv->tx_lock);

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

3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364
static void mwl8k_rx_poll(unsigned long data)
{
	struct ieee80211_hw *hw = (struct ieee80211_hw *)data;
	struct mwl8k_priv *priv = hw->priv;
	int limit;

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

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

3365 3366 3367 3368 3369 3370 3371 3372 3373 3374

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

3375
	if (!priv->radio_on) {
3376 3377
		wiphy_debug(hw->wiphy,
			    "dropped TX frame since radio disabled\n");
3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391
		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;

3392
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
3393 3394
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
3395
		wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
3396
		return -EIO;
3397 3398
	}

3399
	/* Enable TX reclaim and RX tasklets.  */
3400
	tasklet_enable(&priv->poll_tx_task);
3401
	tasklet_enable(&priv->poll_rx_task);
3402

3403
	/* Enable interrupts */
3404
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
3405

3406 3407
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
3408
		rc = mwl8k_cmd_radio_enable(hw);
3409

3410 3411
		if (!priv->ap_fw) {
			if (!rc)
3412
				rc = mwl8k_cmd_enable_sniffer(hw, 0);
3413

3414 3415 3416 3417 3418 3419 3420
			if (!rc)
				rc = mwl8k_cmd_set_pre_scan(hw);

			if (!rc)
				rc = mwl8k_cmd_set_post_scan(hw,
						"\x00\x00\x00\x00\x00\x00");
		}
3421 3422

		if (!rc)
3423
			rc = mwl8k_cmd_set_rateadapt_mode(hw, 0);
3424

3425
		if (!rc)
3426
			rc = mwl8k_cmd_set_wmm_mode(hw, 0);
3427

3428 3429 3430 3431 3432 3433
		mwl8k_fw_unlock(hw);
	}

	if (rc) {
		iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
		free_irq(priv->pdev->irq, hw);
3434
		tasklet_disable(&priv->poll_tx_task);
3435
		tasklet_disable(&priv->poll_rx_task);
3436
	}
3437 3438 3439 3440 3441 3442 3443 3444 3445

	return rc;
}

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

3446
	mwl8k_cmd_radio_disable(hw);
3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458

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

3459
	/* Stop TX reclaim and RX tasklets.  */
3460
	tasklet_disable(&priv->poll_tx_task);
3461
	tasklet_disable(&priv->poll_rx_task);
3462 3463 3464

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

3468 3469
static int mwl8k_reload_firmware(struct ieee80211_hw *hw, char *fw_image);

3470
static int mwl8k_add_interface(struct ieee80211_hw *hw,
3471
			       struct ieee80211_vif *vif)
3472 3473 3474
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_vif *mwl8k_vif;
3475
	u32 macids_supported;
3476 3477
	int macid, rc;
	struct mwl8k_device_info *di;
3478

3479 3480 3481
	/*
	 * Reject interface creation if sniffer mode is active, as
	 * STA operation is mutually exclusive with hardware sniffer
3482
	 * mode.  (Sniffer mode is only used on STA firmware.)
3483 3484
	 */
	if (priv->sniffer_enabled) {
3485 3486
		wiphy_info(hw->wiphy,
			   "unable to create STA interface because sniffer mode is enabled\n");
3487 3488 3489
		return -EINVAL;
	}

3490
	di = priv->device_info;
3491 3492
	switch (vif->type) {
	case NL80211_IFTYPE_AP:
3493 3494 3495 3496 3497 3498 3499 3500
		if (!priv->ap_fw && di->fw_image_ap) {
			/* we must load the ap fw to meet this request */
			if (!list_empty(&priv->vif_list))
				return -EBUSY;
			rc = mwl8k_reload_firmware(hw, di->fw_image_ap);
			if (rc)
				return rc;
		}
3501 3502 3503
		macids_supported = priv->ap_macids_supported;
		break;
	case NL80211_IFTYPE_STATION:
3504 3505 3506 3507 3508 3509 3510 3511
		if (priv->ap_fw && di->fw_image_sta) {
			/* we must load the sta fw to meet this request */
			if (!list_empty(&priv->vif_list))
				return -EBUSY;
			rc = mwl8k_reload_firmware(hw, di->fw_image_sta);
			if (rc)
				return rc;
		}
3512 3513 3514 3515 3516 3517 3518 3519 3520 3521
		macids_supported = priv->sta_macids_supported;
		break;
	default:
		return -EINVAL;
	}

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

3522
	/* Setup driver private area. */
3523
	mwl8k_vif = MWL8K_VIF(vif);
3524
	memset(mwl8k_vif, 0, sizeof(*mwl8k_vif));
3525
	mwl8k_vif->vif = vif;
3526
	mwl8k_vif->macid = macid;
3527 3528
	mwl8k_vif->seqno = 0;

3529 3530 3531 3532 3533 3534
	/* Set the mac address.  */
	mwl8k_cmd_set_mac_addr(hw, vif, vif->addr);

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

3535
	priv->macids_used |= 1 << mwl8k_vif->macid;
3536
	list_add_tail(&mwl8k_vif->list, &priv->vif_list);
3537 3538 3539 3540 3541

	return 0;
}

static void mwl8k_remove_interface(struct ieee80211_hw *hw,
3542
				   struct ieee80211_vif *vif)
3543 3544
{
	struct mwl8k_priv *priv = hw->priv;
3545
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
3546

3547 3548 3549
	if (priv->ap_fw)
		mwl8k_cmd_set_new_stn_del(hw, vif, vif->addr);

3550
	mwl8k_cmd_set_mac_addr(hw, vif, "\x00\x00\x00\x00\x00\x00");
3551

3552
	priv->macids_used &= ~(1 << mwl8k_vif->macid);
3553
	list_del(&mwl8k_vif->list);
3554 3555
}

3556
static int mwl8k_config(struct ieee80211_hw *hw, u32 changed)
3557 3558 3559
{
	struct ieee80211_conf *conf = &hw->conf;
	struct mwl8k_priv *priv = hw->priv;
3560
	int rc;
3561

3562
	if (conf->flags & IEEE80211_CONF_IDLE) {
3563
		mwl8k_cmd_radio_disable(hw);
3564
		return 0;
3565 3566
	}

3567 3568 3569
	rc = mwl8k_fw_lock(hw);
	if (rc)
		return rc;
3570

3571
	rc = mwl8k_cmd_radio_enable(hw);
3572 3573
	if (rc)
		goto out;
3574

3575
	rc = mwl8k_cmd_set_rf_channel(hw, conf);
3576 3577 3578
	if (rc)
		goto out;

3579 3580 3581
	if (conf->power_level > 18)
		conf->power_level = 18;

3582
	if (priv->ap_fw) {
3583 3584 3585 3586
		rc = mwl8k_cmd_tx_power(hw, conf, conf->power_level);
		if (rc)
			goto out;

3587 3588 3589 3590
		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 {
3591 3592 3593
		rc = mwl8k_cmd_rf_tx_power(hw, conf->power_level);
		if (rc)
			goto out;
3594 3595
		rc = mwl8k_cmd_mimo_config(hw, 0x7, 0x7);
	}
3596

3597 3598
out:
	mwl8k_fw_unlock(hw);
3599

3600
	return rc;
3601 3602
}

3603 3604 3605
static void
mwl8k_bss_info_changed_sta(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			   struct ieee80211_bss_conf *info, u32 changed)
3606 3607
{
	struct mwl8k_priv *priv = hw->priv;
3608
	u32 ap_legacy_rates;
3609
	u8 ap_mcs_rates[16];
3610 3611
	int rc;

3612
	if (mwl8k_fw_lock(hw))
3613
		return;
3614

3615 3616 3617 3618 3619
	/*
	 * 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;
3620

3621
	/*
3622
	 * Get the AP's legacy and MCS rates.
3623
	 */
3624
	if (vif->bss_conf.assoc) {
3625
		struct ieee80211_sta *ap;
3626

3627 3628
		rcu_read_lock();

3629 3630 3631
		ap = ieee80211_find_sta(vif, vif->bss_conf.bssid);
		if (ap == NULL) {
			rcu_read_unlock();
3632
			goto out;
3633 3634
		}

3635 3636 3637 3638 3639 3640
		if (hw->conf.channel->band == IEEE80211_BAND_2GHZ) {
			ap_legacy_rates = ap->supp_rates[IEEE80211_BAND_2GHZ];
		} else {
			ap_legacy_rates =
				ap->supp_rates[IEEE80211_BAND_5GHZ] << 5;
		}
3641
		memcpy(ap_mcs_rates, ap->ht_cap.mcs.rx_mask, 16);
3642 3643 3644

		rcu_read_unlock();
	}
3645

3646
	if ((changed & BSS_CHANGED_ASSOC) && vif->bss_conf.assoc) {
3647
		rc = mwl8k_cmd_set_rate(hw, vif, ap_legacy_rates, ap_mcs_rates);
3648 3649
		if (rc)
			goto out;
3650

3651
		rc = mwl8k_cmd_use_fixed_rate_sta(hw);
3652 3653
		if (rc)
			goto out;
3654
	}
3655

3656
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3657 3658
		rc = mwl8k_set_radio_preamble(hw,
				vif->bss_conf.use_short_preamble);
3659 3660
		if (rc)
			goto out;
3661
	}
3662

3663
	if (changed & BSS_CHANGED_ERP_SLOT) {
3664
		rc = mwl8k_cmd_set_slot(hw, vif->bss_conf.use_short_slot);
3665 3666
		if (rc)
			goto out;
3667
	}
3668

3669 3670 3671
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_ERP_CTS_PROT |
			BSS_CHANGED_HT))) {
3672
		rc = mwl8k_cmd_set_aid(hw, vif, ap_legacy_rates);
3673 3674
		if (rc)
			goto out;
3675
	}
3676

3677 3678
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_BEACON_INT))) {
3679 3680 3681 3682
		/*
		 * Finalize the join.  Tell rx handler to process
		 * next beacon from our BSSID.
		 */
3683
		memcpy(priv->capture_bssid, vif->bss_conf.bssid, ETH_ALEN);
3684 3685 3686
		priv->capture_beacon = true;
	}

3687 3688
out:
	mwl8k_fw_unlock(hw);
3689 3690
}

3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716
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);
3717 3718 3719 3720 3721 3722 3723
		if (idx)
			idx--;

		if (hw->conf.channel->band == IEEE80211_BAND_2GHZ)
			rate = mwl8k_rates_24[idx].hw_value;
		else
			rate = mwl8k_rates_50[idx].hw_value;
3724 3725 3726 3727 3728 3729 3730 3731 3732

		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) {
3733
			mwl8k_cmd_set_beacon(hw, vif, skb->data, skb->len);
3734 3735 3736 3737 3738
			kfree_skb(skb);
		}
	}

	if (changed & BSS_CHANGED_BEACON_ENABLED)
3739
		mwl8k_cmd_bss_start(hw, vif, info->enable_beacon);
3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756

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

3757
static u64 mwl8k_prepare_multicast(struct ieee80211_hw *hw,
3758
				   struct netdev_hw_addr_list *mc_list)
3759 3760 3761
{
	struct mwl8k_cmd_pkt *cmd;

3762 3763 3764 3765 3766 3767 3768
	/*
	 * 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().
	 */
3769
	cmd = __mwl8k_cmd_mac_multicast_adr(hw, 0, mc_list);
3770 3771 3772 3773

	return (unsigned long)cmd;
}

3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785
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.
	 */
3786
	if (!list_empty(&priv->vif_list)) {
3787
		if (net_ratelimit())
3788 3789
			wiphy_info(hw->wiphy,
				   "not enabling sniffer mode because STA interface is active\n");
3790 3791 3792 3793
		return 0;
	}

	if (!priv->sniffer_enabled) {
3794
		if (mwl8k_cmd_enable_sniffer(hw, 1))
3795 3796 3797 3798 3799 3800 3801 3802 3803 3804 3805
			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;
}

3806 3807 3808 3809 3810 3811 3812 3813
static struct mwl8k_vif *mwl8k_first_vif(struct mwl8k_priv *priv)
{
	if (!list_empty(&priv->vif_list))
		return list_entry(priv->vif_list.next, struct mwl8k_vif, list);

	return NULL;
}

3814 3815 3816 3817 3818 3819
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;
3820 3821
	struct mwl8k_cmd_pkt *cmd = (void *)(unsigned long)multicast;

3822 3823 3824 3825 3826 3827 3828 3829 3830 3831
	/*
	 * 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;
	}

3832 3833 3834 3835 3836 3837 3838 3839 3840
	/*
	 * 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;
	}
3841

3842
	/* Clear unsupported feature flags */
3843
	*total_flags &= FIF_ALLMULTI | FIF_BCN_PRBRESP_PROMISC;
3844

3845 3846
	if (mwl8k_fw_lock(hw)) {
		kfree(cmd);
3847
		return;
3848
	}
3849

3850
	if (priv->sniffer_enabled) {
3851
		mwl8k_cmd_enable_sniffer(hw, 0);
3852 3853 3854
		priv->sniffer_enabled = false;
	}

3855
	if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
3856 3857 3858 3859
		if (*total_flags & FIF_BCN_PRBRESP_PROMISC) {
			/*
			 * Disable the BSS filter.
			 */
3860
			mwl8k_cmd_set_pre_scan(hw);
3861
		} else {
3862
			struct mwl8k_vif *mwl8k_vif;
3863
			const u8 *bssid;
3864

3865 3866 3867 3868 3869 3870 3871 3872
			/*
			 * 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).
			 */
3873 3874 3875 3876 3877
			mwl8k_vif = mwl8k_first_vif(priv);
			if (mwl8k_vif != NULL)
				bssid = mwl8k_vif->vif->bss_conf.bssid;
			else
				bssid = "\x01\x00\x00\x00\x00\x00";
3878

3879
			mwl8k_cmd_set_post_scan(hw, bssid);
3880 3881 3882
		}
	}

3883 3884 3885 3886 3887 3888 3889 3890
	/*
	 * 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);
3891
		cmd = __mwl8k_cmd_mac_multicast_adr(hw, 1, NULL);
3892 3893 3894 3895 3896
	}

	if (cmd != NULL) {
		mwl8k_post_cmd(hw, cmd);
		kfree(cmd);
3897
	}
3898

3899
	mwl8k_fw_unlock(hw);
3900 3901 3902 3903
}

static int mwl8k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
{
Lennert Buytenhek's avatar
Lennert Buytenhek committed
3904
	return mwl8k_cmd_set_rts_threshold(hw, value);
3905 3906
}

3907 3908 3909
static int mwl8k_sta_remove(struct ieee80211_hw *hw,
			    struct ieee80211_vif *vif,
			    struct ieee80211_sta *sta)
3910 3911 3912
{
	struct mwl8k_priv *priv = hw->priv;

3913 3914 3915 3916
	if (priv->ap_fw)
		return mwl8k_cmd_set_new_stn_del(hw, vif, sta->addr);
	else
		return mwl8k_cmd_update_stadb_del(hw, vif, sta->addr);
3917 3918
}

3919 3920 3921
static int mwl8k_sta_add(struct ieee80211_hw *hw,
			 struct ieee80211_vif *vif,
			 struct ieee80211_sta *sta)
3922 3923
{
	struct mwl8k_priv *priv = hw->priv;
3924
	int ret;
3925

3926 3927 3928 3929 3930 3931
	if (!priv->ap_fw) {
		ret = mwl8k_cmd_update_stadb_add(hw, vif, sta);
		if (ret >= 0) {
			MWL8K_STA(sta)->peer_id = ret;
			return 0;
		}
3932

3933
		return ret;
3934
	}
3935 3936

	return mwl8k_cmd_set_new_stn_add(hw, vif, sta);
3937 3938
}

3939 3940 3941
static int mwl8k_conf_tx(struct ieee80211_hw *hw, u16 queue,
			 const struct ieee80211_tx_queue_params *params)
{
3942
	struct mwl8k_priv *priv = hw->priv;
3943 3944
	int rc;

3945 3946
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
3947 3948 3949
		BUG_ON(queue > MWL8K_TX_QUEUES - 1);
		memcpy(&priv->wmm_params[queue], params, sizeof(*params));

3950
		if (!priv->wmm_enabled)
3951
			rc = mwl8k_cmd_set_wmm_mode(hw, 1);
3952

3953
		if (!rc)
3954 3955 3956 3957 3958
			rc = mwl8k_cmd_set_edca_params(hw, queue,
						       params->cw_min,
						       params->cw_max,
						       params->aifs,
						       params->txop);
3959 3960

		mwl8k_fw_unlock(hw);
3961
	}
3962

3963 3964 3965 3966 3967 3968
	return rc;
}

static int mwl8k_get_stats(struct ieee80211_hw *hw,
			   struct ieee80211_low_level_stats *stats)
{
3969
	return mwl8k_cmd_get_stat(hw, stats);
3970 3971
}

3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987
static int mwl8k_get_survey(struct ieee80211_hw *hw, int idx,
				struct survey_info *survey)
{
	struct mwl8k_priv *priv = hw->priv;
	struct ieee80211_conf *conf = &hw->conf;

	if (idx != 0)
		return -ENOENT;

	survey->channel = conf->channel;
	survey->filled = SURVEY_INFO_NOISE_DBM;
	survey->noise = priv->noise;

	return 0;
}

3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003
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;
	}
}

4004 4005 4006 4007 4008 4009 4010 4011
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,
4012
	.prepare_multicast	= mwl8k_prepare_multicast,
4013 4014
	.configure_filter	= mwl8k_configure_filter,
	.set_rts_threshold	= mwl8k_set_rts_threshold,
4015 4016
	.sta_add		= mwl8k_sta_add,
	.sta_remove		= mwl8k_sta_remove,
4017 4018
	.conf_tx		= mwl8k_conf_tx,
	.get_stats		= mwl8k_get_stats,
4019
	.get_survey		= mwl8k_get_survey,
4020
	.ampdu_action		= mwl8k_ampdu_action,
4021 4022 4023 4024 4025 4026 4027
};

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;
4028 4029 4030 4031 4032 4033 4034 4035
	struct ieee80211_mgmt *mgmt = (void *)skb->data;
	int len = skb->len - offsetof(struct ieee80211_mgmt, u.beacon.variable);
	const u8 *tim = cfg80211_find_ie(WLAN_EID_TIM,
					 mgmt->u.beacon.variable, len);
	int dtim_period = 1;

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

4037
	mwl8k_cmd_finalize_join(priv->hw, skb->data, skb->len, dtim_period);
4038

4039
	dev_kfree_skb(skb);
4040 4041 4042
	priv->beacon_skb = NULL;
}

4043
enum {
4044 4045
	MWL8363 = 0,
	MWL8687,
4046
	MWL8366,
4047 4048
};

4049 4050 4051 4052
#define MWL8K_8366_AP_FW_API 1
#define _MWL8K_8366_AP_FW(api) "mwl8k/fmimage_8366_ap-" #api ".fw"
#define MWL8K_8366_AP_FW(api) _MWL8K_8366_AP_FW(api)

4053
static struct mwl8k_device_info mwl8k_info_tbl[] __devinitdata = {
4054 4055 4056
	[MWL8363] = {
		.part_name	= "88w8363",
		.helper_image	= "mwl8k/helper_8363.fw",
4057
		.fw_image_sta	= "mwl8k/fmimage_8363.fw",
4058
	},
4059
	[MWL8687] = {
4060 4061
		.part_name	= "88w8687",
		.helper_image	= "mwl8k/helper_8687.fw",
4062
		.fw_image_sta	= "mwl8k/fmimage_8687.fw",
4063
	},
4064
	[MWL8366] = {
4065 4066
		.part_name	= "88w8366",
		.helper_image	= "mwl8k/helper_8366.fw",
4067
		.fw_image_sta	= "mwl8k/fmimage_8366.fw",
4068 4069
		.fw_image_ap	= MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API),
		.fw_api_ap	= MWL8K_8366_AP_FW_API,
4070
		.ap_rxd_ops	= &rxd_8366_ap_ops,
4071
	},
4072 4073
};

4074 4075 4076 4077 4078 4079
MODULE_FIRMWARE("mwl8k/helper_8363.fw");
MODULE_FIRMWARE("mwl8k/fmimage_8363.fw");
MODULE_FIRMWARE("mwl8k/helper_8687.fw");
MODULE_FIRMWARE("mwl8k/fmimage_8687.fw");
MODULE_FIRMWARE("mwl8k/helper_8366.fw");
MODULE_FIRMWARE("mwl8k/fmimage_8366.fw");
4080
MODULE_FIRMWARE(MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API));
4081

4082
static DEFINE_PCI_DEVICE_TABLE(mwl8k_pci_id_table) = {
4083
	{ PCI_VDEVICE(MARVELL, 0x2a0a), .driver_data = MWL8363, },
4084 4085
	{ PCI_VDEVICE(MARVELL, 0x2a0c), .driver_data = MWL8363, },
	{ PCI_VDEVICE(MARVELL, 0x2a24), .driver_data = MWL8363, },
4086 4087 4088
	{ PCI_VDEVICE(MARVELL, 0x2a2b), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a30), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a40), .driver_data = MWL8366, },
4089
	{ PCI_VDEVICE(MARVELL, 0x2a43), .driver_data = MWL8366, },
4090
	{ },
4091 4092 4093
};
MODULE_DEVICE_TABLE(pci, mwl8k_pci_id_table);

4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166 4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186
static int mwl8k_request_alt_fw(struct mwl8k_priv *priv)
{
	int rc;
	printk(KERN_ERR "%s: Error requesting preferred fw %s.\n"
	       "Trying alternative firmware %s\n", pci_name(priv->pdev),
	       priv->fw_pref, priv->fw_alt);
	rc = mwl8k_request_fw(priv, priv->fw_alt, &priv->fw_ucode, true);
	if (rc) {
		printk(KERN_ERR "%s: Error requesting alt fw %s\n",
		       pci_name(priv->pdev), priv->fw_alt);
		return rc;
	}
	return 0;
}

static int mwl8k_firmware_load_success(struct mwl8k_priv *priv);
static void mwl8k_fw_state_machine(const struct firmware *fw, void *context)
{
	struct mwl8k_priv *priv = context;
	struct mwl8k_device_info *di = priv->device_info;
	int rc;

	switch (priv->fw_state) {
	case FW_STATE_INIT:
		if (!fw) {
			printk(KERN_ERR "%s: Error requesting helper fw %s\n",
			       pci_name(priv->pdev), di->helper_image);
			goto fail;
		}
		priv->fw_helper = fw;
		rc = mwl8k_request_fw(priv, priv->fw_pref, &priv->fw_ucode,
				      true);
		if (rc && priv->fw_alt) {
			rc = mwl8k_request_alt_fw(priv);
			if (rc)
				goto fail;
			priv->fw_state = FW_STATE_LOADING_ALT;
		} else if (rc)
			goto fail;
		else
			priv->fw_state = FW_STATE_LOADING_PREF;
		break;

	case FW_STATE_LOADING_PREF:
		if (!fw) {
			if (priv->fw_alt) {
				rc = mwl8k_request_alt_fw(priv);
				if (rc)
					goto fail;
				priv->fw_state = FW_STATE_LOADING_ALT;
			} else
				goto fail;
		} else {
			priv->fw_ucode = fw;
			rc = mwl8k_firmware_load_success(priv);
			if (rc)
				goto fail;
			else
				complete(&priv->firmware_loading_complete);
		}
		break;

	case FW_STATE_LOADING_ALT:
		if (!fw) {
			printk(KERN_ERR "%s: Error requesting alt fw %s\n",
			       pci_name(priv->pdev), di->helper_image);
			goto fail;
		}
		priv->fw_ucode = fw;
		rc = mwl8k_firmware_load_success(priv);
		if (rc)
			goto fail;
		else
			complete(&priv->firmware_loading_complete);
		break;

	default:
		printk(KERN_ERR "%s: Unexpected firmware loading state: %d\n",
		       MWL8K_NAME, priv->fw_state);
		BUG_ON(1);
	}

	return;

fail:
	priv->fw_state = FW_STATE_ERROR;
	complete(&priv->firmware_loading_complete);
	device_release_driver(&priv->pdev->dev);
	mwl8k_release_firmware(priv);
}

static int mwl8k_init_firmware(struct ieee80211_hw *hw, char *fw_image,
			       bool nowait)
4187
{
4188
	struct mwl8k_priv *priv = hw->priv;
4189
	int rc;
4190 4191 4192 4193 4194

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

	/* Ask userland hotplug daemon for the device firmware */
4195
	rc = mwl8k_request_firmware(priv, fw_image, nowait);
4196
	if (rc) {
4197
		wiphy_err(hw->wiphy, "Firmware files not found\n");
4198
		return rc;
4199 4200
	}

4201 4202 4203
	if (nowait)
		return rc;

4204 4205
	/* Load firmware into hardware */
	rc = mwl8k_load_firmware(hw);
4206
	if (rc)
4207
		wiphy_err(hw->wiphy, "Cannot start firmware\n");
4208 4209 4210 4211

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

4212 4213 4214 4215 4216 4217 4218 4219 4220
	return rc;
}

/* initialize hw after successfully loading a firmware image */
static int mwl8k_probe_hw(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;
	int rc = 0;
	int i;
4221

4222
	if (priv->ap_fw) {
4223
		priv->rxd_ops = priv->device_info->ap_rxd_ops;
4224
		if (priv->rxd_ops == NULL) {
4225 4226
			wiphy_err(hw->wiphy,
				  "Driver does not have AP firmware image support for this hardware\n");
4227 4228 4229
			goto err_stop_firmware;
		}
	} else {
4230
		priv->rxd_ops = &rxd_sta_ops;
4231
	}
4232 4233 4234 4235 4236

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

4237 4238
	rc = mwl8k_rxq_init(hw, 0);
	if (rc)
4239
		goto err_stop_firmware;
4240 4241 4242 4243 4244 4245 4246 4247 4248
	rxq_refill(hw, 0, INT_MAX);

	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);
4249
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4250
	iowrite32(MWL8K_A2H_INT_TX_DONE | MWL8K_A2H_INT_RX_READY,
4251
		  priv->regs + MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL);
4252 4253
	iowrite32(0xffffffff, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);

4254
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
4255 4256
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
4257
		wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
4258 4259 4260 4261 4262
		goto err_free_queues;
	}

	/*
	 * Temporarily enable interrupts.  Initial firmware host
Lennert Buytenhek's avatar
Lennert Buytenhek committed
4263
	 * commands use interrupts and avoid polling.  Disable
4264 4265
	 * interrupts when done.
	 */
4266
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4267 4268

	/* Get config data, mac addrs etc */
4269 4270 4271 4272 4273 4274 4275
	if (priv->ap_fw) {
		rc = mwl8k_cmd_get_hw_spec_ap(hw);
		if (!rc)
			rc = mwl8k_cmd_set_hw_spec(hw);
	} else {
		rc = mwl8k_cmd_get_hw_spec_sta(hw);
	}
4276
	if (rc) {
4277
		wiphy_err(hw->wiphy, "Cannot initialise firmware\n");
4278
		goto err_free_irq;
4279 4280 4281
	}

	/* Turn radio off */
4282
	rc = mwl8k_cmd_radio_disable(hw);
4283
	if (rc) {
4284
		wiphy_err(hw->wiphy, "Cannot disable\n");
4285
		goto err_free_irq;
4286 4287
	}

4288
	/* Clear MAC address */
4289
	rc = mwl8k_cmd_set_mac_addr(hw, NULL, "\x00\x00\x00\x00\x00\x00");
4290
	if (rc) {
4291
		wiphy_err(hw->wiphy, "Cannot clear MAC address\n");
4292
		goto err_free_irq;
4293 4294
	}

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

4299 4300 4301 4302 4303 4304
	wiphy_info(hw->wiphy, "%s v%d, %pm, %s firmware %u.%u.%u.%u\n",
		   priv->device_info->part_name,
		   priv->hw_rev, hw->wiphy->perm_addr,
		   priv->ap_fw ? "AP" : "STA",
		   (priv->fw_rev >> 24) & 0xff, (priv->fw_rev >> 16) & 0xff,
		   (priv->fw_rev >> 8) & 0xff, priv->fw_rev & 0xff);
4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316

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

4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337
err_stop_firmware:
	mwl8k_hw_reset(priv);

	return rc;
}

/*
 * invoke mwl8k_reload_firmware to change the firmware image after the device
 * has already been registered
 */
static int mwl8k_reload_firmware(struct ieee80211_hw *hw, char *fw_image)
{
	int i, rc = 0;
	struct mwl8k_priv *priv = hw->priv;

	mwl8k_stop(hw);
	mwl8k_rxq_deinit(hw, 0);

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

4338
	rc = mwl8k_init_firmware(hw, fw_image, false);
4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371
	if (rc)
		goto fail;

	rc = mwl8k_probe_hw(hw);
	if (rc)
		goto fail;

	rc = mwl8k_start(hw);
	if (rc)
		goto fail;

	rc = mwl8k_config(hw, ~0);
	if (rc)
		goto fail;

	for (i = 0; i < MWL8K_TX_QUEUES; i++) {
		rc = mwl8k_conf_tx(hw, i, &priv->wmm_params[i]);
		if (rc)
			goto fail;
	}

	return rc;

fail:
	printk(KERN_WARNING "mwl8k: Failed to reload firmware image.\n");
	return rc;
}

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

4372 4373 4374 4375 4376 4377 4378
	rc = mwl8k_load_firmware(hw);
	mwl8k_release_firmware(priv);
	if (rc) {
		wiphy_err(hw->wiphy, "Cannot start firmware\n");
		return rc;
	}

4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392 4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421 4422 4423 4424 4425 4426 4427 4428 4429 4430 4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441 4442 4443 4444 4445 4446 4447
	/*
	 * 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 values to dBm */
	hw->flags |= IEEE80211_HW_SIGNAL_DBM;
	hw->vif_data_size = sizeof(struct mwl8k_vif);
	hw->sta_data_size = sizeof(struct mwl8k_sta);

	priv->macids_used = 0;
	INIT_LIST_HEAD(&priv->vif_list);

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

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

	/* TX reclaim and RX tasklets.  */
	tasklet_init(&priv->poll_tx_task, mwl8k_tx_poll, (unsigned long)hw);
	tasklet_disable(&priv->poll_tx_task);
	tasklet_init(&priv->poll_rx_task, mwl8k_rx_poll, (unsigned long)hw);
	tasklet_disable(&priv->poll_rx_task);

	/* Power management cookie */
	priv->cookie = pci_alloc_consistent(priv->pdev, 4, &priv->cookie_dma);
	if (priv->cookie == NULL)
		return -ENOMEM;

	mutex_init(&priv->fw_mutex);
	priv->fw_mutex_owner = NULL;
	priv->fw_mutex_depth = 0;
	priv->hostcmd_wait = NULL;

	spin_lock_init(&priv->tx_lock);

	priv->tx_wait = NULL;

	rc = mwl8k_probe_hw(hw);
	if (rc)
		goto err_free_cookie;

	hw->wiphy->interface_modes = 0;
	if (priv->ap_macids_supported || priv->device_info->fw_image_ap)
		hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP);
	if (priv->sta_macids_supported || priv->device_info->fw_image_sta)
		hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_STATION);

	rc = ieee80211_register_hw(hw);
	if (rc) {
		wiphy_err(hw->wiphy, "Cannot register device\n");
		goto err_unprobe_hw;
	}

	return 0;

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

4448
err_free_cookie:
4449 4450 4451 4452
	if (priv->cookie != NULL)
		pci_free_consistent(priv->pdev, 4,
				priv->cookie, priv->cookie_dma);

4453 4454 4455 4456 4457 4458 4459 4460
	return rc;
}
static int __devinit mwl8k_probe(struct pci_dev *pdev,
				 const struct pci_device_id *id)
{
	static int printed_version;
	struct ieee80211_hw *hw;
	struct mwl8k_priv *priv;
4461
	struct mwl8k_device_info *di;
4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521
	int rc;

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


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

	pci_set_master(pdev);


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

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

	priv = hw->priv;
	priv->hw = hw;
	priv->pdev = pdev;
	priv->device_info = &mwl8k_info_tbl[id->driver_data];


	priv->sram = pci_iomap(pdev, 0, 0x10000);
	if (priv->sram == NULL) {
		wiphy_err(hw->wiphy, "Cannot map device SRAM\n");
		goto err_iounmap;
	}

	/*
	 * 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) {
			wiphy_err(hw->wiphy, "Cannot map device registers\n");
			goto err_iounmap;
		}
	}

4522
	/*
4523 4524 4525
	 * Choose the initial fw image depending on user input.  If a second
	 * image is available, make it the alternative image that will be
	 * loaded if the first one fails.
4526
	 */
4527
	init_completion(&priv->firmware_loading_complete);
4528
	di = priv->device_info;
4529 4530 4531 4532 4533 4534 4535
	if (ap_mode_default && di->fw_image_ap) {
		priv->fw_pref = di->fw_image_ap;
		priv->fw_alt = di->fw_image_sta;
	} else if (!ap_mode_default && di->fw_image_sta) {
		priv->fw_pref = di->fw_image_sta;
		priv->fw_alt = di->fw_image_ap;
	} else if (ap_mode_default && !di->fw_image_ap && di->fw_image_sta) {
4536
		printk(KERN_WARNING "AP fw is unavailable.  Using STA fw.");
4537
		priv->fw_pref = di->fw_image_sta;
4538 4539
	} else if (!ap_mode_default && !di->fw_image_sta && di->fw_image_ap) {
		printk(KERN_WARNING "STA fw is unavailable.  Using AP fw.");
4540 4541 4542
		priv->fw_pref = di->fw_image_ap;
	}
	rc = mwl8k_init_firmware(hw, priv->fw_pref, true);
4543 4544
	if (rc)
		goto err_stop_firmware;
4545
	return rc;
4546

4547 4548 4549 4550
err_stop_firmware:
	mwl8k_hw_reset(priv);

err_iounmap:
4551 4552 4553
	if (priv->regs != NULL)
		pci_iounmap(pdev, priv->regs);

4554 4555 4556
	if (priv->sram != NULL)
		pci_iounmap(pdev, priv->sram);

4557 4558 4559 4560 4561
	pci_set_drvdata(pdev, NULL);
	ieee80211_free_hw(hw);

err_free_reg:
	pci_release_regions(pdev);
4562 4563

err_disable_device:
4564 4565 4566 4567 4568
	pci_disable_device(pdev);

	return rc;
}

4569
static void __devexit mwl8k_shutdown(struct pci_dev *pdev)
4570 4571 4572 4573
{
	printk(KERN_ERR "===>%s(%u)\n", __func__, __LINE__);
}

4574
static void __devexit mwl8k_remove(struct pci_dev *pdev)
4575 4576 4577 4578 4579 4580 4581 4582 4583
{
	struct ieee80211_hw *hw = pci_get_drvdata(pdev);
	struct mwl8k_priv *priv;
	int i;

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

4584 4585 4586 4587 4588 4589 4590
	wait_for_completion(&priv->firmware_loading_complete);

	if (priv->fw_state == FW_STATE_ERROR) {
		mwl8k_hw_reset(priv);
		goto unmap;
	}

4591 4592
	ieee80211_stop_queues(hw);

4593 4594
	ieee80211_unregister_hw(hw);

4595
	/* Remove TX reclaim and RX tasklets.  */
4596
	tasklet_kill(&priv->poll_tx_task);
4597
	tasklet_kill(&priv->poll_rx_task);
4598 4599 4600 4601 4602 4603

	/* Stop hardware */
	mwl8k_hw_reset(priv);

	/* Return all skbs to mac80211 */
	for (i = 0; i < MWL8K_TX_QUEUES; i++)
4604
		mwl8k_txq_reclaim(hw, i, INT_MAX, 1);
4605 4606 4607 4608 4609 4610

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

	mwl8k_rxq_deinit(hw, 0);

4611
	pci_free_consistent(priv->pdev, 4, priv->cookie, priv->cookie_dma);
4612

4613
unmap:
4614
	pci_iounmap(pdev, priv->regs);
4615
	pci_iounmap(pdev, priv->sram);
4616 4617 4618 4619 4620 4621 4622 4623
	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,
4624
	.id_table	= mwl8k_pci_id_table,
4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638 4639 4640 4641
	.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);
4642 4643 4644 4645 4646

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