mwl8k.c 118.5 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
		if (MWL8K_TXD_SUCCESS(status))
1539 1540 1541 1542
			info->flags |= IEEE80211_TX_STAT_ACK;

		ieee80211_tx_status_irqsafe(hw, skb);

1543
		processed++;
1544 1545
	}

1546
	if (processed && priv->radio_on && !mutex_is_locked(&priv->fw_mutex))
1547
		ieee80211_wake_queue(hw, index);
1548 1549

	return processed;
1550 1551 1552 1553 1554 1555 1556 1557
}

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

1558
	mwl8k_txq_reclaim(hw, index, INT_MAX, 1);
1559

1560 1561
	kfree(txq->skb);
	txq->skb = NULL;
1562 1563 1564

	pci_free_consistent(priv->pdev,
			    MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc),
1565 1566
			    txq->txd, txq->txd_dma);
	txq->txd = NULL;
1567 1568 1569 1570 1571 1572 1573
}

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;
1574
	struct mwl8k_vif *mwl8k_vif;
1575 1576 1577 1578
	struct ieee80211_hdr *wh;
	struct mwl8k_tx_queue *txq;
	struct mwl8k_tx_desc *tx;
	dma_addr_t dma;
1579 1580 1581
	u32 txstatus;
	u8 txdatarate;
	u16 qos;
1582

1583 1584 1585 1586 1587
	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;
1588

1589 1590 1591 1592 1593
	if (priv->ap_fw)
		mwl8k_encapsulate_tx_frame(skb);
	else
		mwl8k_add_dma_header(skb, 0);

1594
	wh = &((struct mwl8k_dma_data *)skb->data)->wh;
1595 1596 1597 1598 1599 1600

	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);
1601 1602
		wh->seq_ctrl |= cpu_to_le16(mwl8k_vif->seqno);
		mwl8k_vif->seqno += 0x10;
1603 1604
	}

1605 1606 1607 1608 1609 1610
	/* 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;
1611
		qos |= MWL8K_QOS_QLEN_UNSPEC | MWL8K_QOS_EOSP;
1612 1613 1614 1615 1616
	} else if (ieee80211_is_data(wh->frame_control)) {
		txdatarate = 1;
		if (is_multicast_ether_addr(wh->addr1))
			txstatus |= MWL8K_TXD_STATUS_MULTICAST_TX;

1617
		qos &= ~MWL8K_QOS_ACK_POLICY_MASK;
1618
		if (tx_info->flags & IEEE80211_TX_CTL_AMPDU)
1619
			qos |= MWL8K_QOS_ACK_POLICY_BLOCKACK;
1620
		else
1621
			qos |= MWL8K_QOS_ACK_POLICY_NORMAL;
1622
	}
1623 1624 1625 1626 1627

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

	if (pci_dma_mapping_error(priv->pdev, dma)) {
1628 1629
		wiphy_debug(hw->wiphy,
			    "failed to dma map skb, dropping TX frame.\n");
1630
		dev_kfree_skb(skb);
1631 1632 1633
		return NETDEV_TX_OK;
	}

1634
	spin_lock_bh(&priv->tx_lock);
1635

1636
	txq = priv->txq + index;
1637

1638 1639
	BUG_ON(txq->skb[txq->tail] != NULL);
	txq->skb[txq->tail] = skb;
1640

1641
	tx = txq->txd + txq->tail;
1642 1643
	tx->data_rate = txdatarate;
	tx->tx_priority = index;
1644 1645 1646
	tx->qos_control = cpu_to_le16(qos);
	tx->pkt_phys_addr = cpu_to_le32(dma);
	tx->pkt_len = cpu_to_le16(skb->len);
1647
	tx->rate_info = 0;
1648 1649 1650 1651
	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;
1652
	wmb();
1653 1654
	tx->status = cpu_to_le32(MWL8K_TXD_STATUS_FW_OWNED | txstatus);

1655
	txq->len++;
1656 1657
	priv->pending_tx_pkts++;

1658 1659 1660
	txq->tail++;
	if (txq->tail == MWL8K_TX_DESCS)
		txq->tail = 0;
1661

1662
	if (txq->head == txq->tail)
1663 1664
		ieee80211_stop_queue(hw, index);

1665
	mwl8k_tx_start(priv);
1666 1667 1668 1669 1670 1671 1672

	spin_unlock_bh(&priv->tx_lock);

	return NETDEV_TX_OK;
}


1673 1674 1675 1676 1677 1678 1679 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
/*
 * 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);
	}
}


1727 1728 1729 1730
/*
 * Command processing.
 */

1731 1732
/* Timeout firmware commands after 10s */
#define MWL8K_CMD_TIMEOUT_MS	10000
1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744

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

1745
	cmd->result = (__force __le16) 0xffff;
1746 1747 1748 1749 1750 1751
	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;

1752
	rc = mwl8k_fw_lock(hw);
1753 1754 1755
	if (rc) {
		pci_unmap_single(priv->pdev, dma_addr, dma_size,
						PCI_DMA_BIDIRECTIONAL);
1756
		return rc;
1757
	}
1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768

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

1769 1770 1771 1772
	priv->hostcmd_wait = NULL;

	mwl8k_fw_unlock(hw);

1773 1774 1775
	pci_unmap_single(priv->pdev, dma_addr, dma_size,
					PCI_DMA_BIDIRECTIONAL);

1776
	if (!timeout) {
1777
		wiphy_err(hw->wiphy, "Command %s timeout after %u ms\n",
1778 1779
			  mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
			  MWL8K_CMD_TIMEOUT_MS);
1780 1781
		rc = -ETIMEDOUT;
	} else {
1782 1783 1784 1785
		int ms;

		ms = MWL8K_CMD_TIMEOUT_MS - jiffies_to_msecs(timeout);

1786
		rc = cmd->result ? -EINVAL : 0;
1787
		if (rc)
1788
			wiphy_err(hw->wiphy, "Command %s error 0x%x\n",
1789 1790
				  mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
				  le16_to_cpu(cmd->result));
1791
		else if (ms > 2000)
1792
			wiphy_notice(hw->wiphy, "Command %s took %d ms\n",
1793 1794 1795
				     mwl8k_cmd_name(cmd->code,
						    buf, sizeof(buf)),
				     ms);
1796 1797 1798 1799 1800
	}

	return rc;
}

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

1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831
/*
 * 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;
}

1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848 1849 1850
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;
}

1851
/*
1852
 * CMD_GET_HW_SPEC (STA version).
1853
 */
1854
struct mwl8k_cmd_get_hw_spec_sta {
1855 1856 1857 1858
	struct mwl8k_cmd_pkt header;
	__u8 hw_rev;
	__u8 host_interface;
	__le16 num_mcaddrs;
1859
	__u8 perm_addr[ETH_ALEN];
1860 1861 1862 1863 1864 1865 1866 1867 1868 1869
	__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;
1870
	__le32 total_rxd;
1871
} __packed;
1872

