mwl8k.c 118.9 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;

L
Lennert Buytenhek 已提交
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 256 257 258 259

	/* BSSID */
	u8 bssid[ETH_ALEN];

	/* A flag to indicate is HW crypto is enabled for this bssid */
	bool is_hw_crypto_enabled;
260
};
261
#define MWL8K_VIF(_vif) ((struct mwl8k_vif *)&((_vif)->drv_priv))
262
#define IEEE80211_KEY_CONF(_u8) ((struct ieee80211_key_conf *)(_u8))
263

264 265 266 267 268 269
struct mwl8k_sta {
	/* Index into station database. Returned by UPDATE_STADB.  */
	u8 peer_id;
};
#define MWL8K_STA(_sta) ((struct mwl8k_sta *)&((_sta)->drv_priv))

270
static const struct ieee80211_channel mwl8k_channels_24[] = {
271 272 273 274 275 276 277 278 279 280 281
	{ .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, },
282 283 284
	{ .center_freq = 2467, .hw_value = 12, },
	{ .center_freq = 2472, .hw_value = 13, },
	{ .center_freq = 2484, .hw_value = 14, },
285 286
};

287
static const struct ieee80211_rate mwl8k_rates_24[] = {
288 289 290
	{ .bitrate = 10, .hw_value = 2, },
	{ .bitrate = 20, .hw_value = 4, },
	{ .bitrate = 55, .hw_value = 11, },
291 292
	{ .bitrate = 110, .hw_value = 22, },
	{ .bitrate = 220, .hw_value = 44, },
293 294 295 296 297 298 299 300
	{ .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, },
301 302 303
	{ .bitrate = 720, .hw_value = 144, },
};

304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322
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, },
};

323 324
/* Set or get info from Firmware */
#define MWL8K_CMD_GET			0x0000
325 326
#define MWL8K_CMD_SET			0x0001
#define MWL8K_CMD_SET_LIST		0x0002
327 328 329 330

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

359
static const char *mwl8k_cmd_name(__le16 cmd, char *buf, int bufsize)
360
{
361 362
	u16 command = le16_to_cpu(cmd);

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

static void mwl8k_release_firmware(struct mwl8k_priv *priv)
{
426 427
	mwl8k_release_fw(&priv->fw_ucode);
	mwl8k_release_fw(&priv->fw_helper);
428 429
}

430 431 432 433 434 435 436 437 438
/* 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,
};

439 440
/* Request fw image */
static int mwl8k_request_fw(struct mwl8k_priv *priv,
441
			    const char *fname, const struct firmware **fw,
442
			    bool nowait)
443 444 445 446 447
{
	/* release current image */
	if (*fw != NULL)
		mwl8k_release_fw(fw);

448 449 450 451 452
	if (nowait)
		return request_firmware_nowait(THIS_MODULE, 1, fname,
					       &priv->pdev->dev, GFP_KERNEL,
					       priv, mwl8k_fw_state_machine);
	else
453
		return request_firmware(fw, fname, &priv->pdev->dev);
454 455
}

456 457
static int mwl8k_request_firmware(struct mwl8k_priv *priv, char *fw_image,
				  bool nowait)
458
{
459
	struct mwl8k_device_info *di = priv->device_info;
460 461
	int rc;

462
	if (di->helper_image != NULL) {
463 464 465 466 467 468 469 470 471 472 473
		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)
474
			return rc;
475 476
	}

477 478 479 480 481 482 483 484 485 486 487 488
	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);
489
	if (rc) {
L
Lennert Buytenhek 已提交
490
		printk(KERN_ERR "%s: Error requesting firmware file %s\n",
491
		       pci_name(priv->pdev), fw_image);
492
		mwl8k_release_fw(&priv->fw_helper);
493 494 495 496 497 498 499 500 501
		return rc;
	}

	return 0;
}

struct mwl8k_cmd_pkt {
	__le16	code;
	__le16	length;
502 503
	__u8	seq_num;
	__u8	macid;
504 505
	__le16	result;
	char	payload[0];
506
} __packed;
507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538

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

539
		cond_resched();
540 541 542 543 544
		udelay(1);
	} while (--loops);

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

545
	return loops ? 0 : -ETIMEDOUT;
546 547 548 549 550 551 552 553 554 555 556 557 558 559 560
}

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;
561
	cmd->macid = 0;
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 640 641 642 643 644 645 646 647 648
	cmd->result = 0;

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

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

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

		done += block_size;
		length -= block_size;
	}

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

	kfree(cmd);

	return rc;
}

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

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

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

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

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

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

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

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

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

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

	kfree(buffer);

	return rc;
}

L
Lennert Buytenhek 已提交
649
static int mwl8k_load_firmware(struct ieee80211_hw *hw)
650
{
L
Lennert Buytenhek 已提交
651
	struct mwl8k_priv *priv = hw->priv;
652
	const struct firmware *fw = priv->fw_ucode;
L
Lennert Buytenhek 已提交
653 654 655 656
	int rc;
	int loops;

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

L
Lennert Buytenhek 已提交
659 660 661 662 663
		if (helper == NULL) {
			printk(KERN_ERR "%s: helper image needed but none "
			       "given\n", pci_name(priv->pdev));
			return -EINVAL;
		}
664

L
Lennert Buytenhek 已提交
665
		rc = mwl8k_load_fw_image(priv, helper->data, helper->size);
666 667
		if (rc) {
			printk(KERN_ERR "%s: unable to load firmware "
L
Lennert Buytenhek 已提交
668
			       "helper image\n", pci_name(priv->pdev));
669 670
			return rc;
		}
671
		msleep(5);
672

L
Lennert Buytenhek 已提交
673
		rc = mwl8k_feed_fw_image(priv, fw->data, fw->size);
674
	} else {
L
Lennert Buytenhek 已提交
675
		rc = mwl8k_load_fw_image(priv, fw->data, fw->size);
676 677 678
	}

	if (rc) {
L
Lennert Buytenhek 已提交
679 680
		printk(KERN_ERR "%s: unable to load firmware image\n",
		       pci_name(priv->pdev));
681 682 683
		return rc;
	}

684
	iowrite32(MWL8K_MODE_STA, priv->regs + MWL8K_HIU_GEN_PTR);
685

686
	loops = 500000;
687
	do {
688 689 690 691 692 693 694 695
		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;
696
			break;
697 698 699
		}

		cond_resched();
700 701 702 703 704 705 706 707 708 709 710
		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;
711
	char data[0];
712
} __packed;
713 714

/* Routines to add/remove DMA header from skb.  */
715
static inline void mwl8k_remove_dma_header(struct sk_buff *skb, __le16 qos)
716
{
717 718 719 720 721 722 723 724 725 726 727 728 729
	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);
		}
730
	}
731 732 733

	if (hdrlen != sizeof(*tr))
		skb_pull(skb, sizeof(*tr) - hdrlen);
734 735
}

736 737
static void
mwl8k_add_dma_header(struct sk_buff *skb, int tail_pad)
738 739
{
	struct ieee80211_hdr *wh;
740
	int hdrlen;
741
	int reqd_hdrlen;
742 743
	struct mwl8k_dma_data *tr;

744 745 746 747 748 749
	/*
	 * 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).
	 */
750
	wh = (struct ieee80211_hdr *)skb->data;
751

752
	hdrlen = ieee80211_hdrlen(wh->frame_control);
753 754 755 756
	reqd_hdrlen = sizeof(*tr);

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

758
	if (ieee80211_is_data_qos(wh->frame_control))
759
		hdrlen -= IEEE80211_QOS_CTL_LEN;
760 761 762 763

	tr = (struct mwl8k_dma_data *)skb->data;
	if (wh != &tr->wh)
		memmove(&tr->wh, wh, hdrlen);
764 765
	if (hdrlen != sizeof(tr->wh))
		memset(((void *)&tr->wh) + hdrlen, 0, sizeof(tr->wh) - hdrlen);
766 767 768 769 770 771

	/*
	 * 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.
	 */
772
	tr->fwlen = cpu_to_le16(skb->len - sizeof(*tr) + tail_pad);
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 809 810 811 812 813 814 815 816 817
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);
}
818 819

/*
820
 * Packet reception for 88w8366 AP firmware.
821
 */
822
struct mwl8k_rxd_8366_ap {
823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
	__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;
838
} __packed;
839

840 841 842
#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)
843

844
#define MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST	0x80
845

846 847 848 849 850 851 852
/* 8366 AP rx_status bits */
#define MWL8K_8366_AP_RXSTAT_DECRYPT_ERR_MASK		0x80
#define MWL8K_8366_AP_RXSTAT_GENERAL_DECRYPT_ERR	0xFF
#define MWL8K_8366_AP_RXSTAT_TKIP_DECRYPT_MIC_ERR	0x02
#define MWL8K_8366_AP_RXSTAT_WEP_DECRYPT_ICV_ERR	0x04
#define MWL8K_8366_AP_RXSTAT_TKIP_DECRYPT_ICV_ERR	0x08

853
static void mwl8k_rxd_8366_ap_init(void *_rxd, dma_addr_t next_dma_addr)
854
{
855
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
856 857

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
858
	rxd->rx_ctrl = MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST;
859 860
}

861
static void mwl8k_rxd_8366_ap_refill(void *_rxd, dma_addr_t addr, int len)
862
{
863
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
864 865 866 867 868 869 870 871

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

static int
872
mwl8k_rxd_8366_ap_process(void *_rxd, struct ieee80211_rx_status *status,
873
			  __le16 *qos, s8 *noise)
874
{
875
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
876

877
	if (!(rxd->rx_ctrl & MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST))
878 879 880 881 882 883
		return -1;
	rmb();

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

	status->signal = -rxd->rssi;
884
	*noise = -rxd->noise_floor;
885

886
	if (rxd->rate & MWL8K_8366_AP_RATE_INFO_MCS_FORMAT) {
887
		status->flag |= RX_FLAG_HT;
888
		if (rxd->rate & MWL8K_8366_AP_RATE_INFO_40MHZ)
889
			status->flag |= RX_FLAG_40MHZ;
890
		status->rate_idx = MWL8K_8366_AP_RATE_INFO_RATEID(rxd->rate);
891 892 893
	} else {
		int i;

894 895
		for (i = 0; i < ARRAY_SIZE(mwl8k_rates_24); i++) {
			if (mwl8k_rates_24[i].hw_value == rxd->rate) {
896 897 898 899 900 901
				status->rate_idx = i;
				break;
			}
		}
	}

902 903 904 905 906 907 908
	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;
	}
909 910
	status->freq = ieee80211_channel_to_frequency(rxd->channel,
						      status->band);
911

912 913
	*qos = rxd->qos_control;

914 915 916 917 918
	if ((rxd->rx_status != MWL8K_8366_AP_RXSTAT_GENERAL_DECRYPT_ERR) &&
	    (rxd->rx_status & MWL8K_8366_AP_RXSTAT_DECRYPT_ERR_MASK) &&
	    (rxd->rx_status & MWL8K_8366_AP_RXSTAT_TKIP_DECRYPT_MIC_ERR))
		status->flag |= RX_FLAG_MMIC_ERROR;

919 920 921
	return le16_to_cpu(rxd->pkt_len);
}

922 923 924 925 926
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,
927 928 929
};

/*
930
 * Packet reception for STA firmware.
931
 */
932
struct mwl8k_rxd_sta {
933 934 935 936
	__le16 pkt_len;
	__u8 link_quality;
	__u8 noise_level;
	__le32 pkt_phys_addr;
937
	__le32 next_rxd_phys_addr;
938 939 940 941 942 943 944 945 946
	__le16 qos_control;
	__le16 rate_info;
	__le32 pad0[4];
	__u8 rssi;
	__u8 channel;
	__le16 pad1;
	__u8 rx_ctrl;
	__u8 rx_status;
	__u8 pad2[2];
947
} __packed;
948

949 950 951 952 953 954
#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
955

956
#define MWL8K_STA_RX_CTRL_OWNED_BY_HOST		0x02
957 958 959 960 961
#define MWL8K_STA_RX_CTRL_DECRYPT_ERROR		0x04
/* ICV=0 or MIC=1 */
#define MWL8K_STA_RX_CTRL_DEC_ERR_TYPE		0x08
/* Key is uploaded only in failure case */
#define MWL8K_STA_RX_CTRL_KEY_INDEX			0x30
962