1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884
#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
1885 1886 1887
#define MWL8K_CAP_BAND_MASK		0x00000007
#define MWL8K_CAP_5GHZ			0x00000004
#define MWL8K_CAP_2GHZ4			0x00000001
1888

1889 1890 1891
static void
mwl8k_set_ht_caps(struct ieee80211_hw *hw,
		  struct ieee80211_supported_band *band, u32 cap)
1892 1893 1894 1895
{
	int rx_streams;
	int tx_streams;

1896
	band->ht_cap.ht_supported = 1;
1897 1898

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

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

1923
	band->ht_cap.mcs.rx_mask[0] = 0xff;
1924
	if (rx_streams >= 2)
1925
		band->ht_cap.mcs.rx_mask[1] = 0xff;
1926
	if (rx_streams >= 3)
1927 1928 1929
		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;
1930 1931

	if (rx_streams != tx_streams) {
1932 1933
		band->ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
		band->ht_cap.mcs.tx_params |= (tx_streams - 1) <<
1934 1935 1936 1937
				IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
	}
}

1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955
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);
	}
}

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

	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);
1984
		priv->fw_rev = le32_to_cpu(cmd->fw_rev);
1985
		priv->hw_rev = cmd->hw_rev;
1986
		mwl8k_set_caps(hw, le32_to_cpu(cmd->caps));
1987 1988
		priv->ap_macids_supported = 0x00000000;
		priv->sta_macids_supported = 0x00000001;
1989 1990 1991 1992 1993 1994
	}

	kfree(cmd);
	return rc;
}

1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014
/*
 * 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;
2015
	__le32 fw_api_version;
2016
} __packed;
2017 2018 2019 2020 2021 2022

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;
2023
	u32 api_version;
2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039

	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;

2040 2041 2042 2043 2044 2045 2046 2047 2048 2049
		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;
		}
2050 2051 2052 2053
		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;
2054
		mwl8k_setup_2ghz_band(hw);
2055 2056
		priv->ap_macids_supported = 0x000000ff;
		priv->sta_macids_supported = 0x00000000;
2057 2058

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

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

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

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

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

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

2077
done:
2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100
	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;
2101
} __packed;
2102

2103 2104 2105
#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
2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125

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);
2126 2127 2128
	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);
2129 2130 2131 2132 2133 2134 2135 2136 2137
	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;
}

2138 2139 2140 2141 2142 2143 2144
/*
 * CMD_MAC_MULTICAST_ADR.
 */
struct mwl8k_cmd_mac_multicast_adr {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 numaddr;
2145
	__u8 addr[0][ETH_ALEN];
2146 2147
};

2148 2149 2150 2151
#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
2152

2153
static struct mwl8k_cmd_pkt *
L
Lennert Buytenhek 已提交
2154
__mwl8k_cmd_mac_multicast_adr(struct ieee80211_hw *hw, int allmulti,
2155
			      struct netdev_hw_addr_list *mc_list)
2156
{
2157
	struct mwl8k_priv *priv = hw->priv;
2158
	struct mwl8k_cmd_mac_multicast_adr *cmd;
2159
	int size;
2160 2161 2162 2163
	int mc_count = 0;

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

L
Lennert Buytenhek 已提交
2165
	if (allmulti || mc_count > priv->num_mcaddrs) {
2166 2167 2168
		allmulti = 1;
		mc_count = 0;
	}
2169 2170

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

2172
	cmd = kzalloc(size, GFP_ATOMIC);
2173
	if (cmd == NULL)
2174
		return NULL;
2175 2176 2177

	cmd->header.code = cpu_to_le16(MWL8K_CMD_MAC_MULTICAST_ADR);
	cmd->header.length = cpu_to_le16(size);
2178 2179 2180 2181 2182 2183
	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) {
2184 2185
		struct netdev_hw_addr *ha;
		int i = 0;
2186 2187 2188

		cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_MULTICAST);
		cmd->numaddr = cpu_to_le16(mc_count);
2189 2190
		netdev_hw_addr_list_for_each(ha, mc_list) {
			memcpy(cmd->addr[i], ha->addr, ETH_ALEN);
2191 2192 2193
		}
	}

2194
	return &cmd->header;
2195 2196 2197
}

/*
2198
 * CMD_GET_STAT.
2199
 */
2200
struct mwl8k_cmd_get_stat {
2201 2202
	struct mwl8k_cmd_pkt header;
	__le32 stats[64];
2203
} __packed;
2204 2205 2206 2207 2208 2209

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

2210 2211
static int mwl8k_cmd_get_stat(struct ieee80211_hw *hw,
			      struct ieee80211_low_level_stats *stats)
2212
{
2213
	struct mwl8k_cmd_get_stat *cmd;
2214 2215 2216 2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239
	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;
}

/*
2240
 * CMD_RADIO_CONTROL.
2241
 */
2242
struct mwl8k_cmd_radio_control {
2243 2244 2245 2246
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 control;
	__le16 radio_on;
2247
} __packed;
2248

2249
static int
2250
mwl8k_cmd_radio_control(struct ieee80211_hw *hw, bool enable, bool force)
2251 2252
{
	struct mwl8k_priv *priv = hw->priv;
2253
	struct mwl8k_cmd_radio_control *cmd;
2254 2255
	int rc;

2256
	if (enable == priv->radio_on && !force)
2257 2258 2259 2260 2261 2262 2263 2264 2265
		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);
2266
	cmd->control = cpu_to_le16(priv->radio_short_preamble ? 3 : 1);
2267 2268 2269 2270 2271 2272
	cmd->radio_on = cpu_to_le16(enable ? 0x0001 : 0x0000);

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

	if (!rc)
2273
		priv->radio_on = enable;
2274 2275 2276 2277

	return rc;
}

2278
static int mwl8k_cmd_radio_disable(struct ieee80211_hw *hw)
2279
{
2280
	return mwl8k_cmd_radio_control(hw, 0, 0);
2281 2282
}

2283
static int mwl8k_cmd_radio_enable(struct ieee80211_hw *hw)
2284
{
2285
	return mwl8k_cmd_radio_control(hw, 1, 0);
2286 2287
}

2288 2289 2290
static int
mwl8k_set_radio_preamble(struct ieee80211_hw *hw, bool short_preamble)
{
2291
	struct mwl8k_priv *priv = hw->priv;
2292

2293
	priv->radio_short_preamble = short_preamble;
2294

2295
	return mwl8k_cmd_radio_control(hw, 1, 1);
2296 2297 2298
}

/*
2299
 * CMD_RF_TX_POWER.
2300
 */
2301
#define MWL8K_RF_TX_POWER_LEVEL_TOTAL	8
2302

2303
struct mwl8k_cmd_rf_tx_power {
2304 2305 2306 2307 2308
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 support_level;
	__le16 current_level;
	__le16 reserved;
2309
	__le16 power_level_list[MWL8K_RF_TX_POWER_LEVEL_TOTAL];
2310
} __packed;
2311

2312
static int mwl8k_cmd_rf_tx_power(struct ieee80211_hw *hw, int dBm)
2313
{
2314
	struct mwl8k_cmd_rf_tx_power *cmd;
2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329 2330 2331
	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;
}

2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 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
/*
 * 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;
}

2391 2392 2393 2394 2395 2396 2397
/*
 * CMD_RF_ANTENNA.
 */
struct mwl8k_cmd_rf_antenna {
	struct mwl8k_cmd_pkt header;
	__le16 antenna;
	__le16 mode;
2398
} __packed;
2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421 2422 2423

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

2424 2425 2426 2427 2428 2429 2430 2431 2432
/*
 * CMD_SET_BEACON.
 */
struct mwl8k_cmd_set_beacon {
	struct mwl8k_cmd_pkt header;
	__le16 beacon_len;
	__u8 beacon[0];
};

2433 2434
static int mwl8k_cmd_set_beacon(struct ieee80211_hw *hw,
				struct ieee80211_vif *vif, u8 *beacon, int len)
2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447
{
	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);

2448
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2449 2450 2451 2452 2453
	kfree(cmd);

	return rc;
}

2454 2455 2456 2457 2458
/*
 * CMD_SET_PRE_SCAN.
 */
struct mwl8k_cmd_set_pre_scan {
	struct mwl8k_cmd_pkt header;
2459
} __packed;
2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484

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;
2485
	__u8 bssid[ETH_ALEN];
2486
} __packed;
2487 2488

static int
2489
mwl8k_cmd_set_post_scan(struct ieee80211_hw *hw, const __u8 *mac)
2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500
{
	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;
2501
	memcpy(cmd->bssid, mac, ETH_ALEN);
2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516

	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;
2517
} __packed;
2518 2519

static int mwl8k_cmd_set_rf_channel(struct ieee80211_hw *hw,
2520
				    struct ieee80211_conf *conf)
2521
{
2522
	struct ieee80211_channel *channel = conf->channel;
2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533
	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;
2534

2535
	if (channel->band == IEEE80211_BAND_2GHZ)
2536
		cmd->channel_flags |= cpu_to_le32(0x00000001);
2537 2538
	else if (channel->band == IEEE80211_BAND_5GHZ)
		cmd->channel_flags |= cpu_to_le32(0x00000004);
2539 2540 2541 2542 2543 2544 2545 2546

	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);
2547 2548 2549 2550 2551 2552 2553 2554

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

	return rc;
}

/*
2555
 * CMD_SET_AID.
2556
 */
2557 2558 2559 2560
#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
2561

2562 2563 2564
struct mwl8k_cmd_update_set_aid {
	struct	mwl8k_cmd_pkt header;
	__le16	aid;
2565

2566 2567 2568 2569
	 /* AP's MAC address (BSSID) */
	__u8	bssid[ETH_ALEN];
	__le16	protection_mode;
	__u8	supp_rates[14];
2570
} __packed;
2571

L
Lennert Buytenhek 已提交
2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583
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))
2584
			rates[j++] = mwl8k_rates_24[i].hw_value;
L
Lennert Buytenhek 已提交
2585 2586 2587
	}
}

2588
static int
L
Lennert Buytenhek 已提交
2589 2590
mwl8k_cmd_set_aid(struct ieee80211_hw *hw,
		  struct ieee80211_vif *vif, u32 legacy_rate_mask)
2591
{
2592 2593
	struct mwl8k_cmd_update_set_aid *cmd;
	u16 prot_mode;
2594 2595 2596 2597 2598 2599
	int rc;

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

2600
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_AID);
2601
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2602
	cmd->aid = cpu_to_le16(vif->bss_conf.aid);
2603
	memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN);
2604

2605
	if (vif->bss_conf.use_cts_prot) {
2606 2607
		prot_mode = MWL8K_FRAME_PROT_11G;
	} else {
2608
		switch (vif->bss_conf.ht_operation_mode &
2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621
			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);
2622

L
Lennert Buytenhek 已提交
2623
	legacy_rate_mask_to_array(cmd->supp_rates, legacy_rate_mask);
2624 2625 2626 2627 2628 2629 2630

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

	return rc;
}

2631
/*
2632
 * CMD_SET_RATE.
2633
 */
2634 2635 2636 2637 2638 2639 2640
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];
2641
} __packed;
2642

2643
static int
L
Lennert Buytenhek 已提交
2644
mwl8k_cmd_set_rate(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2645
		   u32 legacy_rate_mask, u8 *mcs_rates)
2646
{
2647
	struct mwl8k_cmd_set_rate *cmd;
2648 2649 2650 2651 2652 2653
	int rc;

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

2654
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATE);
2655
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
2656
	legacy_rate_mask_to_array(cmd->legacy_rates, legacy_rate_mask);
2657
	memcpy(cmd->mcs_set, mcs_rates, 16);
2658 2659 2660 2661 2662 2663 2664

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

	return rc;
}

2665
/*
2666
 * CMD_FINALIZE_JOIN.
2667
 */
2668 2669 2670
#define MWL8K_FJ_BEACON_MAXLEN	128

struct mwl8k_cmd_finalize_join {
2671
	struct mwl8k_cmd_pkt header;
2672 2673
	__le32 sleep_interval;	/* Number of beacon periods to sleep */
	__u8 beacon_data[MWL8K_FJ_BEACON_MAXLEN];
2674
} __packed;
2675

2676 2677
static int mwl8k_cmd_finalize_join(struct ieee80211_hw *hw, void *frame,
				   int framelen, int dtim)
2678
{
2679 2680 2681
	struct mwl8k_cmd_finalize_join *cmd;
	struct ieee80211_mgmt *payload = frame;
	int payload_len;
2682 2683 2684 2685 2686 2687
	int rc;

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

2688
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_FINALIZE_JOIN);
2689
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2690 2691 2692 2693 2694 2695 2696 2697 2698
	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);
2699 2700 2701 2702 2703 2704 2705 2706

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

	return rc;
}

/*
2707
 * CMD_SET_RTS_THRESHOLD.
2708
 */
2709
struct mwl8k_cmd_set_rts_threshold {
2710 2711
	struct mwl8k_cmd_pkt header;
	__le16 action;
2712
	__le16 threshold;
2713
} __packed;
2714

L
Lennert Buytenhek 已提交
2715 2716
static int
mwl8k_cmd_set_rts_threshold(struct ieee80211_hw *hw, int rts_thresh)
2717
{
2718
	struct mwl8k_cmd_set_rts_threshold *cmd;
2719 2720 2721 2722 2723 2724
	int rc;

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

2725
	cmd->header.code = cpu_to_le16(MWL8K_CMD_RTS_THRESHOLD);
2726
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
2727 2728
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->threshold = cpu_to_le16(rts_thresh);
2729 2730 2731 2732 2733 2734 2735 2736

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

	return rc;
}

/*
2737
 * CMD_SET_SLOT.
2738
 */
2739
struct mwl8k_cmd_set_slot {
2740 2741
	struct mwl8k_cmd_pkt header;
	__le16 action;
2742
	__u8 short_slot;
2743
} __packed;
2744