963
static void mwl8k_rxd_sta_init(void *_rxd, dma_addr_t next_dma_addr)
964
{
965
	struct mwl8k_rxd_sta *rxd = _rxd;
966 967

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
968
	rxd->rx_ctrl = MWL8K_STA_RX_CTRL_OWNED_BY_HOST;
969 970
}

971
static void mwl8k_rxd_sta_refill(void *_rxd, dma_addr_t addr, int len)
972
{
973
	struct mwl8k_rxd_sta *rxd = _rxd;
974 975 976 977 978 979 980 981

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

static int
982
mwl8k_rxd_sta_process(void *_rxd, struct ieee80211_rx_status *status,
983
		       __le16 *qos, s8 *noise)
984
{
985
	struct mwl8k_rxd_sta *rxd = _rxd;
986 987
	u16 rate_info;

988
	if (!(rxd->rx_ctrl & MWL8K_STA_RX_CTRL_OWNED_BY_HOST))
989 990 991 992 993 994 995 996
		return -1;
	rmb();

	rate_info = le16_to_cpu(rxd->rate_info);

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

	status->signal = -rxd->rssi;
997
	*noise = -rxd->noise_level;
998 999
	status->antenna = MWL8K_STA_RATE_INFO_ANTSELECT(rate_info);
	status->rate_idx = MWL8K_STA_RATE_INFO_RATEID(rate_info);
1000

1001
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTPRE)
1002
		status->flag |= RX_FLAG_SHORTPRE;
1003
	if (rate_info & MWL8K_STA_RATE_INFO_40MHZ)
1004
		status->flag |= RX_FLAG_40MHZ;
1005
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTGI)
1006
		status->flag |= RX_FLAG_SHORT_GI;
1007
	if (rate_info & MWL8K_STA_RATE_INFO_MCS_FORMAT)
1008 1009
		status->flag |= RX_FLAG_HT;

1010 1011 1012 1013 1014 1015 1016
	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;
	}
1017 1018
	status->freq = ieee80211_channel_to_frequency(rxd->channel,
						      status->band);
1019

1020
	*qos = rxd->qos_control;
1021 1022 1023
	if ((rxd->rx_ctrl & MWL8K_STA_RX_CTRL_DECRYPT_ERROR) &&
	    (rxd->rx_ctrl & MWL8K_STA_RX_CTRL_DEC_ERR_TYPE))
		status->flag |= RX_FLAG_MMIC_ERROR;
1024

1025 1026 1027
	return le16_to_cpu(rxd->pkt_len);
}

1028 1029 1030 1031 1032
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,
1033 1034 1035
};


1036 1037 1038 1039 1040 1041 1042 1043 1044 1045
#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;

1046 1047 1048
	rxq->rxd_count = 0;
	rxq->head = 0;
	rxq->tail = 0;
1049

1050
	size = MWL8K_RX_DESCS * priv->rxd_ops->rxd_size;
1051

1052 1053
	rxq->rxd = pci_alloc_consistent(priv->pdev, size, &rxq->rxd_dma);
	if (rxq->rxd == NULL) {
1054
		wiphy_err(hw->wiphy, "failed to alloc RX descriptors\n");
1055 1056
		return -ENOMEM;
	}
1057
	memset(rxq->rxd, 0, size);
1058

1059 1060
	rxq->buf = kmalloc(MWL8K_RX_DESCS * sizeof(*rxq->buf), GFP_KERNEL);
	if (rxq->buf == NULL) {
1061
		wiphy_err(hw->wiphy, "failed to alloc RX skbuff list\n");
1062
		pci_free_consistent(priv->pdev, size, rxq->rxd, rxq->rxd_dma);
1063 1064
		return -ENOMEM;
	}
1065
	memset(rxq->buf, 0, MWL8K_RX_DESCS * sizeof(*rxq->buf));
1066 1067

	for (i = 0; i < MWL8K_RX_DESCS; i++) {
1068 1069
		int desc_size;
		void *rxd;
1070
		int nexti;
1071 1072 1073 1074
		dma_addr_t next_dma_addr;

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

1076 1077 1078 1079
		nexti = i + 1;
		if (nexti == MWL8K_RX_DESCS)
			nexti = 0;
		next_dma_addr = rxq->rxd_dma + (nexti * desc_size);
1080

1081
		priv->rxd_ops->rxd_init(rxd, next_dma_addr);
1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
	}

	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;
1094
	while (rxq->rxd_count < MWL8K_RX_DESCS && limit--) {
1095
		struct sk_buff *skb;
1096
		dma_addr_t addr;
1097
		int rx;
1098
		void *rxd;
1099 1100 1101 1102 1103

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

1104 1105
		addr = pci_map_single(priv->pdev, skb->data,
				      MWL8K_RX_MAXSZ, DMA_FROM_DEVICE);
1106

1107 1108 1109 1110
		rxq->rxd_count++;
		rx = rxq->tail++;
		if (rxq->tail == MWL8K_RX_DESCS)
			rxq->tail = 0;
1111
		rxq->buf[rx].skb = skb;
1112
		dma_unmap_addr_set(&rxq->buf[rx], dma, addr);
1113 1114 1115

		rxd = rxq->rxd + (rx * priv->rxd_ops->rxd_size);
		priv->rxd_ops->rxd_refill(rxd, addr, MWL8K_RX_MAXSZ);
1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130

		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++) {
1131 1132
		if (rxq->buf[i].skb != NULL) {
			pci_unmap_single(priv->pdev,
1133
					 dma_unmap_addr(&rxq->buf[i], dma),
1134
					 MWL8K_RX_MAXSZ, PCI_DMA_FROMDEVICE);
1135
			dma_unmap_addr_set(&rxq->buf[i], dma, 0);
1136 1137 1138

			kfree_skb(rxq->buf[i].skb);
			rxq->buf[i].skb = NULL;
1139 1140 1141
		}
	}

1142 1143
	kfree(rxq->buf);
	rxq->buf = NULL;
1144 1145

	pci_free_consistent(priv->pdev,
1146
			    MWL8K_RX_DESCS * priv->rxd_ops->rxd_size,
1147 1148
			    rxq->rxd, rxq->rxd_dma);
	rxq->rxd = NULL;
1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
}


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

1164 1165
static inline void mwl8k_save_beacon(struct ieee80211_hw *hw,
				     struct sk_buff *skb)
1166
{
1167 1168
	struct mwl8k_priv *priv = hw->priv;

1169
	priv->capture_beacon = false;
1170
	memset(priv->capture_bssid, 0, ETH_ALEN);
1171 1172 1173 1174 1175 1176 1177 1178

	/*
	 * 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)
1179
		ieee80211_queue_work(hw, &priv->finalize_join_worker);
1180 1181
}

1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
static inline struct mwl8k_vif *mwl8k_find_vif_bss(struct list_head *vif_list,
						   u8 *bssid)
{
	struct mwl8k_vif *mwl8k_vif;

	list_for_each_entry(mwl8k_vif,
			    vif_list, list) {
		if (memcmp(bssid, mwl8k_vif->bssid,
			   ETH_ALEN) == 0)
			return mwl8k_vif;
	}

	return NULL;
}

1197 1198 1199
static int rxq_process(struct ieee80211_hw *hw, int index, int limit)
{
	struct mwl8k_priv *priv = hw->priv;
1200
	struct mwl8k_vif *mwl8k_vif = NULL;
1201 1202 1203 1204
	struct mwl8k_rx_queue *rxq = priv->rxq + index;
	int processed;

	processed = 0;
1205
	while (rxq->rxd_count && limit--) {
1206
		struct sk_buff *skb;
1207 1208
		void *rxd;
		int pkt_len;
1209
		struct ieee80211_rx_status status;
1210
		struct ieee80211_hdr *wh;
1211
		__le16 qos;
1212

1213
		skb = rxq->buf[rxq->head].skb;
1214 1215
		if (skb == NULL)
			break;
1216 1217 1218

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

1219 1220
		pkt_len = priv->rxd_ops->rxd_process(rxd, &status, &qos,
							&priv->noise);
1221 1222 1223
		if (pkt_len < 0)
			break;

1224 1225 1226
		rxq->buf[rxq->head].skb = NULL;

		pci_unmap_single(priv->pdev,
1227
				 dma_unmap_addr(&rxq->buf[rxq->head], dma),
1228
				 MWL8K_RX_MAXSZ, PCI_DMA_FROMDEVICE);
1229
		dma_unmap_addr_set(&rxq->buf[rxq->head], dma, 0);
1230

1231 1232 1233 1234
		rxq->head++;
		if (rxq->head == MWL8K_RX_DESCS)
			rxq->head = 0;

1235
		rxq->rxd_count--;
1236

1237
		wh = &((struct mwl8k_dma_data *)skb->data)->wh;
1238 1239

		/*
L
Lennert Buytenhek 已提交
1240 1241 1242
		 * 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.
1243
		 */
1244
		if (mwl8k_capture_bssid(priv, (void *)skb->data))
1245
			mwl8k_save_beacon(hw, skb);
1246

1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286
		if (ieee80211_has_protected(wh->frame_control)) {

			/* Check if hw crypto has been enabled for
			 * this bss. If yes, set the status flags
			 * accordingly
			 */
			mwl8k_vif = mwl8k_find_vif_bss(&priv->vif_list,
								wh->addr1);

			if (mwl8k_vif != NULL &&
			    mwl8k_vif->is_hw_crypto_enabled == true) {
				/*
				 * When MMIC ERROR is encountered
				 * by the firmware, payload is
				 * dropped and only 32 bytes of
				 * mwl8k Firmware header is sent
				 * to the host.
				 *
				 * We need to add four bytes of
				 * key information.  In it
				 * MAC80211 expects keyidx set to
				 * 0 for triggering Counter
				 * Measure of MMIC failure.
				 */
				if (status.flag & RX_FLAG_MMIC_ERROR) {
					struct mwl8k_dma_data *tr;
					tr = (struct mwl8k_dma_data *)skb->data;
					memset((void *)&(tr->data), 0, 4);
					pkt_len += 4;
				}

				if (!ieee80211_is_auth(wh->frame_control))
					status.flag |= RX_FLAG_IV_STRIPPED |
						       RX_FLAG_DECRYPTED |
						       RX_FLAG_MMIC_STRIPPED;
			}
		}

		skb_put(skb, pkt_len);
		mwl8k_remove_dma_header(skb, qos);
1287 1288
		memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
		ieee80211_rx_irqsafe(hw, skb);
1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306

		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

1307 1308 1309 1310 1311 1312
#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

1313 1314 1315 1316 1317 1318 1319
struct mwl8k_tx_desc {
	__le32 status;
	__u8 data_rate;
	__u8 tx_priority;
	__le16 qos_control;
	__le32 pkt_phys_addr;
	__le16 pkt_len;
1320
	__u8 dest_MAC_addr[ETH_ALEN];
1321
	__le32 next_txd_phys_addr;
1322 1323 1324
	__le32 reserved;
	__le16 rate_info;
	__u8 peer_id;
1325
	__u8 tx_frag_cnt;
1326
} __packed;
1327 1328 1329 1330 1331 1332 1333 1334 1335 1336

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

1337
	txq->len = 0;
1338 1339
	txq->head = 0;
	txq->tail = 0;
1340 1341 1342

	size = MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc);

1343 1344
	txq->txd = pci_alloc_consistent(priv->pdev, size, &txq->txd_dma);
	if (txq->txd == NULL) {
1345
		wiphy_err(hw->wiphy, "failed to alloc TX descriptors\n");
1346 1347
		return -ENOMEM;
	}
1348
	memset(txq->txd, 0, size);
1349

1350 1351
	txq->skb = kmalloc(MWL8K_TX_DESCS * sizeof(*txq->skb), GFP_KERNEL);
	if (txq->skb == NULL) {
1352
		wiphy_err(hw->wiphy, "failed to alloc TX skbuff list\n");
1353
		pci_free_consistent(priv->pdev, size, txq->txd, txq->txd_dma);
1354 1355
		return -ENOMEM;
	}
1356
	memset(txq->skb, 0, MWL8K_TX_DESCS * sizeof(*txq->skb));
1357 1358 1359 1360 1361

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