2745
static int mwl8k_cmd_set_slot(struct ieee80211_hw *hw, bool short_slot_time)
2746
{
2747
	struct mwl8k_cmd_set_slot *cmd;
2748 2749 2750 2751 2752 2753
	int rc;

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

2754
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_SLOT);
2755
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2756 2757
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->short_slot = short_slot_time;
2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776

	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;

2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793
	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;
2794

2795 2796
			/* Log exponent of min contention period: 0...15 */
			__u8 log_cw_min;
2797

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

2801 2802 2803 2804
			/* TX queue to configure */
			__u8 txq;
		} sta;
	};
2805
} __packed;
2806 2807 2808 2809 2810 2811 2812 2813 2814 2815

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

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

	return rc;
}

/*
2851
 * CMD_SET_WMM_MODE.
2852
 */
2853
struct mwl8k_cmd_set_wmm_mode {
2854
	struct mwl8k_cmd_pkt header;
2855
	__le16 action;
2856
} __packed;
2857

2858
static int mwl8k_cmd_set_wmm_mode(struct ieee80211_hw *hw, bool enable)
2859
{
2860 2861
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_cmd_set_wmm_mode *cmd;
2862 2863 2864 2865 2866 2867
	int rc;

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

2868
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_WMM_MODE);
2869
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2870
	cmd->action = cpu_to_le16(!!enable);
2871 2872 2873

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

2875 2876
	if (!rc)
		priv->wmm_enabled = enable;
2877 2878 2879 2880 2881

	return rc;
}

/*
2882
 * CMD_MIMO_CONFIG.
2883
 */
2884 2885 2886 2887 2888
struct mwl8k_cmd_mimo_config {
	struct mwl8k_cmd_pkt header;
	__le32 action;
	__u8 rx_antenna_map;
	__u8 tx_antenna_map;
2889
} __packed;
2890

2891
static int mwl8k_cmd_mimo_config(struct ieee80211_hw *hw, __u8 rx, __u8 tx)
2892
{
2893
	struct mwl8k_cmd_mimo_config *cmd;
2894 2895 2896 2897 2898 2899
	int rc;

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

2900
	cmd->header.code = cpu_to_le16(MWL8K_CMD_MIMO_CONFIG);
2901
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2902 2903 2904
	cmd->action = cpu_to_le32((u32)MWL8K_CMD_SET);
	cmd->rx_antenna_map = rx;
	cmd->tx_antenna_map = tx;
2905 2906 2907 2908 2909 2910 2911 2912

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

	return rc;
}

/*
2913
 * CMD_USE_FIXED_RATE (STA version).
2914
 */
2915 2916 2917 2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928
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;
2929
} __packed;
2930

2931 2932
#define MWL8K_USE_AUTO_RATE	0x0002
#define MWL8K_UCAST_RATE	0
2933

2934
static int mwl8k_cmd_use_fixed_rate_sta(struct ieee80211_hw *hw)
2935
{
2936
	struct mwl8k_cmd_use_fixed_rate_sta *cmd;
2937 2938 2939 2940 2941 2942 2943 2944
	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));
2945 2946
	cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE);
	cmd->rate_type = cpu_to_le32(MWL8K_UCAST_RATE);
2947 2948 2949 2950 2951 2952 2953

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

	return rc;
}

2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970
/*
 * 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;
2971
} __packed;
2972 2973 2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994

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

2995 2996 2997 2998 2999 3000
/*
 * CMD_ENABLE_SNIFFER.
 */
struct mwl8k_cmd_enable_sniffer {
	struct mwl8k_cmd_pkt header;
	__le32 action;
3001
} __packed;
3002 3003 3004 3005 3006 3007 3008 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

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];
	};
3034
} __packed;
3035

3036 3037 3038 3039
#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
3040

3041 3042
static int mwl8k_cmd_set_mac_addr(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif, u8 *mac)
3043 3044
{
	struct mwl8k_priv *priv = hw->priv;
3045
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
3046
	struct mwl8k_cmd_set_mac_addr *cmd;
3047
	int mac_type;
3048 3049
	int rc;

3050 3051 3052 3053 3054 3055 3056 3057 3058 3059 3060 3061 3062
	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;
	}

3063 3064 3065 3066 3067 3068 3069
	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) {
3070
		cmd->mbss.mac_type = cpu_to_le16(mac_type);
3071 3072 3073 3074 3075
		memcpy(cmd->mbss.mac_addr, mac, ETH_ALEN);
	} else {
		memcpy(cmd->mac_addr, mac, ETH_ALEN);
	}

3076
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3077 3078 3079 3080 3081 3082 3083 3084 3085 3086 3087 3088
	kfree(cmd);

	return rc;
}

/*
 * CMD_SET_RATEADAPT_MODE.
 */
struct mwl8k_cmd_set_rate_adapt_mode {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 mode;
3089
} __packed;
3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110

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

3111 3112 3113 3114 3115 3116
/*
 * CMD_BSS_START.
 */
struct mwl8k_cmd_bss_start {
	struct mwl8k_cmd_pkt header;
	__le32 enable;
3117
} __packed;
3118

3119 3120
static int mwl8k_cmd_bss_start(struct ieee80211_hw *hw,
			       struct ieee80211_vif *vif, int enable)
3121 3122 3123 3124 3125 3126 3127 3128 3129 3130 3131 3132
{
	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);

3133
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3134 3135 3136 3137 3138
	kfree(cmd);

	return rc;
}

3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161
/*
 * 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;
3162
} __packed;
3163 3164 3165 3166 3167 3168 3169 3170 3171

#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;
3172
	u32 rates;
3173 3174 3175 3176 3177 3178 3179 3180 3181 3182 3183 3184
	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);
3185 3186 3187 3188 3189
	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);
3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200
	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;
	}

3201
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3202 3203 3204 3205 3206
	kfree(cmd);

	return rc;
}

3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220
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);

3221
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3222 3223 3224 3225 3226
	kfree(cmd);

	return rc;
}

3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241
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);

3242
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3243 3244 3245 3246 3247
	kfree(cmd);

	return rc;
}

3248 3249 3250 3251 3252 3253 3254 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
/*
 * 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;
}

3516 3517 3518
/*
 * CMD_UPDATE_STADB.
 */
3519 3520 3521 3522
struct ewc_ht_info {
	__le16	control1;
	__le16	control2;
	__le16	control3;
3523
} __packed;
3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551

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;
3552
} __packed;
3553

3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566
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;
3567
} __packed;
3568

3569 3570 3571 3572 3573 3574 3575
#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 已提交
3576
				      struct ieee80211_vif *vif,
3577
				      struct ieee80211_sta *sta)
3578 3579
{
	struct mwl8k_cmd_update_stadb *cmd;
3580
	struct peer_capability_info *p;
3581
	u32 rates;
3582 3583 3584 3585 3586 3587 3588 3589
	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));
3590
	cmd->action = cpu_to_le32(MWL8K_STA_DB_MODIFY_ENTRY);
3591
	memcpy(cmd->peer_addr, sta->addr, ETH_ALEN);
3592

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