1362
		tx_desc = txq->txd + i;
1363 1364 1365
		nexti = (i + 1) % MWL8K_TX_DESCS;

		tx_desc->status = 0;
1366 1367
		tx_desc->next_txd_phys_addr =
			cpu_to_le32(txq->txd_dma + nexti * sizeof(*tx_desc));
1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381
	}

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

1382
static void mwl8k_dump_tx_rings(struct ieee80211_hw *hw)
1383
{
1384 1385 1386 1387 1388 1389 1390 1391 1392 1393
	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;

1394
		for (desc = 0; desc < MWL8K_TX_DESCS; desc++) {
1395 1396
			struct mwl8k_tx_desc *tx_desc = txq->txd + desc;
			u32 status;
1397

1398
			status = le32_to_cpu(tx_desc->status);
1399
			if (status & MWL8K_TXD_STATUS_FW_OWNED)
1400
				fw_owned++;
1401
			else
1402
				drv_owned++;
1403 1404

			if (tx_desc->pkt_len == 0)
1405
				unused++;
1406 1407
		}

1408 1409 1410 1411 1412 1413
		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);
1414
	}
1415 1416
}

1417
/*
1418
 * Must be called with priv->fw_mutex held and tx queues stopped.
1419
 */
1420
#define MWL8K_TX_WAIT_TIMEOUT_MS	5000
1421

1422
static int mwl8k_tx_wait_empty(struct ieee80211_hw *hw)
1423 1424
{
	struct mwl8k_priv *priv = hw->priv;
1425
	DECLARE_COMPLETION_ONSTACK(tx_wait);
1426 1427
	int retry;
	int rc;
1428 1429 1430

	might_sleep();

1431 1432 1433 1434 1435 1436 1437 1438 1439 1440
	/*
	 * 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;

1441
	spin_lock_bh(&priv->tx_lock);
1442 1443 1444 1445
	priv->tx_wait = &tx_wait;
	while (!rc) {
		int oldcount;
		unsigned long timeout;
1446

1447
		oldcount = priv->pending_tx_pkts;
1448

1449
		spin_unlock_bh(&priv->tx_lock);
1450
		timeout = wait_for_completion_timeout(&tx_wait,
1451
			    msecs_to_jiffies(MWL8K_TX_WAIT_TIMEOUT_MS));
1452
		spin_lock_bh(&priv->tx_lock);
1453 1454 1455 1456

		if (timeout) {
			WARN_ON(priv->pending_tx_pkts);
			if (retry) {
1457
				wiphy_notice(hw->wiphy, "tx rings drained\n");
1458 1459 1460 1461 1462
			}
			break;
		}

		if (priv->pending_tx_pkts < oldcount) {
1463 1464 1465
			wiphy_notice(hw->wiphy,
				     "waiting for tx rings to drain (%d -> %d pkts)\n",
				     oldcount, priv->pending_tx_pkts);
1466 1467 1468 1469
			retry = 1;
			continue;
		}

1470 1471
		priv->tx_wait = NULL;

1472 1473
		wiphy_err(hw->wiphy, "tx rings stuck for %d ms\n",
			  MWL8K_TX_WAIT_TIMEOUT_MS);
1474 1475 1476
		mwl8k_dump_tx_rings(hw);

		rc = -ETIMEDOUT;
1477
	}
1478
	spin_unlock_bh(&priv->tx_lock);
1479

1480
	return rc;
1481 1482
}

1483 1484 1485 1486
#define MWL8K_TXD_SUCCESS(status)				\
	((status) & (MWL8K_TXD_STATUS_OK |			\
		     MWL8K_TXD_STATUS_OK_RETRY |		\
		     MWL8K_TXD_STATUS_OK_MORE_RETRY))
1487

1488 1489
static int
mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int limit, int force)
1490 1491 1492
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_tx_queue *txq = priv->txq + index;
1493
	int processed;
1494

1495
	processed = 0;
1496
	while (txq->len > 0 && limit--) {
1497 1498 1499
		int tx;
		struct mwl8k_tx_desc *tx_desc;
		unsigned long addr;
1500
		int size;
1501 1502 1503 1504
		struct sk_buff *skb;
		struct ieee80211_tx_info *info;
		u32 status;

1505 1506
		tx = txq->head;
		tx_desc = txq->txd + tx;
1507 1508 1509 1510 1511 1512 1513 1514 1515 1516

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

1517
		txq->head = (tx + 1) % MWL8K_TX_DESCS;
1518 1519
		BUG_ON(txq->len == 0);
		txq->len--;
1520 1521 1522
		priv->pending_tx_pkts--;

		addr = le32_to_cpu(tx_desc->pkt_phys_addr);
1523
		size = le16_to_cpu(tx_desc->pkt_len);
1524 1525
		skb = txq->skb[tx];
		txq->skb[tx] = NULL;
1526 1527 1528 1529

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

1530
		mwl8k_remove_dma_header(skb, tx_desc->qos_control);
1531 1532 1533 1534 1535 1536 1537

		/* 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);
1538 1539 1540 1541 1542 1543 1544

		/* Rate control is happening in the firmware.
		 * Ensure no tx rate is being reported.
		 */
                info->status.rates[0].idx = -1;
                info->status.rates[0].count = 1;

1545
		if (MWL8K_TXD_SUCCESS(status))
1546 1547 1548 1549
			info->flags |= IEEE80211_TX_STAT_ACK;

		ieee80211_tx_status_irqsafe(hw, skb);

1550
		processed++;
1551 1552
	}

1553
	if (processed && priv->radio_on && !mutex_is_locked(&priv->fw_mutex))
1554
		ieee80211_wake_queue(hw, index);
1555 1556

	return processed;
1557 1558 1559 1560 1561 1562 1563 1564
}

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

1565
	mwl8k_txq_reclaim(hw, index, INT_MAX, 1);
1566

1567 1568
	kfree(txq->skb);
	txq->skb = NULL;
1569 1570 1571

	pci_free_consistent(priv->pdev,
			    MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc),
1572 1573
			    txq->txd, txq->txd_dma);
	txq->txd = NULL;
1574 1575 1576 1577 1578 1579 1580
}

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;
1581
	struct mwl8k_vif *mwl8k_vif;
1582 1583 1584 1585
	struct ieee80211_hdr *wh;
	struct mwl8k_tx_queue *txq;
	struct mwl8k_tx_desc *tx;
	dma_addr_t dma;
1586 1587 1588
	u32 txstatus;
	u8 txdatarate;
	u16 qos;
1589

1590 1591 1592 1593 1594
	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;
1595

1596 1597 1598 1599 1600
	if (priv->ap_fw)
		mwl8k_encapsulate_tx_frame(skb);
	else
		mwl8k_add_dma_header(skb, 0);

1601
	wh = &((struct mwl8k_dma_data *)skb->data)->wh;
1602 1603 1604 1605 1606 1607

	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);
1608 1609
		wh->seq_ctrl |= cpu_to_le16(mwl8k_vif->seqno);
		mwl8k_vif->seqno += 0x10;
1610 1611
	}

1612 1613 1614 1615 1616 1617
	/* 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;
1618
		qos |= MWL8K_QOS_QLEN_UNSPEC | MWL8K_QOS_EOSP;
1619 1620 1621 1622 1623
	} else if (ieee80211_is_data(wh->frame_control)) {
		txdatarate = 1;
		if (is_multicast_ether_addr(wh->addr1))
			txstatus |= MWL8K_TXD_STATUS_MULTICAST_TX;

1624
		qos &= ~MWL8K_QOS_ACK_POLICY_MASK;
1625
		if (tx_info->flags & IEEE80211_TX_CTL_AMPDU)
1626
			qos |= MWL8K_QOS_ACK_POLICY_BLOCKACK;
1627
		else
1628
			qos |= MWL8K_QOS_ACK_POLICY_NORMAL;
1629
	}
1630 1631 1632 1633 1634

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

	if (pci_dma_mapping_error(priv->pdev, dma)) {
1635 1636
		wiphy_debug(hw->wiphy,
			    "failed to dma map skb, dropping TX frame.\n");
1637
		dev_kfree_skb(skb);
1638 1639 1640
		return NETDEV_TX_OK;
	}

1641
	spin_lock_bh(&priv->tx_lock);
1642

1643
	txq = priv->txq + index;
1644

1645 1646
	BUG_ON(txq->skb[txq->tail] != NULL);
	txq->skb[txq->tail] = skb;
1647

1648
	tx = txq->txd + txq->tail;
1649 1650
	tx->data_rate = txdatarate;
	tx->tx_priority = index;
1651 1652 1653
	tx->qos_control = cpu_to_le16(qos);
	tx->pkt_phys_addr = cpu_to_le32(dma);
	tx->pkt_len = cpu_to_le16(skb->len);
1654
	tx->rate_info = 0;
1655 1656 1657 1658
	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;
1659
	wmb();
1660 1661
	tx->status = cpu_to_le32(MWL8K_TXD_STATUS_FW_OWNED | txstatus);

1662
	txq->len++;
1663 1664
	priv->pending_tx_pkts++;

1665 1666 1667
	txq->tail++;
	if (txq->tail == MWL8K_TX_DESCS)
		txq->tail = 0;
1668

1669
	if (txq->head == txq->tail)
1670 1671
		ieee80211_stop_queue(hw, index);

1672
	mwl8k_tx_start(priv);
1673 1674 1675 1676 1677 1678 1679

	spin_unlock_bh(&priv->tx_lock);

	return NETDEV_TX_OK;
}


1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733
/*
 * 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);
	}
}


1734 1735 1736 1737
/*
 * Command processing.
 */

1738 1739
/* Timeout firmware commands after 10s */
#define MWL8K_CMD_TIMEOUT_MS	10000
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751

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

1752
	cmd->result = (__force __le16) 0xffff;
1753 1754 1755 1756 1757 1758
	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;

1759
	rc = mwl8k_fw_lock(hw);
1760 1761 1762
	if (rc) {
		pci_unmap_single(priv->pdev, dma_addr, dma_size,
						PCI_DMA_BIDIRECTIONAL);
1763
		return rc;
1764
	}
1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775

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

1776 1777 1778 1779
	priv->hostcmd_wait = NULL;

	mwl8k_fw_unlock(hw);

1780 1781 1782
	pci_unmap_single(priv->pdev, dma_addr, dma_size,
					PCI_DMA_BIDIRECTIONAL);

1783
	if (!timeout) {
1784
		wiphy_err(hw->wiphy, "Command %s timeout after %u ms\n",
1785 1786
			  mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
			  MWL8K_CMD_TIMEOUT_MS);
1787 1788
		rc = -ETIMEDOUT;
	} else {
1789 1790 1791 1792
		int ms;

		ms = MWL8K_CMD_TIMEOUT_MS - jiffies_to_msecs(timeout);

1793
		rc = cmd->result ? -EINVAL : 0;
1794
		if (rc)
1795
			wiphy_err(hw->wiphy, "Command %s error 0x%x\n",
1796 1797
				  mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
				  le16_to_cpu(cmd->result));
1798
		else if (ms > 2000)
1799
			wiphy_notice(hw->wiphy, "Command %s took %d ms\n",
1800 1801 1802
				     mwl8k_cmd_name(cmd->code,
						    buf, sizeof(buf)),
				     ms);
1803 1804 1805 1806 1807
	}

	return rc;
}

1808 1809 1810 1811 1812 1813 1814 1815 1816
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);
}

1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838
/*
 * 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;
}

1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857
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;
}

1858
/*
1859
 * CMD_GET_HW_SPEC (STA version).
1860
 */
1861
struct mwl8k_cmd_get_hw_spec_sta {
1862 1863 1864 1865
	struct mwl8k_cmd_pkt header;
	__u8 hw_rev;
	__u8 host_interface;
	__le16 num_mcaddrs;
1866
	__u8 perm_addr[ETH_ALEN];
1867 1868 1869 1870 1871 1872 1873 1874 1875 1876
	__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;
1877
	__le32 total_rxd;
1878
} __packed;
1879

1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891
#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
1892 1893 1894
#define MWL8K_CAP_BAND_MASK		0x00000007
#define MWL8K_CAP_5GHZ			0x00000004
#define MWL8K_CAP_2GHZ4			0x00000001
1895

1896 1897 1898
static void
mwl8k_set_ht_caps(struct ieee80211_hw *hw,
		  struct ieee80211_supported_band *band, u32 cap)
1899 1900 1901 1902
{
	int rx_streams;
	int tx_streams;

1903
	band->ht_cap.ht_supported = 1;
1904 1905

	if (cap & MWL8K_CAP_MAX_AMSDU)
1906
		band->ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
1907
	if (cap & MWL8K_CAP_GREENFIELD)
1908
		band->ht_cap.cap |= IEEE80211_HT_CAP_GRN_FLD;
1909 1910
	if (cap & MWL8K_CAP_AMPDU) {
		hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
1911 1912
		band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
		band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
1913 1914
	}
	if (cap & MWL8K_CAP_RX_STBC)
1915
		band->ht_cap.cap |= IEEE80211_HT_CAP_RX_STBC;
1916
	if (cap & MWL8K_CAP_TX_STBC)
1917
		band->ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
1918
	if (cap & MWL8K_CAP_SHORTGI_40MHZ)
1919
		band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
1920
	if (cap & MWL8K_CAP_SHORTGI_20MHZ)
1921
		band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
1922
	if (cap & MWL8K_CAP_DELAY_BA)
1923
		band->ht_cap.cap |= IEEE80211_HT_CAP_DELAY_BA;
1924
	if (cap & MWL8K_CAP_40MHZ)
1925
		band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
1926 1927 1928 1929

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

1930
	band->ht_cap.mcs.rx_mask[0] = 0xff;
1931
	if (rx_streams >= 2)
1932
		band->ht_cap.mcs.rx_mask[1] = 0xff;
1933
	if (rx_streams >= 3)
1934 1935 1936
		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;
1937 1938

	if (rx_streams != tx_streams) {
1939 1940
		band->ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
		band->ht_cap.mcs.tx_params |= (tx_streams - 1) <<
1941 1942 1943 1944
				IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
	}
}

1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962
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);
	}
}

1963
static int mwl8k_cmd_get_hw_spec_sta(struct ieee80211_hw *hw)
1964 1965
{
	struct mwl8k_priv *priv = hw->priv;
1966
	struct mwl8k_cmd_get_hw_spec_sta *cmd;
1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978
	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);
1979
	cmd->rx_queue_ptr = cpu_to_le32(priv->rxq[0].rxd_dma);
1980
	cmd->num_tx_queues = cpu_to_le32(MWL8K_TX_QUEUES);
1981
	for (i = 0; i < MWL8K_TX_QUEUES; i++)
1982
		cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[i].txd_dma);
1983
	cmd->num_tx_desc_per_queue = cpu_to_le32(MWL8K_TX_DESCS);
1984
	cmd->total_rxd = cpu_to_le32(MWL8K_RX_DESCS);
1985 1986 1987 1988 1989 1990

	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);
1991
		priv->fw_rev = le32_to_cpu(cmd->fw_rev);
1992
		priv->hw_rev = cmd->hw_rev;
1993
		mwl8k_set_caps(hw, le32_to_cpu(cmd->caps));
1994 1995
		priv->ap_macids_supported = 0x00000000;
		priv->sta_macids_supported = 0x00000001;
1996 1997 1998 1999 2000 2001
	}

	kfree(cmd);
	return rc;
}

2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019 2020 2021
/*
 * 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;
2022
	__le32 fw_api_version;
2023
} __packed;
2024 2025 2026 2027 2028 2029

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;
2030
	u32 api_version;
2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046

	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;

2047 2048 2049 2050 2051 2052 2053 2054 2055 2056
		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;
		}
2057 2058 2059 2060
		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;
2061
		mwl8k_setup_2ghz_band(hw);
2062 2063
		priv->ap_macids_supported = 0x000000ff;
		priv->sta_macids_supported = 0x00000000;
2064 2065

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

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

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

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

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

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

2084
done:
2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107
	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;
2108
} __packed;
2109

2110 2111 2112
#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
2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132

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);
2133 2134 2135
	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);
2136 2137 2138 2139 2140 2141 2142 2143 2144
	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;
}

2145 2146 2147 2148 2149 2150 2151
/*
 * CMD_MAC_MULTICAST_ADR.
 */
struct mwl8k_cmd_mac_multicast_adr {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 numaddr;
2152
	__u8 addr[0][ETH_ALEN];
2153 2154
};

2155 2156 2157 2158
#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
2159

2160
static struct mwl8k_cmd_pkt *
L
Lennert Buytenhek 已提交
2161
__mwl8k_cmd_mac_multicast_adr(struct ieee80211_hw *hw, int allmulti,
2162
			      struct netdev_hw_addr_list *mc_list)
2163
{
2164
	struct mwl8k_priv *priv = hw->priv;
2165
	struct mwl8k_cmd_mac_multicast_adr *cmd;
2166
	int size;
2167 2168 2169 2170
	int mc_count = 0;

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

L
Lennert Buytenhek 已提交
2172
	if (allmulti || mc_count > priv->num_mcaddrs) {
2173 2174 2175
		allmulti = 1;
		mc_count = 0;
	}
2176 2177

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

2179
	cmd = kzalloc(size, GFP_ATOMIC);
2180
	if (cmd == NULL)
2181
		return NULL;
2182 2183 2184

	cmd->header.code = cpu_to_le16(MWL8K_CMD_MAC_MULTICAST_ADR);
	cmd->header.length = cpu_to_le16(size);
2185 2186 2187 2188 2189 2190
	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) {
2191 2192
		struct netdev_hw_addr *ha;
		int i = 0;
2193 2194 2195

		cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_MULTICAST);
		cmd->numaddr = cpu_to_le16(mc_count);
2196 2197
		netdev_hw_addr_list_for_each(ha, mc_list) {
			memcpy(cmd->addr[i], ha->addr, ETH_ALEN);
2198 2199 2200
		}
	}

2201
	return &cmd->header;
2202 2203 2204
}

/*
2205
 * CMD_GET_STAT.
2206
 */
2207
struct mwl8k_cmd_get_stat {
2208 2209
	struct mwl8k_cmd_pkt header;
	__le32 stats[64];
2210
} __packed;
2211 2212 2213 2214 2215 2216

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

2217 2218
static int mwl8k_cmd_get_stat(struct ieee80211_hw *hw,
			      struct ieee80211_low_level_stats *stats)
2219
{
2220
	struct mwl8k_cmd_get_stat *cmd;
2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244 2245 2246
	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;
}

/*
2247
 * CMD_RADIO_CONTROL.
2248
 */
2249
struct mwl8k_cmd_radio_control {
2250 2251 2252 2253
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 control;
	__le16 radio_on;
2254
} __packed;
2255

2256
static int
2257
mwl8k_cmd_radio_control(struct ieee80211_hw *hw, bool enable, bool force)
2258 2259
{
	struct mwl8k_priv *priv = hw->priv;
2260
	struct mwl8k_cmd_radio_control *cmd;
2261 2262
	int rc;

2263
	if (enable == priv->radio_on && !force)
2264 2265 2266 2267 2268 2269 2270 2271 2272
		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);
2273
	cmd->control = cpu_to_le16(priv->radio_short_preamble ? 3 : 1);
2274 2275 2276 2277 2278 2279
	cmd->radio_on = cpu_to_le16(enable ? 0x0001 : 0x0000);

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

	if (!rc)
2280
		priv->radio_on = enable;
2281 2282 2283 2284

	return rc;
}

2285
static int mwl8k_cmd_radio_disable(struct ieee80211_hw *hw)
2286
{
2287
	return mwl8k_cmd_radio_control(hw, 0, 0);
2288 2289
}

2290
static int mwl8k_cmd_radio_enable(struct ieee80211_hw *hw)
2291
{
2292
	return mwl8k_cmd_radio_control(hw, 1, 0);
2293 2294
}

2295 2296 2297
static int
mwl8k_set_radio_preamble(struct ieee80211_hw *hw, bool short_preamble)
{
2298
	struct mwl8k_priv *priv = hw->priv;
2299

2300
	priv->radio_short_preamble = short_preamble;
2301

2302
	return mwl8k_cmd_radio_control(hw, 1, 1);
2303 2304 2305
}

/*
2306
 * CMD_RF_TX_POWER.
2307
 */
2308
#define MWL8K_RF_TX_POWER_LEVEL_TOTAL	8
2309

2310
struct mwl8k_cmd_rf_tx_power {
2311 2312 2313 2314 2315
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 support_level;
	__le16 current_level;
	__le16 reserved;
2316
	__le16 power_level_list[MWL8K_RF_TX_POWER_LEVEL_TOTAL];
2317
} __packed;
2318

2319
static int mwl8k_cmd_rf_tx_power(struct ieee80211_hw *hw, int dBm)
2320
{
2321
	struct mwl8k_cmd_rf_tx_power *cmd;
2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338
	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;
}

2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 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 2394 2395 2396 2397
/*
 * 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;
}

2398 2399 2400 2401 2402 2403 2404
/*
 * CMD_RF_ANTENNA.
 */
struct mwl8k_cmd_rf_antenna {
	struct mwl8k_cmd_pkt header;
	__le16 antenna;
	__le16 mode;
2405
} __packed;
2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423 2424 2425 2426 2427 2428 2429 2430

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

2431 2432 2433 2434 2435 2436 2437 2438 2439
/*
 * CMD_SET_BEACON.
 */
struct mwl8k_cmd_set_beacon {
	struct mwl8k_cmd_pkt header;
	__le16 beacon_len;
	__u8 beacon[0];
};

2440 2441
static int mwl8k_cmd_set_beacon(struct ieee80211_hw *hw,
				struct ieee80211_vif *vif, u8 *beacon, int len)
2442 2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454
{
	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);

2455
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2456 2457 2458 2459 2460
	kfree(cmd);

	return rc;
}

2461 2462 2463 2464 2465
/*
 * CMD_SET_PRE_SCAN.
 */
struct mwl8k_cmd_set_pre_scan {
	struct mwl8k_cmd_pkt header;
2466
} __packed;
2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491

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;
2492
	__u8 bssid[ETH_ALEN];
2493
} __packed;
2494 2495

static int
2496
mwl8k_cmd_set_post_scan(struct ieee80211_hw *hw, const __u8 *mac)
2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507
{
	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;
2508
	memcpy(cmd->bssid, mac, ETH_ALEN);
2509 2510 2511 2512 2513 2514 2515 2516 2517 2518 2519 2520 2521 2522 2523

	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;
2524
} __packed;
2525 2526

static int mwl8k_cmd_set_rf_channel(struct ieee80211_hw *hw,
2527
				    struct ieee80211_conf *conf)
2528
{
2529
	struct ieee80211_channel *channel = conf->channel;
2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540
	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;
2541

2542
	if (channel->band == IEEE80211_BAND_2GHZ)
2543
		cmd->channel_flags |= cpu_to_le32(0x00000001);
2544 2545
	else if (channel->band == IEEE80211_BAND_5GHZ)
		cmd->channel_flags |= cpu_to_le32(0x00000004);
2546 2547 2548 2549 2550 2551 2552 2553

	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);
2554 2555 2556 2557 2558 2559 2560 2561

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

	return rc;
}

/*
2562
 * CMD_SET_AID.
2563
 */
2564 2565 2566 2567
#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
2568

2569 2570 2571
struct mwl8k_cmd_update_set_aid {
	struct	mwl8k_cmd_pkt header;
	__le16	aid;
2572

2573 2574 2575 2576
	 /* AP's MAC address (BSSID) */
	__u8	bssid[ETH_ALEN];
	__le16	protection_mode;
	__u8	supp_rates[14];
2577
} __packed;
2578

L
Lennert Buytenhek 已提交
2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590
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))
2591
			rates[j++] = mwl8k_rates_24[i].hw_value;
L
Lennert Buytenhek 已提交
2592 2593 2594
	}
}

2595
static int
L
Lennert Buytenhek 已提交
2596 2597
mwl8k_cmd_set_aid(struct ieee80211_hw *hw,
		  struct ieee80211_vif *vif, u32 legacy_rate_mask)
2598
{
2599 2600
	struct mwl8k_cmd_update_set_aid *cmd;
	u16 prot_mode;
2601 2602 2603 2604 2605 2606
	int rc;

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

2607
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_AID);
2608
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2609
	cmd->aid = cpu_to_le16(vif->bss_conf.aid);