3630
	rc = mwl8k_post_cmd(hw, &cmd->header);
3631 3632 3633 3634 3635
	kfree(cmd);

	return rc;
}

3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649

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

3650 3651 3652 3653 3654
	if (status & MWL8K_A2H_INT_TX_DONE) {
		status &= ~MWL8K_A2H_INT_TX_DONE;
		tasklet_schedule(&priv->poll_tx_task);
	}

3655
	if (status & MWL8K_A2H_INT_RX_READY) {
3656 3657
		status &= ~MWL8K_A2H_INT_RX_READY;
		tasklet_schedule(&priv->poll_rx_task);
3658 3659
	}

3660 3661 3662
	if (status)
		iowrite32(~status, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);

3663
	if (status & MWL8K_A2H_INT_OPC_DONE) {
3664
		if (priv->hostcmd_wait != NULL)
3665 3666 3667 3668
			complete(priv->hostcmd_wait);
	}

	if (status & MWL8K_A2H_INT_QUEUE_EMPTY) {
3669
		if (!mutex_is_locked(&priv->fw_mutex) &&
3670
		    priv->radio_on && priv->pending_tx_pkts)
3671
			mwl8k_tx_start(priv);
3672 3673 3674 3675 3676
	}

	return IRQ_HANDLED;
}

3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705
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);
	}
}

3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723
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);
	}
}

3724 3725 3726 3727 3728 3729 3730 3731 3732 3733

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

3734
	if (!priv->radio_on) {
3735 3736
		wiphy_debug(hw->wiphy,
			    "dropped TX frame since radio disabled\n");
3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750
		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;

3751
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
3752 3753
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
3754
		wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
3755
		return -EIO;
3756 3757
	}

3758
	/* Enable TX reclaim and RX tasklets.  */
3759
	tasklet_enable(&priv->poll_tx_task);
3760
	tasklet_enable(&priv->poll_rx_task);
3761

3762
	/* Enable interrupts */
3763
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
3764

3765 3766
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
3767
		rc = mwl8k_cmd_radio_enable(hw);
3768

3769 3770
		if (!priv->ap_fw) {
			if (!rc)
3771
				rc = mwl8k_cmd_enable_sniffer(hw, 0);
3772

3773 3774 3775 3776 3777 3778 3779
			if (!rc)
				rc = mwl8k_cmd_set_pre_scan(hw);

			if (!rc)
				rc = mwl8k_cmd_set_post_scan(hw,
						"\x00\x00\x00\x00\x00\x00");
		}
3780 3781

		if (!rc)
3782
			rc = mwl8k_cmd_set_rateadapt_mode(hw, 0);
3783

3784
		if (!rc)
3785
			rc = mwl8k_cmd_set_wmm_mode(hw, 0);
3786

3787 3788 3789 3790 3791 3792
		mwl8k_fw_unlock(hw);
	}

	if (rc) {
		iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
		free_irq(priv->pdev->irq, hw);
3793
		tasklet_disable(&priv->poll_tx_task);
3794
		tasklet_disable(&priv->poll_rx_task);
3795
	}
3796 3797 3798 3799 3800 3801 3802 3803 3804

	return rc;
}

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

3805
	mwl8k_cmd_radio_disable(hw);
3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817

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

3818
	/* Stop TX reclaim and RX tasklets.  */
3819
	tasklet_disable(&priv->poll_tx_task);
3820
	tasklet_disable(&priv->poll_rx_task);
3821 3822 3823

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

3827 3828
static int mwl8k_reload_firmware(struct ieee80211_hw *hw, char *fw_image);

3829
static int mwl8k_add_interface(struct ieee80211_hw *hw,
3830
			       struct ieee80211_vif *vif)
3831 3832 3833
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_vif *mwl8k_vif;
3834
	u32 macids_supported;
3835 3836
	int macid, rc;
	struct mwl8k_device_info *di;
3837

3838 3839 3840
	/*
	 * Reject interface creation if sniffer mode is active, as
	 * STA operation is mutually exclusive with hardware sniffer
3841
	 * mode.  (Sniffer mode is only used on STA firmware.)
3842 3843
	 */
	if (priv->sniffer_enabled) {
3844 3845
		wiphy_info(hw->wiphy,
			   "unable to create STA interface because sniffer mode is enabled\n");
3846 3847 3848
		return -EINVAL;
	}

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

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

3881
	/* Setup driver private area. */
3882
	mwl8k_vif = MWL8K_VIF(vif);
3883
	memset(mwl8k_vif, 0, sizeof(*mwl8k_vif));
3884
	mwl8k_vif->vif = vif;
3885
	mwl8k_vif->macid = macid;
3886
	mwl8k_vif->seqno = 0;
3887 3888
	memcpy(mwl8k_vif->bssid, vif->addr, ETH_ALEN);
	mwl8k_vif->is_hw_crypto_enabled = false;
3889

3890 3891 3892 3893 3894 3895
	/* 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);

3896
	priv->macids_used |= 1 << mwl8k_vif->macid;
3897
	list_add_tail(&mwl8k_vif->list, &priv->vif_list);
3898 3899 3900 3901 3902

	return 0;
}

static void mwl8k_remove_interface(struct ieee80211_hw *hw,
3903
				   struct ieee80211_vif *vif)
3904 3905
{
	struct mwl8k_priv *priv = hw->priv;
3906
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
3907

3908 3909 3910
	if (priv->ap_fw)
		mwl8k_cmd_set_new_stn_del(hw, vif, vif->addr);

3911
	mwl8k_cmd_set_mac_addr(hw, vif, "\x00\x00\x00\x00\x00\x00");
3912

3913
	priv->macids_used &= ~(1 << mwl8k_vif->macid);
3914
	list_del(&mwl8k_vif->list);
3915 3916
}

3917
static int mwl8k_config(struct ieee80211_hw *hw, u32 changed)
3918 3919 3920
{
	struct ieee80211_conf *conf = &hw->conf;
	struct mwl8k_priv *priv = hw->priv;
3921
	int rc;
3922

L
Lennert Buytenhek 已提交
3923
	if (conf->flags & IEEE80211_CONF_IDLE) {
3924
		mwl8k_cmd_radio_disable(hw);
3925
		return 0;
L
Lennert Buytenhek 已提交
3926 3927
	}

3928 3929 3930
	rc = mwl8k_fw_lock(hw);
	if (rc)
		return rc;
3931

3932
	rc = mwl8k_cmd_radio_enable(hw);
3933 3934
	if (rc)
		goto out;
3935

3936
	rc = mwl8k_cmd_set_rf_channel(hw, conf);
3937 3938 3939
	if (rc)
		goto out;

3940 3941 3942
	if (conf->power_level > 18)
		conf->power_level = 18;

3943
	if (priv->ap_fw) {
3944 3945 3946 3947
		rc = mwl8k_cmd_tx_power(hw, conf, conf->power_level);
		if (rc)
			goto out;

3948 3949 3950 3951
		rc = mwl8k_cmd_rf_antenna(hw, MWL8K_RF_ANTENNA_RX, 0x7);
		if (!rc)
			rc = mwl8k_cmd_rf_antenna(hw, MWL8K_RF_ANTENNA_TX, 0x7);
	} else {
3952 3953 3954
		rc = mwl8k_cmd_rf_tx_power(hw, conf->power_level);
		if (rc)
			goto out;
3955 3956
		rc = mwl8k_cmd_mimo_config(hw, 0x7, 0x7);
	}
3957

3958 3959
out:
	mwl8k_fw_unlock(hw);
3960

3961
	return rc;
3962 3963
}

3964 3965 3966
static void
mwl8k_bss_info_changed_sta(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			   struct ieee80211_bss_conf *info, u32 changed)
3967 3968
{
	struct mwl8k_priv *priv = hw->priv;
3969
	u32 ap_legacy_rates;
3970
	u8 ap_mcs_rates[16];
3971 3972
	int rc;

3973
	if (mwl8k_fw_lock(hw))
3974
		return;
3975

3976 3977 3978 3979 3980
	/*
	 * 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;
3981

3982
	/*
3983
	 * Get the AP's legacy and MCS rates.
3984
	 */