2610
	memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN);
2611

2612
	if (vif->bss_conf.use_cts_prot) {
2613 2614
		prot_mode = MWL8K_FRAME_PROT_11G;
	} else {
2615
		switch (vif->bss_conf.ht_operation_mode &
2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628
			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);
2629

L
Lennert Buytenhek 已提交
2630
	legacy_rate_mask_to_array(cmd->supp_rates, legacy_rate_mask);
2631 2632 2633 2634 2635 2636 2637

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

	return rc;
}

2638
/*
2639
 * CMD_SET_RATE.
2640
 */
2641 2642 2643 2644 2645 2646 2647
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];
2648
} __packed;
2649

2650
static int
L
Lennert Buytenhek 已提交
2651
mwl8k_cmd_set_rate(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2652
		   u32 legacy_rate_mask, u8 *mcs_rates)
2653
{
2654
	struct mwl8k_cmd_set_rate *cmd;
2655 2656 2657 2658 2659 2660
	int rc;

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

2661
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATE);
2662
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
2663
	legacy_rate_mask_to_array(cmd->legacy_rates, legacy_rate_mask);
2664
	memcpy(cmd->mcs_set, mcs_rates, 16);
2665 2666 2667 2668 2669 2670 2671

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

	return rc;
}

2672
/*
2673
 * CMD_FINALIZE_JOIN.
2674
 */
2675 2676 2677
#define MWL8K_FJ_BEACON_MAXLEN	128

struct mwl8k_cmd_finalize_join {
2678
	struct mwl8k_cmd_pkt header;
2679 2680
	__le32 sleep_interval;	/* Number of beacon periods to sleep */
	__u8 beacon_data[MWL8K_FJ_BEACON_MAXLEN];
2681
} __packed;
2682

2683 2684
static int mwl8k_cmd_finalize_join(struct ieee80211_hw *hw, void *frame,
				   int framelen, int dtim)
2685
{
2686 2687 2688
	struct mwl8k_cmd_finalize_join *cmd;
	struct ieee80211_mgmt *payload = frame;
	int payload_len;
2689 2690 2691 2692 2693 2694
	int rc;

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

2695
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_FINALIZE_JOIN);
2696
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2697 2698 2699 2700 2701 2702 2703 2704 2705
	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);
2706 2707 2708 2709 2710 2711 2712 2713

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

	return rc;
}

/*
2714
 * CMD_SET_RTS_THRESHOLD.
2715
 */
2716
struct mwl8k_cmd_set_rts_threshold {
2717 2718
	struct mwl8k_cmd_pkt header;
	__le16 action;
2719
	__le16 threshold;
2720
} __packed;
2721

L
Lennert Buytenhek 已提交
2722 2723
static int
mwl8k_cmd_set_rts_threshold(struct ieee80211_hw *hw, int rts_thresh)
2724
{
2725
	struct mwl8k_cmd_set_rts_threshold *cmd;
2726 2727 2728 2729 2730 2731
	int rc;

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

2732
	cmd->header.code = cpu_to_le16(MWL8K_CMD_RTS_THRESHOLD);
2733
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
2734 2735
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->threshold = cpu_to_le16(rts_thresh);
2736 2737 2738 2739 2740 2741 2742 2743

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

	return rc;
}

/*
2744
 * CMD_SET_SLOT.
2745
 */
2746
struct mwl8k_cmd_set_slot {
2747 2748
	struct mwl8k_cmd_pkt header;
	__le16 action;
2749
	__u8 short_slot;
2750
} __packed;
2751

2752
static int mwl8k_cmd_set_slot(struct ieee80211_hw *hw, bool short_slot_time)
2753
{
2754
	struct mwl8k_cmd_set_slot *cmd;
2755 2756 2757 2758 2759 2760
	int rc;

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

2761
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_SLOT);
2762
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2763 2764
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->short_slot = short_slot_time;
2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783

	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;

2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800
	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;
2801

2802 2803
			/* Log exponent of min contention period: 0...15 */
			__u8 log_cw_min;
2804

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

2808 2809 2810 2811
			/* TX queue to configure */
			__u8 txq;
		} sta;
	};
2812
} __packed;
2813 2814 2815 2816 2817 2818 2819 2820 2821 2822

#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
2823 2824 2825
mwl8k_cmd_set_edca_params(struct ieee80211_hw *hw, __u8 qnum,
			  __u16 cw_min, __u16 cw_max,
			  __u8 aifs, __u16 txop)
2826
{
2827
	struct mwl8k_priv *priv = hw->priv;
2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838
	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);
2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849
	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;
	}
2850 2851 2852 2853 2854 2855 2856 2857

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

	return rc;
}

/*
2858
 * CMD_SET_WMM_MODE.
2859
 */
2860
struct mwl8k_cmd_set_wmm_mode {
2861
	struct mwl8k_cmd_pkt header;
2862
	__le16 action;
2863
} __packed;
2864

2865
static int mwl8k_cmd_set_wmm_mode(struct ieee80211_hw *hw, bool enable)
2866
{
2867 2868
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_cmd_set_wmm_mode *cmd;
2869 2870 2871 2872 2873 2874
	int rc;

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

2875
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_WMM_MODE);
2876
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2877
	cmd->action = cpu_to_le16(!!enable);
2878 2879 2880

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

2882 2883
	if (!rc)
		priv->wmm_enabled = enable;
2884 2885 2886 2887 2888

	return rc;
}

/*
2889
 * CMD_MIMO_CONFIG.
2890
 */
2891 2892 2893 2894 2895
struct mwl8k_cmd_mimo_config {
	struct mwl8k_cmd_pkt header;
	__le32 action;
	__u8 rx_antenna_map;
	__u8 tx_antenna_map;
2896
} __packed;
2897

2898
static int mwl8k_cmd_mimo_config(struct ieee80211_hw *hw, __u8 rx, __u8 tx)
2899
{
2900
	struct mwl8k_cmd_mimo_config *cmd;
2901 2902 2903 2904 2905 2906
	int rc;

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

2907
	cmd->header.code = cpu_to_le16(MWL8K_CMD_MIMO_CONFIG);
2908
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2909 2910 2911
	cmd->action = cpu_to_le32((u32)MWL8K_CMD_SET);
	cmd->rx_antenna_map = rx;
	cmd->tx_antenna_map = tx;
2912 2913 2914 2915 2916 2917 2918 2919

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

	return rc;
}

/*
2920
 * CMD_USE_FIXED_RATE (STA version).
2921
 */
2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935
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;
2936
} __packed;
2937

2938 2939
#define MWL8K_USE_AUTO_RATE	0x0002
#define MWL8K_UCAST_RATE	0
2940

2941
static int mwl8k_cmd_use_fixed_rate_sta(struct ieee80211_hw *hw)
2942
{
2943
	struct mwl8k_cmd_use_fixed_rate_sta *cmd;
2944 2945 2946 2947 2948 2949 2950 2951
	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));
2952 2953
	cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE);
	cmd->rate_type = cpu_to_le32(MWL8K_UCAST_RATE);
2954 2955 2956 2957 2958 2959 2960

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

	return rc;
}

2961 2962 2963 2964 2965 2966 2967 2968 2969 2970 2971 2972 2973 2974 2975 2976 2977
/*
 * 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;
2978
} __packed;
2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001

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

3002 3003 3004 3005 3006 3007
/*
 * CMD_ENABLE_SNIFFER.
 */
struct mwl8k_cmd_enable_sniffer {
	struct mwl8k_cmd_pkt header;
	__le32 action;
3008
} __packed;
3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036 3037 3038 3039 3040

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];
	};
3041
} __packed;
3042

3043 3044 3045 3046
#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
3047

3048 3049
static int mwl8k_cmd_set_mac_addr(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif, u8 *mac)
3050 3051
{
	struct mwl8k_priv *priv = hw->priv;
3052
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
3053
	struct mwl8k_cmd_set_mac_addr *cmd;
3054
	int mac_type;
3055 3056
	int rc;

3057 3058 3059 3060 3061 3062 3063 3064 3065 3066 3067 3068 3069
	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;
	}

3070 3071 3072 3073 3074 3075 3076
	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) {
3077
		cmd->mbss.mac_type = cpu_to_le16(mac_type);
3078 3079 3080 3081 3082
		memcpy(cmd->mbss.mac_addr, mac, ETH_ALEN);
	} else {
		memcpy(cmd->mac_addr, mac, ETH_ALEN);
	}

3083
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095
	kfree(cmd);

	return rc;
}

/*
 * CMD_SET_RATEADAPT_MODE.
 */
struct mwl8k_cmd_set_rate_adapt_mode {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 mode;
3096
} __packed;
3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117

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

3118 3119 3120 3121 3122 3123
/*
 * CMD_BSS_START.
 */
struct mwl8k_cmd_bss_start {
	struct mwl8k_cmd_pkt header;
	__le32 enable;
3124
} __packed;
3125

3126 3127
static int mwl8k_cmd_bss_start(struct ieee80211_hw *hw,
			       struct ieee80211_vif *vif, int enable)
3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139
{
	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);

3140
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3141 3142 3143 3144 3145
	kfree(cmd);

	return rc;
}

3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168
/*
 * 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;
3169
} __packed;
3170 3171 3172 3173 3174 3175 3176 3177 3178

#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;
3179
	u32 rates;
3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190 3191
	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);
3192 3193 3194 3195 3196
	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);
3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207
	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;
	}

3208
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3209 3210 3211 3212 3213
	kfree(cmd);

	return rc;
}

3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227
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);

3228
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3229 3230 3231 3232 3233
	kfree(cmd);

	return rc;
}

3234 3235 3236 3237 3238 3239 3240 3241 3242 3243 3244 3245 3246 3247 3248
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);

3249
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3250 3251 3252 3253 3254
	kfree(cmd);

	return rc;
}

3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335 3336 3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522
/*
 * CMD_UPDATE_ENCRYPTION.
 */

#define MAX_ENCR_KEY_LENGTH	16
#define MIC_KEY_LENGTH		8

struct mwl8k_cmd_update_encryption {
	struct mwl8k_cmd_pkt header;

	__le32 action;
	__le32 reserved;
	__u8 mac_addr[6];
	__u8 encr_type;

} __attribute__((packed));

struct mwl8k_cmd_set_key {
	struct mwl8k_cmd_pkt header;

	__le32 action;
	__le32 reserved;
	__le16 length;
	__le16 key_type_id;
	__le32 key_info;
	__le32 key_id;
	__le16 key_len;
	__u8 key_material[MAX_ENCR_KEY_LENGTH];
	__u8 tkip_tx_mic_key[MIC_KEY_LENGTH];
	__u8 tkip_rx_mic_key[MIC_KEY_LENGTH];
	__le16 tkip_rsc_low;
	__le32 tkip_rsc_high;
	__le16 tkip_tsc_low;
	__le32 tkip_tsc_high;
	__u8 mac_addr[6];
} __attribute__((packed));

enum {
	MWL8K_ENCR_ENABLE,
	MWL8K_ENCR_SET_KEY,
	MWL8K_ENCR_REMOVE_KEY,
	MWL8K_ENCR_SET_GROUP_KEY,
};

#define MWL8K_UPDATE_ENCRYPTION_TYPE_WEP	0
#define MWL8K_UPDATE_ENCRYPTION_TYPE_DISABLE	1
#define MWL8K_UPDATE_ENCRYPTION_TYPE_TKIP	4
#define MWL8K_UPDATE_ENCRYPTION_TYPE_MIXED	7
#define MWL8K_UPDATE_ENCRYPTION_TYPE_AES	8

enum {
	MWL8K_ALG_WEP,
	MWL8K_ALG_TKIP,
	MWL8K_ALG_CCMP,
};

#define MWL8K_KEY_FLAG_TXGROUPKEY	0x00000004
#define MWL8K_KEY_FLAG_PAIRWISE		0x00000008
#define MWL8K_KEY_FLAG_TSC_VALID	0x00000040
#define MWL8K_KEY_FLAG_WEP_TXKEY	0x01000000
#define MWL8K_KEY_FLAG_MICKEY_VALID	0x02000000

static int mwl8k_cmd_update_encryption_enable(struct ieee80211_hw *hw,
					      struct ieee80211_vif *vif,
					      u8 *addr,
					      u8 encr_type)
{
	struct mwl8k_cmd_update_encryption *cmd;
	int rc;

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

	cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_ENCRYPTION);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->action = cpu_to_le32(MWL8K_ENCR_ENABLE);
	memcpy(cmd->mac_addr, addr, ETH_ALEN);
	cmd->encr_type = encr_type;

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

	return rc;
}

static int mwl8k_encryption_set_cmd_info(struct mwl8k_cmd_set_key *cmd,
						u8 *addr,
						struct ieee80211_key_conf *key)
{
	cmd->header.code = cpu_to_le16(MWL8K_CMD_UPDATE_ENCRYPTION);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->length = cpu_to_le16(sizeof(*cmd) -
				offsetof(struct mwl8k_cmd_set_key, length));
	cmd->key_id = cpu_to_le32(key->keyidx);
	cmd->key_len = cpu_to_le16(key->keylen);
	memcpy(cmd->mac_addr, addr, ETH_ALEN);

	switch (key->cipher) {
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_WEP104:
		cmd->key_type_id = cpu_to_le16(MWL8K_ALG_WEP);
		if (key->keyidx == 0)
			cmd->key_info =	cpu_to_le32(MWL8K_KEY_FLAG_WEP_TXKEY);

		break;
	case WLAN_CIPHER_SUITE_TKIP:
		cmd->key_type_id = cpu_to_le16(MWL8K_ALG_TKIP);
		cmd->key_info =	(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
			? cpu_to_le32(MWL8K_KEY_FLAG_PAIRWISE)
			: cpu_to_le32(MWL8K_KEY_FLAG_TXGROUPKEY);
		cmd->key_info |= cpu_to_le32(MWL8K_KEY_FLAG_MICKEY_VALID
						| MWL8K_KEY_FLAG_TSC_VALID);
		break;
	case WLAN_CIPHER_SUITE_CCMP:
		cmd->key_type_id = cpu_to_le16(MWL8K_ALG_CCMP);
		cmd->key_info =	(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
			? cpu_to_le32(MWL8K_KEY_FLAG_PAIRWISE)
			: cpu_to_le32(MWL8K_KEY_FLAG_TXGROUPKEY);
		break;
	default:
		return -ENOTSUPP;
	}

	return 0;
}

static int mwl8k_cmd_encryption_set_key(struct ieee80211_hw *hw,
						struct ieee80211_vif *vif,
						u8 *addr,
						struct ieee80211_key_conf *key)
{
	struct mwl8k_cmd_set_key *cmd;
	int rc;
	int keymlen;
	u32 action;
	u8 idx;
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);

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

	rc = mwl8k_encryption_set_cmd_info(cmd, addr, key);
	if (rc < 0)
		goto done;

	idx = key->keyidx;

	if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
		action = MWL8K_ENCR_SET_KEY;
	else
		action = MWL8K_ENCR_SET_GROUP_KEY;

	switch (key->cipher) {
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_WEP104:
		if (!mwl8k_vif->wep_key_conf[idx].enabled) {
			memcpy(mwl8k_vif->wep_key_conf[idx].key, key,
						sizeof(*key) + key->keylen);
			mwl8k_vif->wep_key_conf[idx].enabled = 1;
		}

		keymlen = 0;
		action = MWL8K_ENCR_SET_KEY;
		break;
	case WLAN_CIPHER_SUITE_TKIP:
		keymlen = MAX_ENCR_KEY_LENGTH + 2 * MIC_KEY_LENGTH;
		break;
	case WLAN_CIPHER_SUITE_CCMP:
		keymlen = key->keylen;
		break;
	default:
		rc = -ENOTSUPP;
		goto done;
	}

	memcpy(cmd->key_material, key->key, keymlen);
	cmd->action = cpu_to_le32(action);

	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
done:
	kfree(cmd);

	return rc;
}

static int mwl8k_cmd_encryption_remove_key(struct ieee80211_hw *hw,
						struct ieee80211_vif *vif,
						u8 *addr,
						struct ieee80211_key_conf *key)
{
	struct mwl8k_cmd_set_key *cmd;
	int rc;
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);

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

	rc = mwl8k_encryption_set_cmd_info(cmd, addr, key);
	if (rc < 0)
		goto done;

	if (key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
			WLAN_CIPHER_SUITE_WEP104)
		mwl8k_vif->wep_key_conf[key->keyidx].enabled = 0;

	cmd->action = cpu_to_le32(MWL8K_ENCR_REMOVE_KEY);

	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
done:
	kfree(cmd);

	return rc;
}

static int mwl8k_set_key(struct ieee80211_hw *hw,
			 enum set_key_cmd cmd_param,
			 struct ieee80211_vif *vif,
			 struct ieee80211_sta *sta,
			 struct ieee80211_key_conf *key)
{
	int rc = 0;
	u8 encr_type;
	u8 *addr;
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);

	if (vif->type == NL80211_IFTYPE_STATION)
		return -EOPNOTSUPP;

	if (sta == NULL)
		addr = hw->wiphy->perm_addr;
	else
		addr = sta->addr;

	if (cmd_param == SET_KEY) {
		key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
		rc = mwl8k_cmd_encryption_set_key(hw, vif, addr, key);
		if (rc)
			goto out;

		if ((key->cipher == WLAN_CIPHER_SUITE_WEP40)
				|| (key->cipher == WLAN_CIPHER_SUITE_WEP104))
			encr_type = MWL8K_UPDATE_ENCRYPTION_TYPE_WEP;
		else
			encr_type = MWL8K_UPDATE_ENCRYPTION_TYPE_MIXED;

		rc = mwl8k_cmd_update_encryption_enable(hw, vif, addr,
								encr_type);
		if (rc)
			goto out;

		mwl8k_vif->is_hw_crypto_enabled = true;

	} else {
		rc = mwl8k_cmd_encryption_remove_key(hw, vif, addr, key);

		if (rc)
			goto out;

		mwl8k_vif->is_hw_crypto_enabled = false;

	}
out:
	return rc;
}

3523 3524 3525
/*
 * CMD_UPDATE_STADB.
 */
3526 3527 3528 3529
struct ewc_ht_info {
	__le16	control1;
	__le16	control2;
	__le16	control3;
3530
} __packed;
3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557 3558

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;
3559
} __packed;
3560

3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573
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;
3574
} __packed;
3575

3576 3577 3578 3579 3580 3581 3582
#define MWL8K_STA_DB_MODIFY_ENTRY	1
#define MWL8K_STA_DB_DEL_ENTRY		2

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

static int mwl8k_cmd_update_stadb_add(struct ieee80211_hw *hw,
L
Lennert Buytenhek 已提交
3583
				      struct ieee80211_vif *vif,
3584
				      struct ieee80211_sta *sta)
3585 3586
{
	struct mwl8k_cmd_update_stadb *cmd;
3587
	struct peer_capability_info *p;
3588
	u32 rates;
3589 3590 3591 3592 3593 3594 3595 3596
	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));
3597
	cmd->action = cpu_to_le32(MWL8K_STA_DB_MODIFY_ENTRY);
3598
	memcpy(cmd->peer_addr, sta->addr, ETH_ALEN);
3599

3600 3601 3602
	p = &cmd->peer_info;
	p->peer_type = MWL8K_PEER_TYPE_ACCESSPOINT;
	p->basic_caps = cpu_to_le16(vif->bss_conf.assoc_capability);
3603
	p->ht_support = sta->ht_cap.ht_supported;
3604
	p->ht_caps = cpu_to_le16(sta->ht_cap.cap);
3605 3606
	p->extended_ht_caps = (sta->ht_cap.ampdu_factor & 3) |
		((sta->ht_cap.ampdu_density & 7) << 2);
3607 3608 3609 3610 3611
	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);
3612
	memcpy(p->ht_rates, sta->ht_cap.mcs.rx_mask, 16);
3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634
	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);
3635
	memcpy(cmd->peer_addr, addr, ETH_ALEN);
3636

3637
	rc = mwl8k_post_cmd(hw, &cmd->header);
3638 3639 3640 3641 3642
	kfree(cmd);

	return rc;
}

3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656

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

3657 3658 3659 3660 3661
	if (status & MWL8K_A2H_INT_TX_DONE) {
		status &= ~MWL8K_A2H_INT_TX_DONE;
		tasklet_schedule(&priv->poll_tx_task);
	}

3662
	if (status & MWL8K_A2H_INT_RX_READY) {
3663 3664
		status &= ~MWL8K_A2H_INT_RX_READY;
		tasklet_schedule(&priv->poll_rx_task);
3665 3666
	}

3667 3668 3669
	if (status)
		iowrite32(~status, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);

3670
	if (status & MWL8K_A2H_INT_OPC_DONE) {
3671
		if (priv->hostcmd_wait != NULL)
3672 3673 3674 3675
			complete(priv->hostcmd_wait);
	}

	if (status & MWL8K_A2H_INT_QUEUE_EMPTY) {
3676
		if (!mutex_is_locked(&priv->fw_mutex) &&
3677
		    priv->radio_on && priv->pending_tx_pkts)
3678
			mwl8k_tx_start(priv);
3679 3680 3681 3682 3683
	}

	return IRQ_HANDLED;
}

3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712
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);
	}
}

3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730
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);
	}
}

3731 3732 3733 3734 3735 3736 3737 3738 3739 3740

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

3741
	if (!priv->radio_on) {
3742 3743
		wiphy_debug(hw->wiphy,
			    "dropped TX frame since radio disabled\n");
3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757
		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;

3758
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
3759 3760
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
3761
		wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
3762
		return -EIO;
3763 3764
	}

3765
	/* Enable TX reclaim and RX tasklets.  */
3766
	tasklet_enable(&priv->poll_tx_task);
3767
	tasklet_enable(&priv->poll_rx_task);
3768

3769
	/* Enable interrupts */
3770
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
3771

3772 3773
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
3774
		rc = mwl8k_cmd_radio_enable(hw);
3775

3776 3777
		if (!priv->ap_fw) {
			if (!rc)
3778
				rc = mwl8k_cmd_enable_sniffer(hw, 0);
3779

3780 3781 3782 3783 3784 3785 3786
			if (!rc)
				rc = mwl8k_cmd_set_pre_scan(hw);

			if (!rc)
				rc = mwl8k_cmd_set_post_scan(hw,
						"\x00\x00\x00\x00\x00\x00");
		}
3787 3788

		if (!rc)
3789
			rc = mwl8k_cmd_set_rateadapt_mode(hw, 0);
3790

3791
		if (!rc)
3792
			rc = mwl8k_cmd_set_wmm_mode(hw, 0);
3793

3794 3795 3796 3797 3798 3799
		mwl8k_fw_unlock(hw);
	}

	if (rc) {
		iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
		free_irq(priv->pdev->irq, hw);
3800
		tasklet_disable(&priv->poll_tx_task);
3801
		tasklet_disable(&priv->poll_rx_task);
3802
	}
3803 3804 3805 3806 3807 3808 3809 3810 3811

	return rc;
}

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

3812
	mwl8k_cmd_radio_disable(hw);
3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824

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

3825
	/* Stop TX reclaim and RX tasklets.  */
3826
	tasklet_disable(&priv->poll_tx_task);
3827
	tasklet_disable(&priv->poll_rx_task);
3828 3829 3830

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

3834 3835
static int mwl8k_reload_firmware(struct ieee80211_hw *hw, char *fw_image);

3836
static int mwl8k_add_interface(struct ieee80211_hw *hw,
3837
			       struct ieee80211_vif *vif)
3838 3839 3840
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_vif *mwl8k_vif;
3841
	u32 macids_supported;
3842 3843
	int macid, rc;
	struct mwl8k_device_info *di;
3844

3845 3846 3847
	/*
	 * Reject interface creation if sniffer mode is active, as
	 * STA operation is mutually exclusive with hardware sniffer
3848
	 * mode.  (Sniffer mode is only used on STA firmware.)
3849 3850
	 */
	if (priv->sniffer_enabled) {
3851 3852
		wiphy_info(hw->wiphy,
			   "unable to create STA interface because sniffer mode is enabled\n");
3853 3854 3855
		return -EINVAL;
	}

3856
	di = priv->device_info;
3857 3858
	switch (vif->type) {
	case NL80211_IFTYPE_AP:
3859 3860 3861 3862 3863 3864 3865 3866
		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;
		}