3985
	if (vif->bss_conf.assoc) {
L
Lennert Buytenhek 已提交
3986
		struct ieee80211_sta *ap;
3987

L
Lennert Buytenhek 已提交
3988 3989
		rcu_read_lock();

3990 3991 3992
		ap = ieee80211_find_sta(vif, vif->bss_conf.bssid);
		if (ap == NULL) {
			rcu_read_unlock();
L
Lennert Buytenhek 已提交
3993
			goto out;
3994 3995
		}

3996 3997 3998 3999 4000 4001
		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;
		}
4002
		memcpy(ap_mcs_rates, ap->ht_cap.mcs.rx_mask, 16);
4003 4004 4005

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

4007
	if ((changed & BSS_CHANGED_ASSOC) && vif->bss_conf.assoc) {
4008
		rc = mwl8k_cmd_set_rate(hw, vif, ap_legacy_rates, ap_mcs_rates);
4009 4010
		if (rc)
			goto out;
4011

4012
		rc = mwl8k_cmd_use_fixed_rate_sta(hw);
4013 4014
		if (rc)
			goto out;
4015
	}
4016

4017
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4018 4019
		rc = mwl8k_set_radio_preamble(hw,
				vif->bss_conf.use_short_preamble);
4020 4021
		if (rc)
			goto out;
4022
	}
4023

4024
	if (changed & BSS_CHANGED_ERP_SLOT) {
4025
		rc = mwl8k_cmd_set_slot(hw, vif->bss_conf.use_short_slot);
4026 4027
		if (rc)
			goto out;
4028
	}
4029

4030 4031 4032
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_ERP_CTS_PROT |
			BSS_CHANGED_HT))) {
4033
		rc = mwl8k_cmd_set_aid(hw, vif, ap_legacy_rates);
4034 4035
		if (rc)
			goto out;
4036
	}
4037

4038 4039
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_BEACON_INT))) {
4040 4041 4042 4043
		/*
		 * Finalize the join.  Tell rx handler to process
		 * next beacon from our BSSID.
		 */
4044
		memcpy(priv->capture_bssid, vif->bss_conf.bssid, ETH_ALEN);
4045 4046 4047
		priv->capture_beacon = true;
	}

4048 4049
out:
	mwl8k_fw_unlock(hw);
4050 4051
}

4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077
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);
4078 4079 4080 4081 4082 4083 4084
		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;
4085 4086 4087 4088 4089 4090 4091 4092 4093

		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) {
4094
			mwl8k_cmd_set_beacon(hw, vif, skb->data, skb->len);
4095 4096 4097 4098 4099
			kfree_skb(skb);
		}
	}

	if (changed & BSS_CHANGED_BEACON_ENABLED)
4100
		mwl8k_cmd_bss_start(hw, vif, info->enable_beacon);
4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117

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

4118
static u64 mwl8k_prepare_multicast(struct ieee80211_hw *hw,
4119
				   struct netdev_hw_addr_list *mc_list)
4120 4121 4122
{
	struct mwl8k_cmd_pkt *cmd;

L
Lennert Buytenhek 已提交
4123 4124 4125 4126 4127 4128 4129
	/*
	 * 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().
	 */
4130
	cmd = __mwl8k_cmd_mac_multicast_adr(hw, 0, mc_list);
4131 4132 4133 4134

	return (unsigned long)cmd;
}

4135 4136 4137 4138 4139 4140 4141 4142 4143 4144 4145 4146
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.
	 */
4147
	if (!list_empty(&priv->vif_list)) {
4148
		if (net_ratelimit())
4149 4150
			wiphy_info(hw->wiphy,
				   "not enabling sniffer mode because STA interface is active\n");
4151 4152 4153 4154
		return 0;
	}

	if (!priv->sniffer_enabled) {
4155
		if (mwl8k_cmd_enable_sniffer(hw, 1))
4156 4157 4158 4159 4160 4161 4162 4163 4164 4165 4166
			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;
}

4167 4168 4169 4170 4171 4172 4173 4174
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;
}

4175 4176 4177 4178 4179 4180
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;
4181 4182
	struct mwl8k_cmd_pkt *cmd = (void *)(unsigned long)multicast;

4183 4184 4185 4186 4187 4188 4189 4190 4191 4192
	/*
	 * 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;
	}

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

4203
	/* Clear unsupported feature flags */
L
Lennert Buytenhek 已提交
4204
	*total_flags &= FIF_ALLMULTI | FIF_BCN_PRBRESP_PROMISC;
4205

4206 4207
	if (mwl8k_fw_lock(hw)) {
		kfree(cmd);
4208
		return;
4209
	}
4210

4211
	if (priv->sniffer_enabled) {
4212
		mwl8k_cmd_enable_sniffer(hw, 0);
4213 4214 4215
		priv->sniffer_enabled = false;
	}

4216
	if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
4217 4218 4219 4220
		if (*total_flags & FIF_BCN_PRBRESP_PROMISC) {
			/*
			 * Disable the BSS filter.
			 */
4221
			mwl8k_cmd_set_pre_scan(hw);
4222
		} else {
4223
			struct mwl8k_vif *mwl8k_vif;
4224
			const u8 *bssid;
4225

4226 4227 4228 4229 4230 4231 4232 4233
			/*
			 * 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).
			 */
4234 4235 4236 4237 4238
			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";
4239

4240
			mwl8k_cmd_set_post_scan(hw, bssid);
4241 4242 4243
		}
	}

L
Lennert Buytenhek 已提交
4244 4245 4246 4247 4248 4249 4250 4251
	/*
	 * 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);
4252
		cmd = __mwl8k_cmd_mac_multicast_adr(hw, 1, NULL);
L
Lennert Buytenhek 已提交
4253 4254 4255 4256 4257
	}

	if (cmd != NULL) {
		mwl8k_post_cmd(hw, cmd);
		kfree(cmd);
4258
	}
4259

4260
	mwl8k_fw_unlock(hw);
4261 4262 4263 4264
}

static int mwl8k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
{
L
Lennert Buytenhek 已提交
4265
	return mwl8k_cmd_set_rts_threshold(hw, value);
4266 4267
}

4268 4269 4270
static int mwl8k_sta_remove(struct ieee80211_hw *hw,
			    struct ieee80211_vif *vif,
			    struct ieee80211_sta *sta)
4271 4272 4273
{
	struct mwl8k_priv *priv = hw->priv;

4274 4275 4276 4277
	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);
4278 4279
}

4280 4281 4282
static int mwl8k_sta_add(struct ieee80211_hw *hw,
			 struct ieee80211_vif *vif,
			 struct ieee80211_sta *sta)
4283 4284
{
	struct mwl8k_priv *priv = hw->priv;
4285
	int ret;
4286 4287 4288
	int i;
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
	struct ieee80211_key_conf *key;
4289

4290 4291 4292 4293
	if (!priv->ap_fw) {
		ret = mwl8k_cmd_update_stadb_add(hw, vif, sta);
		if (ret >= 0) {
			MWL8K_STA(sta)->peer_id = ret;
4294
			ret = 0;
4295
		}
4296

4297 4298
	} else {
		ret = mwl8k_cmd_set_new_stn_add(hw, vif, sta);
4299
	}
4300

4301 4302 4303 4304 4305
	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);
	}
4306
	return ret;
4307 4308
}

4309 4310 4311
static int mwl8k_conf_tx(struct ieee80211_hw *hw, u16 queue,
			 const struct ieee80211_tx_queue_params *params)
{
4312
	struct mwl8k_priv *priv = hw->priv;
4313 4314
	int rc;

4315 4316
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
4317 4318 4319
		BUG_ON(queue > MWL8K_TX_QUEUES - 1);
		memcpy(&priv->wmm_params[queue], params, sizeof(*params));

4320
		if (!priv->wmm_enabled)
4321
			rc = mwl8k_cmd_set_wmm_mode(hw, 1);
4322

4323
		if (!rc)
4324 4325 4326 4327 4328
			rc = mwl8k_cmd_set_edca_params(hw, queue,
						       params->cw_min,
						       params->cw_max,
						       params->aifs,
						       params->txop);
4329 4330

		mwl8k_fw_unlock(hw);
4331
	}
4332

4333 4334 4335 4336 4337 4338
	return rc;
}

static int mwl8k_get_stats(struct ieee80211_hw *hw,
			   struct ieee80211_low_level_stats *stats)
{
4339
	return mwl8k_cmd_get_stat(hw, stats);
4340 4341
}

4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357
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;
}

4358 4359 4360
static int
mwl8k_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		   enum ieee80211_ampdu_mlme_action action,
4361 4362
		   struct ieee80211_sta *sta, u16 tid, u16 *ssn,
		   u8 buf_size)
4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374
{
	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;
	}
}

4375 4376 4377 4378 4379 4380 4381 4382
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,
4383
	.prepare_multicast	= mwl8k_prepare_multicast,
4384
	.configure_filter	= mwl8k_configure_filter,
4385
	.set_key                = mwl8k_set_key,
4386
	.set_rts_threshold	= mwl8k_set_rts_threshold,
4387 4388
	.sta_add		= mwl8k_sta_add,
	.sta_remove		= mwl8k_sta_remove,
4389 4390
	.conf_tx		= mwl8k_conf_tx,
	.get_stats		= mwl8k_get_stats,
4391
	.get_survey		= mwl8k_get_survey,
4392
	.ampdu_action		= mwl8k_ampdu_action,
4393 4394 4395 4396 4397 4398 4399
};

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;
4400 4401 4402 4403 4404 4405 4406 4407
	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];
4408

4409
	mwl8k_cmd_finalize_join(priv->hw, skb->data, skb->len, dtim_period);
4410

4411
	dev_kfree_skb(skb);
4412 4413 4414
	priv->beacon_skb = NULL;
}

4415
enum {
4416 4417
	MWL8363 = 0,
	MWL8687,
4418
	MWL8366,
4419 4420
};

4421 4422 4423 4424
#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)

4425
static struct mwl8k_device_info mwl8k_info_tbl[] __devinitdata = {
4426 4427 4428
	[MWL8363] = {
		.part_name	= "88w8363",
		.helper_image	= "mwl8k/helper_8363.fw",
4429
		.fw_image_sta	= "mwl8k/fmimage_8363.fw",
4430
	},
4431
	[MWL8687] = {
4432 4433
		.part_name	= "88w8687",
		.helper_image	= "mwl8k/helper_8687.fw",
4434
		.fw_image_sta	= "mwl8k/fmimage_8687.fw",
4435
	},
4436
	[MWL8366] = {
4437 4438
		.part_name	= "88w8366",
		.helper_image	= "mwl8k/helper_8366.fw",
4439
		.fw_image_sta	= "mwl8k/fmimage_8366.fw",
4440 4441
		.fw_image_ap	= MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API),
		.fw_api_ap	= MWL8K_8366_AP_FW_API,
4442
		.ap_rxd_ops	= &rxd_8366_ap_ops,
4443
	},
4444 4445
};

4446 4447 4448 4449 4450 4451
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");
4452
MODULE_FIRMWARE(MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API));
4453

4454
static DEFINE_PCI_DEVICE_TABLE(mwl8k_pci_id_table) = {
4455
	{ PCI_VDEVICE(MARVELL, 0x2a0a), .driver_data = MWL8363, },
4456 4457
	{ PCI_VDEVICE(MARVELL, 0x2a0c), .driver_data = MWL8363, },
	{ PCI_VDEVICE(MARVELL, 0x2a24), .driver_data = MWL8363, },
4458 4459 4460
	{ PCI_VDEVICE(MARVELL, 0x2a2b), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a30), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a40), .driver_data = MWL8366, },
4461
	{ PCI_VDEVICE(MARVELL, 0x2a43), .driver_data = MWL8366, },
4462
	{ },
4463 4464 4465
};
MODULE_DEVICE_TABLE(pci, mwl8k_pci_id_table);

4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476 4477 4478 4479 4480 4481 4482 4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513 4514 4515 4516 4517 4518 4519 4520 4521 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
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)
4559
{
4560
	struct mwl8k_priv *priv = hw->priv;
4561
	int rc;
4562 4563 4564 4565 4566

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

	/* Ask userland hotplug daemon for the device firmware */
4567
	rc = mwl8k_request_firmware(priv, fw_image, nowait);
4568
	if (rc) {
4569
		wiphy_err(hw->wiphy, "Firmware files not found\n");
4570
		return rc;
4571 4572
	}

4573 4574 4575
	if (nowait)
		return rc;

4576 4577
	/* Load firmware into hardware */
	rc = mwl8k_load_firmware(hw);
4578
	if (rc)
4579
		wiphy_err(hw->wiphy, "Cannot start firmware\n");
4580 4581 4582 4583

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

4584 4585 4586 4587 4588 4589 4590 4591 4592
	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;
4593