3867 3868 3869
		macids_supported = priv->ap_macids_supported;
		break;
	case NL80211_IFTYPE_STATION:
3870 3871 3872 3873 3874 3875 3876 3877
		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;
		}
3878 3879 3880 3881 3882 3883 3884 3885 3886 3887
		macids_supported = priv->sta_macids_supported;
		break;
	default:
		return -EINVAL;
	}

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

3888
	/* Setup driver private area. */
3889
	mwl8k_vif = MWL8K_VIF(vif);
3890
	memset(mwl8k_vif, 0, sizeof(*mwl8k_vif));
3891
	mwl8k_vif->vif = vif;
3892
	mwl8k_vif->macid = macid;
3893
	mwl8k_vif->seqno = 0;
3894 3895
	memcpy(mwl8k_vif->bssid, vif->addr, ETH_ALEN);
	mwl8k_vif->is_hw_crypto_enabled = false;
3896

3897 3898 3899 3900 3901 3902
	/* 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);

3903
	priv->macids_used |= 1 << mwl8k_vif->macid;
3904
	list_add_tail(&mwl8k_vif->list, &priv->vif_list);
3905 3906 3907 3908 3909

	return 0;
}

static void mwl8k_remove_interface(struct ieee80211_hw *hw,
3910
				   struct ieee80211_vif *vif)
3911 3912
{
	struct mwl8k_priv *priv = hw->priv;
3913
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
3914

3915 3916 3917
	if (priv->ap_fw)
		mwl8k_cmd_set_new_stn_del(hw, vif, vif->addr);

3918
	mwl8k_cmd_set_mac_addr(hw, vif, "\x00\x00\x00\x00\x00\x00");
3919

3920
	priv->macids_used &= ~(1 << mwl8k_vif->macid);
3921
	list_del(&mwl8k_vif->list);
3922 3923
}

3924
static int mwl8k_config(struct ieee80211_hw *hw, u32 changed)
3925 3926 3927
{
	struct ieee80211_conf *conf = &hw->conf;
	struct mwl8k_priv *priv = hw->priv;
3928
	int rc;
3929

L
Lennert Buytenhek 已提交
3930
	if (conf->flags & IEEE80211_CONF_IDLE) {
3931
		mwl8k_cmd_radio_disable(hw);
3932
		return 0;
L
Lennert Buytenhek 已提交
3933 3934
	}

3935 3936 3937
	rc = mwl8k_fw_lock(hw);
	if (rc)
		return rc;
3938

3939
	rc = mwl8k_cmd_radio_enable(hw);
3940 3941
	if (rc)
		goto out;
3942

3943
	rc = mwl8k_cmd_set_rf_channel(hw, conf);
3944 3945 3946
	if (rc)
		goto out;

3947 3948 3949
	if (conf->power_level > 18)
		conf->power_level = 18;

3950
	if (priv->ap_fw) {
3951 3952 3953 3954
		rc = mwl8k_cmd_tx_power(hw, conf, conf->power_level);
		if (rc)
			goto out;

3955 3956 3957 3958 3959 3960 3961
		rc = mwl8k_cmd_rf_antenna(hw, MWL8K_RF_ANTENNA_RX, 0x3);
		if (rc)
			wiphy_warn(hw->wiphy, "failed to set # of RX antennas");
		rc = mwl8k_cmd_rf_antenna(hw, MWL8K_RF_ANTENNA_TX, 0x7);
		if (rc)
			wiphy_warn(hw->wiphy, "failed to set # of TX antennas");

3962
	} else {
3963 3964 3965
		rc = mwl8k_cmd_rf_tx_power(hw, conf->power_level);
		if (rc)
			goto out;
3966 3967
		rc = mwl8k_cmd_mimo_config(hw, 0x7, 0x7);
	}
3968

3969 3970
out:
	mwl8k_fw_unlock(hw);
3971

3972
	return rc;
3973 3974
}

3975 3976 3977
static void
mwl8k_bss_info_changed_sta(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			   struct ieee80211_bss_conf *info, u32 changed)
3978 3979
{
	struct mwl8k_priv *priv = hw->priv;
3980
	u32 ap_legacy_rates;
3981
	u8 ap_mcs_rates[16];
3982 3983
	int rc;

3984
	if (mwl8k_fw_lock(hw))
3985
		return;
3986

3987 3988 3989 3990 3991
	/*
	 * 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;
3992

3993
	/*
3994
	 * Get the AP's legacy and MCS rates.
3995
	 */
3996
	if (vif->bss_conf.assoc) {
L
Lennert Buytenhek 已提交
3997
		struct ieee80211_sta *ap;
3998

L
Lennert Buytenhek 已提交
3999 4000
		rcu_read_lock();

4001 4002 4003
		ap = ieee80211_find_sta(vif, vif->bss_conf.bssid);
		if (ap == NULL) {
			rcu_read_unlock();
L
Lennert Buytenhek 已提交
4004
			goto out;
4005 4006
		}

4007 4008 4009 4010 4011 4012
		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;
		}
4013
		memcpy(ap_mcs_rates, ap->ht_cap.mcs.rx_mask, 16);
4014 4015 4016

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

4018
	if ((changed & BSS_CHANGED_ASSOC) && vif->bss_conf.assoc) {
4019
		rc = mwl8k_cmd_set_rate(hw, vif, ap_legacy_rates, ap_mcs_rates);
4020 4021
		if (rc)
			goto out;
4022

4023
		rc = mwl8k_cmd_use_fixed_rate_sta(hw);
4024 4025
		if (rc)
			goto out;
4026
	}
4027

4028
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4029 4030
		rc = mwl8k_set_radio_preamble(hw,
				vif->bss_conf.use_short_preamble);
4031 4032
		if (rc)
			goto out;
4033
	}
4034

4035
	if (changed & BSS_CHANGED_ERP_SLOT) {
4036
		rc = mwl8k_cmd_set_slot(hw, vif->bss_conf.use_short_slot);
4037 4038
		if (rc)
			goto out;
4039
	}
4040

4041 4042 4043
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_ERP_CTS_PROT |
			BSS_CHANGED_HT))) {
4044
		rc = mwl8k_cmd_set_aid(hw, vif, ap_legacy_rates);
4045 4046
		if (rc)
			goto out;
4047
	}
4048

4049 4050
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_BEACON_INT))) {
4051 4052 4053 4054
		/*
		 * Finalize the join.  Tell rx handler to process
		 * next beacon from our BSSID.
		 */
4055
		memcpy(priv->capture_bssid, vif->bss_conf.bssid, ETH_ALEN);
4056 4057 4058
		priv->capture_beacon = true;
	}

4059 4060
out:
	mwl8k_fw_unlock(hw);
4061 4062
}

4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088
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);
4089 4090 4091 4092 4093 4094 4095
		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;
4096 4097 4098 4099 4100 4101 4102 4103 4104

		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) {
4105
			mwl8k_cmd_set_beacon(hw, vif, skb->data, skb->len);
4106 4107 4108 4109 4110
			kfree_skb(skb);
		}
	}

	if (changed & BSS_CHANGED_BEACON_ENABLED)
4111
		mwl8k_cmd_bss_start(hw, vif, info->enable_beacon);
4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128

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

4129
static u64 mwl8k_prepare_multicast(struct ieee80211_hw *hw,
4130
				   struct netdev_hw_addr_list *mc_list)
4131 4132 4133
{
	struct mwl8k_cmd_pkt *cmd;

L
Lennert Buytenhek 已提交
4134 4135 4136 4137 4138 4139 4140
	/*
	 * 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().
	 */
4141
	cmd = __mwl8k_cmd_mac_multicast_adr(hw, 0, mc_list);
4142 4143 4144 4145

	return (unsigned long)cmd;
}

4146 4147 4148 4149 4150 4151 4152 4153 4154 4155 4156 4157
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.
	 */
4158
	if (!list_empty(&priv->vif_list)) {
4159
		if (net_ratelimit())
4160 4161
			wiphy_info(hw->wiphy,
				   "not enabling sniffer mode because STA interface is active\n");
4162 4163 4164 4165
		return 0;
	}

	if (!priv->sniffer_enabled) {
4166
		if (mwl8k_cmd_enable_sniffer(hw, 1))
4167 4168 4169 4170 4171 4172 4173 4174 4175 4176 4177
			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;
}

4178 4179 4180 4181 4182 4183 4184 4185
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;
}

4186 4187 4188 4189 4190 4191
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;
4192 4193
	struct mwl8k_cmd_pkt *cmd = (void *)(unsigned long)multicast;

4194 4195 4196 4197 4198 4199 4200 4201 4202 4203
	/*
	 * 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;
	}

4204 4205 4206 4207 4208 4209 4210 4211 4212
	/*
	 * 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;
	}
4213

4214
	/* Clear unsupported feature flags */
L
Lennert Buytenhek 已提交
4215
	*total_flags &= FIF_ALLMULTI | FIF_BCN_PRBRESP_PROMISC;
4216

4217 4218
	if (mwl8k_fw_lock(hw)) {
		kfree(cmd);
4219
		return;
4220
	}
4221

4222
	if (priv->sniffer_enabled) {
4223
		mwl8k_cmd_enable_sniffer(hw, 0);
4224 4225 4226
		priv->sniffer_enabled = false;
	}

4227
	if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
4228 4229 4230 4231
		if (*total_flags & FIF_BCN_PRBRESP_PROMISC) {
			/*
			 * Disable the BSS filter.
			 */
4232
			mwl8k_cmd_set_pre_scan(hw);
4233
		} else {
4234
			struct mwl8k_vif *mwl8k_vif;
4235
			const u8 *bssid;
4236

4237 4238 4239 4240 4241 4242 4243 4244
			/*
			 * 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).
			 */
4245 4246 4247 4248 4249
			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";
4250

4251
			mwl8k_cmd_set_post_scan(hw, bssid);
4252 4253 4254
		}
	}