4594
	if (priv->ap_fw) {
4595
		priv->rxd_ops = priv->device_info->ap_rxd_ops;
4596
		if (priv->rxd_ops == NULL) {
4597 4598
			wiphy_err(hw->wiphy,
				  "Driver does not have AP firmware image support for this hardware\n");
4599 4600 4601
			goto err_stop_firmware;
		}
	} else {
4602
		priv->rxd_ops = &rxd_sta_ops;
4603
	}
4604 4605 4606 4607 4608

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

4609 4610
	rc = mwl8k_rxq_init(hw, 0);
	if (rc)
4611
		goto err_stop_firmware;
4612 4613 4614 4615 4616 4617 4618 4619 4620
	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);
4621
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4622
	iowrite32(MWL8K_A2H_INT_TX_DONE | MWL8K_A2H_INT_RX_READY,
4623
		  priv->regs + MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL);
4624 4625
	iowrite32(0xffffffff, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);

4626
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
4627 4628
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
4629
		wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
4630 4631 4632 4633 4634
		goto err_free_queues;
	}

	/*
	 * Temporarily enable interrupts.  Initial firmware host
L
Lennert Buytenhek 已提交
4635
	 * commands use interrupts and avoid polling.  Disable
4636 4637
	 * interrupts when done.
	 */
4638
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4639 4640

	/* Get config data, mac addrs etc */
4641 4642 4643 4644 4645 4646 4647
	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);
	}
4648
	if (rc) {
4649
		wiphy_err(hw->wiphy, "Cannot initialise firmware\n");
4650
		goto err_free_irq;
4651 4652 4653
	}

	/* Turn radio off */
4654
	rc = mwl8k_cmd_radio_disable(hw);
4655
	if (rc) {
4656
		wiphy_err(hw->wiphy, "Cannot disable\n");
4657
		goto err_free_irq;
4658 4659
	}

4660
	/* Clear MAC address */
4661
	rc = mwl8k_cmd_set_mac_addr(hw, NULL, "\x00\x00\x00\x00\x00\x00");
4662
	if (rc) {
4663
		wiphy_err(hw->wiphy, "Cannot clear MAC address\n");
4664
		goto err_free_irq;
4665 4666
	}

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

4671 4672 4673 4674 4675 4676
	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);
4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688

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

4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705 4706 4707 4708 4709
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);

4710
	rc = mwl8k_init_firmware(hw, fw_image, false);
4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743
	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;

4744 4745 4746 4747 4748 4749 4750
	rc = mwl8k_load_firmware(hw);
	mwl8k_release_firmware(priv);
	if (rc) {
		wiphy_err(hw->wiphy, "Cannot start firmware\n");
		return rc;
	}

4751 4752 4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 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
	/*
	 * Extra headroom is the size of the required DMA header
	 * minus the size of the smallest 802.11 frame (CTS frame).
	 */
	hw->extra_tx_headroom =
		sizeof(struct mwl8k_dma_data) - sizeof(struct ieee80211_cts);

	hw->channel_change_time = 10;

	hw->queues = MWL8K_TX_QUEUES;

	/* Set rssi values to dBm */
	hw->flags |= IEEE80211_HW_SIGNAL_DBM;
	hw->vif_data_size = sizeof(struct mwl8k_vif);
	hw->sta_data_size = sizeof(struct mwl8k_sta);

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

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

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

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

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

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

	spin_lock_init(&priv->tx_lock);

	priv->tx_wait = NULL;

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

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

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

	return 0;

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

4820
err_free_cookie:
4821 4822 4823 4824
	if (priv->cookie != NULL)
		pci_free_consistent(priv->pdev, 4,
				priv->cookie, priv->cookie_dma);

4825 4826 4827 4828 4829 4830 4831 4832
	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;
4833
	struct mwl8k_device_info *di;
4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 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
	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;
		}
	}

4894
	/*
4895 4896 4897
	 * 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.
4898
	 */
4899
	init_completion(&priv->firmware_loading_complete);
4900
	di = priv->device_info;
4901 4902 4903 4904 4905 4906 4907
	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) {
4908
		printk(KERN_WARNING "AP fw is unavailable.  Using STA fw.");
4909
		priv->fw_pref = di->fw_image_sta;
4910 4911
	} else if (!ap_mode_default && !di->fw_image_sta && di->fw_image_ap) {
		printk(KERN_WARNING "STA fw is unavailable.  Using AP fw.");
4912 4913 4914
		priv->fw_pref = di->fw_image_ap;
	}
	rc = mwl8k_init_firmware(hw, priv->fw_pref, true);
4915 4916
	if (rc)
		goto err_stop_firmware;
4917
	return rc;
4918

4919 4920 4921 4922
err_stop_firmware:
	mwl8k_hw_reset(priv);

err_iounmap:
4923 4924 4925
	if (priv->regs != NULL)
		pci_iounmap(pdev, priv->regs);

L
Lennert Buytenhek 已提交
4926 4927 4928
	if (priv->sram != NULL)
		pci_iounmap(pdev, priv->sram);

4929 4930 4931 4932 4933
	pci_set_drvdata(pdev, NULL);
	ieee80211_free_hw(hw);

err_free_reg:
	pci_release_regions(pdev);
4934 4935

err_disable_device:
4936 4937 4938 4939 4940
	pci_disable_device(pdev);

	return rc;
}

4941
static void __devexit mwl8k_shutdown(struct pci_dev *pdev)
4942 4943 4944 4945
{
	printk(KERN_ERR "===>%s(%u)\n", __func__, __LINE__);
}

4946
static void __devexit mwl8k_remove(struct pci_dev *pdev)
4947 4948 4949 4950 4951 4952 4953 4954 4955
{
	struct ieee80211_hw *hw = pci_get_drvdata(pdev);
	struct mwl8k_priv *priv;
	int i;

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

4956 4957 4958 4959 4960 4961 4962
	wait_for_completion(&priv->firmware_loading_complete);

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

4963 4964
	ieee80211_stop_queues(hw);

4965 4966
	ieee80211_unregister_hw(hw);

4967
	/* Remove TX reclaim and RX tasklets.  */
4968
	tasklet_kill(&priv->poll_tx_task);
4969
	tasklet_kill(&priv->poll_rx_task);
4970 4971 4972 4973 4974 4975

	/* Stop hardware */
	mwl8k_hw_reset(priv);

	/* Return all skbs to mac80211 */
	for (i = 0; i < MWL8K_TX_QUEUES; i++)
4976
		mwl8k_txq_reclaim(hw, i, INT_MAX, 1);
4977 4978 4979 4980 4981 4982

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

	mwl8k_rxq_deinit(hw, 0);

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

4985
unmap:
4986
	pci_iounmap(pdev, priv->regs);
L
Lennert Buytenhek 已提交
4987
	pci_iounmap(pdev, priv->sram);
4988 4989 4990 4991 4992 4993 4994 4995
	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,
4996
	.id_table	= mwl8k_pci_id_table,
4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013
	.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 已提交
5014 5015 5016 5017 5018

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