L
Lennert Buytenhek 已提交
4255 4256 4257 4258 4259 4260 4261 4262
	/*
	 * 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);
4263
		cmd = __mwl8k_cmd_mac_multicast_adr(hw, 1, NULL);
L
Lennert Buytenhek 已提交
4264 4265 4266 4267 4268
	}

	if (cmd != NULL) {
		mwl8k_post_cmd(hw, cmd);
		kfree(cmd);
4269
	}
4270

4271
	mwl8k_fw_unlock(hw);
4272 4273 4274 4275
}

static int mwl8k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
{
L
Lennert Buytenhek 已提交
4276
	return mwl8k_cmd_set_rts_threshold(hw, value);
4277 4278
}

4279 4280 4281
static int mwl8k_sta_remove(struct ieee80211_hw *hw,
			    struct ieee80211_vif *vif,
			    struct ieee80211_sta *sta)
4282 4283 4284
{
	struct mwl8k_priv *priv = hw->priv;

4285 4286 4287 4288
	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);
4289 4290
}

4291 4292 4293
static int mwl8k_sta_add(struct ieee80211_hw *hw,
			 struct ieee80211_vif *vif,
			 struct ieee80211_sta *sta)
4294 4295
{
	struct mwl8k_priv *priv = hw->priv;
4296
	int ret;
4297 4298 4299
	int i;
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
	struct ieee80211_key_conf *key;
4300

4301 4302 4303 4304
	if (!priv->ap_fw) {
		ret = mwl8k_cmd_update_stadb_add(hw, vif, sta);
		if (ret >= 0) {
			MWL8K_STA(sta)->peer_id = ret;
4305
			ret = 0;
4306
		}
4307

4308 4309
	} else {
		ret = mwl8k_cmd_set_new_stn_add(hw, vif, sta);
4310
	}
4311

4312 4313 4314 4315 4316
	for (i = 0; i < NUM_WEP_KEYS; i++) {
		key = IEEE80211_KEY_CONF(mwl8k_vif->wep_key_conf[i].key);
		if (mwl8k_vif->wep_key_conf[i].enabled)
			mwl8k_set_key(hw, SET_KEY, vif, sta, key);
	}
4317
	return ret;
4318 4319
}

4320 4321 4322
static int mwl8k_conf_tx(struct ieee80211_hw *hw, u16 queue,
			 const struct ieee80211_tx_queue_params *params)
{
4323
	struct mwl8k_priv *priv = hw->priv;
4324 4325
	int rc;

4326 4327
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
4328 4329 4330
		BUG_ON(queue > MWL8K_TX_QUEUES - 1);
		memcpy(&priv->wmm_params[queue], params, sizeof(*params));

4331
		if (!priv->wmm_enabled)
4332
			rc = mwl8k_cmd_set_wmm_mode(hw, 1);
4333

4334
		if (!rc)
4335 4336 4337 4338 4339
			rc = mwl8k_cmd_set_edca_params(hw, queue,
						       params->cw_min,
						       params->cw_max,
						       params->aifs,
						       params->txop);
4340 4341

		mwl8k_fw_unlock(hw);
4342
	}
4343

4344 4345 4346 4347 4348 4349
	return rc;
}

static int mwl8k_get_stats(struct ieee80211_hw *hw,
			   struct ieee80211_low_level_stats *stats)
{
4350
	return mwl8k_cmd_get_stat(hw, stats);
4351 4352
}

4353 4354 4355 4356 4357 4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368
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;
}

4369 4370 4371
static int
mwl8k_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		   enum ieee80211_ampdu_mlme_action action,
4372 4373
		   struct ieee80211_sta *sta, u16 tid, u16 *ssn,
		   u8 buf_size)
4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385
{
	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;
	}
}

4386 4387 4388 4389 4390 4391 4392 4393
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,
4394
	.prepare_multicast	= mwl8k_prepare_multicast,
4395
	.configure_filter	= mwl8k_configure_filter,
4396
	.set_key                = mwl8k_set_key,
4397
	.set_rts_threshold	= mwl8k_set_rts_threshold,
4398 4399
	.sta_add		= mwl8k_sta_add,
	.sta_remove		= mwl8k_sta_remove,
4400 4401
	.conf_tx		= mwl8k_conf_tx,
	.get_stats		= mwl8k_get_stats,
4402
	.get_survey		= mwl8k_get_survey,
4403
	.ampdu_action		= mwl8k_ampdu_action,
4404 4405 4406 4407 4408 4409 4410
};

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;
4411 4412 4413 4414 4415 4416 4417 4418
	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];
4419

4420
	mwl8k_cmd_finalize_join(priv->hw, skb->data, skb->len, dtim_period);
4421

4422
	dev_kfree_skb(skb);
4423 4424 4425
	priv->beacon_skb = NULL;
}

4426
enum {
4427 4428
	MWL8363 = 0,
	MWL8687,
4429
	MWL8366,
4430 4431
};

4432 4433 4434 4435
#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)

4436
static struct mwl8k_device_info mwl8k_info_tbl[] __devinitdata = {
4437 4438 4439
	[MWL8363] = {
		.part_name	= "88w8363",
		.helper_image	= "mwl8k/helper_8363.fw",
4440
		.fw_image_sta	= "mwl8k/fmimage_8363.fw",
4441
	},
4442
	[MWL8687] = {
4443 4444
		.part_name	= "88w8687",
		.helper_image	= "mwl8k/helper_8687.fw",
4445
		.fw_image_sta	= "mwl8k/fmimage_8687.fw",
4446
	},
4447
	[MWL8366] = {
4448 4449
		.part_name	= "88w8366",
		.helper_image	= "mwl8k/helper_8366.fw",
4450
		.fw_image_sta	= "mwl8k/fmimage_8366.fw",
4451 4452
		.fw_image_ap	= MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API),
		.fw_api_ap	= MWL8K_8366_AP_FW_API,
4453
		.ap_rxd_ops	= &rxd_8366_ap_ops,
4454
	},
4455 4456
};

4457 4458 4459 4460 4461 4462
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");
4463
MODULE_FIRMWARE(MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API));
4464

4465
static DEFINE_PCI_DEVICE_TABLE(mwl8k_pci_id_table) = {
4466
	{ PCI_VDEVICE(MARVELL, 0x2a0a), .driver_data = MWL8363, },
4467 4468
	{ PCI_VDEVICE(MARVELL, 0x2a0c), .driver_data = MWL8363, },
	{ PCI_VDEVICE(MARVELL, 0x2a24), .driver_data = MWL8363, },
4469 4470 4471
	{ PCI_VDEVICE(MARVELL, 0x2a2b), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a30), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a40), .driver_data = MWL8366, },
4472
	{ PCI_VDEVICE(MARVELL, 0x2a43), .driver_data = MWL8366, },
4473
	{ },
4474 4475 4476
};
MODULE_DEVICE_TABLE(pci, mwl8k_pci_id_table);

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 4522 4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533 4534 4535 4536 4537 4538 4539 4540 4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569
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)
4570
{
4571
	struct mwl8k_priv *priv = hw->priv;
4572
	int rc;
4573 4574 4575 4576 4577

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

	/* Ask userland hotplug daemon for the device firmware */
4578
	rc = mwl8k_request_firmware(priv, fw_image, nowait);
4579
	if (rc) {
4580
		wiphy_err(hw->wiphy, "Firmware files not found\n");
4581
		return rc;
4582 4583
	}

4584 4585 4586
	if (nowait)
		return rc;

4587 4588
	/* Load firmware into hardware */
	rc = mwl8k_load_firmware(hw);
4589
	if (rc)
4590
		wiphy_err(hw->wiphy, "Cannot start firmware\n");
4591 4592 4593 4594

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

4595 4596 4597 4598 4599 4600 4601 4602 4603
	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;
4604

4605
	if (priv->ap_fw) {
4606
		priv->rxd_ops = priv->device_info->ap_rxd_ops;
4607
		if (priv->rxd_ops == NULL) {
4608 4609
			wiphy_err(hw->wiphy,
				  "Driver does not have AP firmware image support for this hardware\n");
4610 4611 4612
			goto err_stop_firmware;
		}
	} else {
4613
		priv->rxd_ops = &rxd_sta_ops;
4614
	}
4615 4616 4617 4618 4619

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

4620 4621
	rc = mwl8k_rxq_init(hw, 0);
	if (rc)
4622
		goto err_stop_firmware;
4623 4624 4625 4626 4627 4628 4629 4630 4631
	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);
4632
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4633
	iowrite32(MWL8K_A2H_INT_TX_DONE | MWL8K_A2H_INT_RX_READY,
4634
		  priv->regs + MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL);
4635 4636
	iowrite32(0xffffffff, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);

4637
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
4638 4639
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
4640
		wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
4641 4642 4643 4644 4645
		goto err_free_queues;
	}

	/*
	 * Temporarily enable interrupts.  Initial firmware host
L
Lennert Buytenhek 已提交
4646
	 * commands use interrupts and avoid polling.  Disable
4647 4648
	 * interrupts when done.
	 */
4649
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4650 4651

	/* Get config data, mac addrs etc */
4652 4653 4654 4655 4656 4657 4658
	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);
	}
4659
	if (rc) {
4660
		wiphy_err(hw->wiphy, "Cannot initialise firmware\n");
4661
		goto err_free_irq;
4662 4663 4664
	}

	/* Turn radio off */
4665
	rc = mwl8k_cmd_radio_disable(hw);
4666
	if (rc) {
4667
		wiphy_err(hw->wiphy, "Cannot disable\n");
4668
		goto err_free_irq;
4669 4670
	}

4671
	/* Clear MAC address */
4672
	rc = mwl8k_cmd_set_mac_addr(hw, NULL, "\x00\x00\x00\x00\x00\x00");
4673
	if (rc) {
4674
		wiphy_err(hw->wiphy, "Cannot clear MAC address\n");
4675
		goto err_free_irq;
4676 4677
	}

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

4682 4683 4684 4685 4686 4687
	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);
4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699

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

4700 4701 4702 4703 4704 4705 4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720
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);

4721
	rc = mwl8k_init_firmware(hw, fw_image, false);
4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754
	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;

4755 4756 4757 4758 4759 4760 4761
	rc = mwl8k_load_firmware(hw);
	mwl8k_release_firmware(priv);
	if (rc) {
		wiphy_err(hw->wiphy, "Cannot start firmware\n");
		return rc;
	}

4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773
	/*
	 * 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 */
4774
	hw->flags |= IEEE80211_HW_SIGNAL_DBM | IEEE80211_HW_HAS_RATE_CONTROL;
4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830
	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);

4831
err_free_cookie:
4832 4833 4834 4835
	if (priv->cookie != NULL)
		pci_free_consistent(priv->pdev, 4,
				priv->cookie, priv->cookie_dma);

4836 4837 4838 4839 4840 4841 4842 4843
	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;
4844
	struct mwl8k_device_info *di;
4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878 4879 4880 4881 4882 4883 4884 4885 4886 4887 4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898 4899 4900 4901 4902 4903 4904
	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;
		}
	}

4905
	/*
4906 4907 4908
	 * 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.
4909
	 */
4910
	init_completion(&priv->firmware_loading_complete);
4911
	di = priv->device_info;
4912 4913 4914 4915 4916 4917 4918
	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) {
4919
		printk(KERN_WARNING "AP fw is unavailable.  Using STA fw.");
4920
		priv->fw_pref = di->fw_image_sta;
4921 4922
	} else if (!ap_mode_default && !di->fw_image_sta && di->fw_image_ap) {
		printk(KERN_WARNING "STA fw is unavailable.  Using AP fw.");
4923 4924 4925
		priv->fw_pref = di->fw_image_ap;
	}
	rc = mwl8k_init_firmware(hw, priv->fw_pref, true);
4926 4927
	if (rc)
		goto err_stop_firmware;
4928
	return rc;
4929

4930 4931 4932 4933
err_stop_firmware:
	mwl8k_hw_reset(priv);

err_iounmap:
4934 4935 4936
	if (priv->regs != NULL)
		pci_iounmap(pdev, priv->regs);

L
Lennert Buytenhek 已提交
4937 4938 4939
	if (priv->sram != NULL)
		pci_iounmap(pdev, priv->sram);

4940 4941 4942 4943 4944
	pci_set_drvdata(pdev, NULL);
	ieee80211_free_hw(hw);

err_free_reg:
	pci_release_regions(pdev);
4945 4946

err_disable_device:
4947 4948 4949 4950 4951
	pci_disable_device(pdev);

	return rc;
}

4952
static void __devexit mwl8k_shutdown(struct pci_dev *pdev)
4953 4954 4955 4956
{
	printk(KERN_ERR "===>%s(%u)\n", __func__, __LINE__);
}

4957
static void __devexit mwl8k_remove(struct pci_dev *pdev)
4958 4959 4960 4961 4962 4963 4964 4965 4966
{
	struct ieee80211_hw *hw = pci_get_drvdata(pdev);
	struct mwl8k_priv *priv;
	int i;

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

4967 4968 4969 4970 4971 4972 4973
	wait_for_completion(&priv->firmware_loading_complete);

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

4974 4975
	ieee80211_stop_queues(hw);

4976 4977
	ieee80211_unregister_hw(hw);

4978
	/* Remove TX reclaim and RX tasklets.  */
4979
	tasklet_kill(&priv->poll_tx_task);
4980
	tasklet_kill(&priv->poll_rx_task);
4981 4982 4983 4984 4985 4986

	/* Stop hardware */
	mwl8k_hw_reset(priv);

	/* Return all skbs to mac80211 */
	for (i = 0; i < MWL8K_TX_QUEUES; i++)
4987
		mwl8k_txq_reclaim(hw, i, INT_MAX, 1);
4988 4989 4990 4991 4992 4993

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

	mwl8k_rxq_deinit(hw, 0);

L
Lennert Buytenhek 已提交
4994
	pci_free_consistent(priv->pdev, 4, priv->cookie, priv->cookie_dma);
4995

4996
unmap:
4997
	pci_iounmap(pdev, priv->regs);
L
Lennert Buytenhek 已提交
4998
	pci_iounmap(pdev, priv->sram);
4999 5000 5001 5002 5003 5004 5005 5006
	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,
5007
	.id_table	= mwl8k_pci_id_table,
5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024
	.probe		= mwl8k_probe,
	.remove		= __devexit_p(mwl8k_remove),
	.shutdown	= __devexit_p(mwl8k_shutdown),
};

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

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

module_init(mwl8k_init);
module_exit(mwl8k_exit);
L
Lennert Buytenhek 已提交
5025 5026 5027 5028 5029

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