mwl8k.c 126.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

#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
88
#define MWL8K_TX_WMM_QUEUES	4
89
#define MWL8K_MAX_AMPDU_QUEUES	8
90 91
#define MWL8K_MAX_TX_QUEUES	(MWL8K_TX_WMM_QUEUES + MWL8K_MAX_AMPDU_QUEUES)
#define mwl8k_tx_queues(priv)	(MWL8K_TX_WMM_QUEUES + (priv)->num_ampdu_queues)
92

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

101
struct mwl8k_device_info {
102 103
	char *part_name;
	char *helper_image;
104 105
	char *fw_image_sta;
	char *fw_image_ap;
106
	struct rxd_ops *ap_rxd_ops;
107
	u32 fw_api_ap;
108 109
};

110
struct mwl8k_rx_queue {
111
	int rxd_count;
112 113

	/* hw receives here */
114
	int head;
115 116

	/* refill descs here */
117
	int tail;
118

119
	void *rxd;
120
	dma_addr_t rxd_dma;
121 122
	struct {
		struct sk_buff *skb;
123
		DEFINE_DMA_UNMAP_ADDR(dma);
124
	} *buf;
125 126 127 128
};

struct mwl8k_tx_queue {
	/* hw transmits here */
129
	int head;
130 131

	/* sw appends here */
132
	int tail;
133

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

140 141 142 143 144 145 146
enum {
	AMPDU_NO_STREAM,
	AMPDU_STREAM_NEW,
	AMPDU_STREAM_IN_PROGRESS,
	AMPDU_STREAM_ACTIVE,
};

147 148 149 150 151 152 153 154
struct mwl8k_ampdu_stream {
	struct ieee80211_sta *sta;
	u8 tid;
	u8 state;
	u8 idx;
	u8 txq_idx; /* index of this stream in priv->txq */
};

155 156 157 158
struct mwl8k_priv {
	struct ieee80211_hw *hw;
	struct pci_dev *pdev;

159 160
	struct mwl8k_device_info *device_info;

161 162 163 164
	void __iomem *sram;
	void __iomem *regs;

	/* firmware */
165 166
	const struct firmware *fw_helper;
	const struct firmware *fw_ucode;
167

168 169 170
	/* hardware/firmware parameters */
	bool ap_fw;
	struct rxd_ops *rxd_ops;
171 172 173
	struct ieee80211_supported_band band_24;
	struct ieee80211_channel channels_24[14];
	struct ieee80211_rate rates_24[14];
174 175 176
	struct ieee80211_supported_band band_50;
	struct ieee80211_channel channels_50[4];
	struct ieee80211_rate rates_50[9];
177 178
	u32 ap_macids_supported;
	u32 sta_macids_supported;
179

180 181
	/* Ampdu stream information */
	u8 num_ampdu_queues;
182 183
	spinlock_t stream_lock;
	struct mwl8k_ampdu_stream ampdu[MWL8K_MAX_AMPDU_QUEUES];
184

185 186 187 188 189 190
	/* firmware access */
	struct mutex fw_mutex;
	struct task_struct *fw_mutex_owner;
	int fw_mutex_depth;
	struct completion *hostcmd_wait;

191 192 193
	/* lock held over TX and TX reap */
	spinlock_t tx_lock;

194 195 196
	/* TX quiesce completion, protected by fw_mutex and tx_lock */
	struct completion *tx_wait;

197
	/* List of interfaces.  */
198
	u32 macids_used;
199
	struct list_head vif_list;
200 201 202 203 204 205 206

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

	u16 num_mcaddrs;
	u8 hw_rev;
207
	u32 fw_rev;
208 209 210 211 212 213 214 215

	/*
	 * 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];
216 217
	struct mwl8k_tx_queue txq[MWL8K_MAX_TX_QUEUES];
	u32 txq_offset[MWL8K_MAX_TX_QUEUES];
218

219
	bool radio_on;
220
	bool radio_short_preamble;
221
	bool sniffer_enabled;
222
	bool wmm_enabled;
223 224 225

	/* XXX need to convert this to handle multiple interfaces */
	bool capture_beacon;
226
	u8 capture_bssid[ETH_ALEN];
227 228 229 230 231 232 233 234 235 236
	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;

237 238
	/* Tasklet to perform TX reclaim.  */
	struct tasklet_struct poll_tx_task;
239 240 241

	/* Tasklet to perform RX.  */
	struct tasklet_struct poll_rx_task;
242 243 244

	/* Most recently reported noise in dBm */
	s8 noise;
245 246 247 248 249

	/*
	 * preserve the queue configurations so they can be restored if/when
	 * the firmware image is swapped.
	 */
250
	struct ieee80211_tx_queue_params wmm_params[MWL8K_TX_WMM_QUEUES];
251 252 253 254 255 256

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

259 260 261
#define MAX_WEP_KEY_LEN         13
#define NUM_WEP_KEYS            4

262 263
/* Per interface specific private data */
struct mwl8k_vif {
264 265 266
	struct list_head list;
	struct ieee80211_vif *vif;

267 268 269
	/* Firmware macid for this vif.  */
	int macid;

L
Lennert Buytenhek 已提交
270
	/* Non AMPDU sequence number assigned by driver.  */
271
	u16 seqno;
272 273 274 275 276 277

	/* Saved WEP keys */
	struct {
		u8 enabled;
		u8 key[sizeof(struct ieee80211_key_conf) + MAX_WEP_KEY_LEN];
	} wep_key_conf[NUM_WEP_KEYS];
278 279 280 281 282 283

	/* BSSID */
	u8 bssid[ETH_ALEN];

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

288 289 290 291 292 293
struct mwl8k_sta {
	/* Index into station database. Returned by UPDATE_STADB.  */
	u8 peer_id;
};
#define MWL8K_STA(_sta) ((struct mwl8k_sta *)&((_sta)->drv_priv))

294
static const struct ieee80211_channel mwl8k_channels_24[] = {
295 296 297 298 299 300 301 302 303 304 305
	{ .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, },
306 307 308
	{ .center_freq = 2467, .hw_value = 12, },
	{ .center_freq = 2472, .hw_value = 13, },
	{ .center_freq = 2484, .hw_value = 14, },
309 310
};

311
static const struct ieee80211_rate mwl8k_rates_24[] = {
312 313 314
	{ .bitrate = 10, .hw_value = 2, },
	{ .bitrate = 20, .hw_value = 4, },
	{ .bitrate = 55, .hw_value = 11, },
315 316
	{ .bitrate = 110, .hw_value = 22, },
	{ .bitrate = 220, .hw_value = 44, },
317 318 319 320 321 322 323 324
	{ .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, },
325 326 327
	{ .bitrate = 720, .hw_value = 144, },
};

328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
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, },
};

347 348
/* Set or get info from Firmware */
#define MWL8K_CMD_GET			0x0000
349 350
#define MWL8K_CMD_SET			0x0001
#define MWL8K_CMD_SET_LIST		0x0002
351 352 353 354

/* Firmware command codes */
#define MWL8K_CMD_CODE_DNLD		0x0001
#define MWL8K_CMD_GET_HW_SPEC		0x0003
355
#define MWL8K_CMD_SET_HW_SPEC		0x0004
356 357
#define MWL8K_CMD_MAC_MULTICAST_ADR	0x0010
#define MWL8K_CMD_GET_STAT		0x0014
358 359
#define MWL8K_CMD_RADIO_CONTROL		0x001c
#define MWL8K_CMD_RF_TX_POWER		0x001e
360
#define MWL8K_CMD_TX_POWER		0x001f
361
#define MWL8K_CMD_RF_ANTENNA		0x0020
362
#define MWL8K_CMD_SET_BEACON		0x0100		/* per-vif */
363 364
#define MWL8K_CMD_SET_PRE_SCAN		0x0107
#define MWL8K_CMD_SET_POST_SCAN		0x0108
365 366 367 368 369
#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
370
#define MWL8K_CMD_SET_SLOT		0x0114
371 372
#define MWL8K_CMD_SET_EDCA_PARAMS	0x0115
#define MWL8K_CMD_SET_WMM_MODE		0x0123
373
#define MWL8K_CMD_MIMO_CONFIG		0x0125
374
#define MWL8K_CMD_USE_FIXED_RATE	0x0126
375
#define MWL8K_CMD_ENABLE_SNIFFER	0x0150
376
#define MWL8K_CMD_SET_MAC_ADDR		0x0202		/* per-vif */
377
#define MWL8K_CMD_SET_RATEADAPT_MODE	0x0203
378 379
#define MWL8K_CMD_BSS_START		0x1100		/* per-vif */
#define MWL8K_CMD_SET_NEW_STN		0x1111		/* per-vif */
380
#define MWL8K_CMD_UPDATE_ENCRYPTION	0x1122		/* per-vif */
381
#define MWL8K_CMD_UPDATE_STADB		0x1123
382
#define MWL8K_CMD_BASTREAM		0x1125
383

384
static const char *mwl8k_cmd_name(__le16 cmd, char *buf, int bufsize)
385
{
386 387
	u16 command = le16_to_cpu(cmd);

388 389 390 391
#define MWL8K_CMDNAME(x)	case MWL8K_CMD_##x: do {\
					snprintf(buf, bufsize, "%s", #x);\
					return buf;\
					} while (0)
392
	switch (command & ~0x8000) {
393 394
		MWL8K_CMDNAME(CODE_DNLD);
		MWL8K_CMDNAME(GET_HW_SPEC);
395
		MWL8K_CMDNAME(SET_HW_SPEC);
396 397 398 399
		MWL8K_CMDNAME(MAC_MULTICAST_ADR);
		MWL8K_CMDNAME(GET_STAT);
		MWL8K_CMDNAME(RADIO_CONTROL);
		MWL8K_CMDNAME(RF_TX_POWER);
400
		MWL8K_CMDNAME(TX_POWER);
401
		MWL8K_CMDNAME(RF_ANTENNA);
402
		MWL8K_CMDNAME(SET_BEACON);
403 404 405
		MWL8K_CMDNAME(SET_PRE_SCAN);
		MWL8K_CMDNAME(SET_POST_SCAN);
		MWL8K_CMDNAME(SET_RF_CHANNEL);
406 407 408 409
		MWL8K_CMDNAME(SET_AID);
		MWL8K_CMDNAME(SET_RATE);
		MWL8K_CMDNAME(SET_FINALIZE_JOIN);
		MWL8K_CMDNAME(RTS_THRESHOLD);
410
		MWL8K_CMDNAME(SET_SLOT);
411 412
		MWL8K_CMDNAME(SET_EDCA_PARAMS);
		MWL8K_CMDNAME(SET_WMM_MODE);
413
		MWL8K_CMDNAME(MIMO_CONFIG);
414
		MWL8K_CMDNAME(USE_FIXED_RATE);
415
		MWL8K_CMDNAME(ENABLE_SNIFFER);
416
		MWL8K_CMDNAME(SET_MAC_ADDR);
417
		MWL8K_CMDNAME(SET_RATEADAPT_MODE);
418
		MWL8K_CMDNAME(BSS_START);
419
		MWL8K_CMDNAME(SET_NEW_STN);
420
		MWL8K_CMDNAME(UPDATE_ENCRYPTION);
421
		MWL8K_CMDNAME(UPDATE_STADB);
422
		MWL8K_CMDNAME(BASTREAM);
423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441
	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 */
442
static void mwl8k_release_fw(const struct firmware **fw)
443 444 445 446 447 448 449 450 451
{
	if (*fw == NULL)
		return;
	release_firmware(*fw);
	*fw = NULL;
}

static void mwl8k_release_firmware(struct mwl8k_priv *priv)
{
452 453
	mwl8k_release_fw(&priv->fw_ucode);
	mwl8k_release_fw(&priv->fw_helper);
454 455
}

456 457 458 459 460 461 462 463 464
/* 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,
};

465 466
/* Request fw image */
static int mwl8k_request_fw(struct mwl8k_priv *priv,
467
			    const char *fname, const struct firmware **fw,
468
			    bool nowait)
469 470 471 472 473
{
	/* release current image */
	if (*fw != NULL)
		mwl8k_release_fw(fw);

474 475 476 477 478
	if (nowait)
		return request_firmware_nowait(THIS_MODULE, 1, fname,
					       &priv->pdev->dev, GFP_KERNEL,
					       priv, mwl8k_fw_state_machine);
	else
479
		return request_firmware(fw, fname, &priv->pdev->dev);
480 481
}

482 483
static int mwl8k_request_firmware(struct mwl8k_priv *priv, char *fw_image,
				  bool nowait)
484
{
485
	struct mwl8k_device_info *di = priv->device_info;
486 487
	int rc;

488
	if (di->helper_image != NULL) {
489 490 491 492 493 494 495 496 497 498 499
		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)
500
			return rc;
501 502
	}

503 504 505 506 507 508 509 510 511 512 513 514
	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);
515
	if (rc) {
L
Lennert Buytenhek 已提交
516
		printk(KERN_ERR "%s: Error requesting firmware file %s\n",
517
		       pci_name(priv->pdev), fw_image);
518
		mwl8k_release_fw(&priv->fw_helper);
519 520 521 522 523 524 525 526 527
		return rc;
	}

	return 0;
}

struct mwl8k_cmd_pkt {
	__le16	code;
	__le16	length;
528 529
	__u8	seq_num;
	__u8	macid;
530 531
	__le16	result;
	char	payload[0];
532
} __packed;
533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564

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

565
		cond_resched();
566 567 568 569 570
		udelay(1);
	} while (--loops);

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

571
	return loops ? 0 : -ETIMEDOUT;
572 573 574 575 576 577 578 579 580 581 582 583 584 585 586
}

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;
587
	cmd->macid = 0;
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 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
	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 已提交
675
static int mwl8k_load_firmware(struct ieee80211_hw *hw)
676
{
L
Lennert Buytenhek 已提交
677
	struct mwl8k_priv *priv = hw->priv;
678
	const struct firmware *fw = priv->fw_ucode;
L
Lennert Buytenhek 已提交
679 680 681 682
	int rc;
	int loops;

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

L
Lennert Buytenhek 已提交
685 686 687 688 689
		if (helper == NULL) {
			printk(KERN_ERR "%s: helper image needed but none "
			       "given\n", pci_name(priv->pdev));
			return -EINVAL;
		}
690

L
Lennert Buytenhek 已提交
691
		rc = mwl8k_load_fw_image(priv, helper->data, helper->size);
692 693
		if (rc) {
			printk(KERN_ERR "%s: unable to load firmware "
L
Lennert Buytenhek 已提交
694
			       "helper image\n", pci_name(priv->pdev));
695 696
			return rc;
		}
697
		msleep(5);
698

L
Lennert Buytenhek 已提交
699
		rc = mwl8k_feed_fw_image(priv, fw->data, fw->size);
700
	} else {
L
Lennert Buytenhek 已提交
701
		rc = mwl8k_load_fw_image(priv, fw->data, fw->size);
702 703 704
	}

	if (rc) {
L
Lennert Buytenhek 已提交
705 706
		printk(KERN_ERR "%s: unable to load firmware image\n",
		       pci_name(priv->pdev));
707 708 709
		return rc;
	}

710
	iowrite32(MWL8K_MODE_STA, priv->regs + MWL8K_HIU_GEN_PTR);
711

712
	loops = 500000;
713
	do {
714 715 716 717 718 719 720 721
		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;
722
			break;
723 724 725
		}

		cond_resched();
726 727 728 729 730 731 732 733 734 735 736
		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;
737
	char data[0];
738
} __packed;
739 740

/* Routines to add/remove DMA header from skb.  */
741
static inline void mwl8k_remove_dma_header(struct sk_buff *skb, __le16 qos)
742
{
743 744 745 746 747 748 749 750 751 752 753 754 755
	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);
		}
756
	}
757 758 759

	if (hdrlen != sizeof(*tr))
		skb_pull(skb, sizeof(*tr) - hdrlen);
760 761
}

762 763
static void
mwl8k_add_dma_header(struct sk_buff *skb, int tail_pad)
764 765
{
	struct ieee80211_hdr *wh;
766
	int hdrlen;
767
	int reqd_hdrlen;
768 769
	struct mwl8k_dma_data *tr;

770 771 772 773 774 775
	/*
	 * 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).
	 */
776
	wh = (struct ieee80211_hdr *)skb->data;
777

778
	hdrlen = ieee80211_hdrlen(wh->frame_control);
779 780 781 782
	reqd_hdrlen = sizeof(*tr);

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

784
	if (ieee80211_is_data_qos(wh->frame_control))
785
		hdrlen -= IEEE80211_QOS_CTL_LEN;
786 787 788 789

	tr = (struct mwl8k_dma_data *)skb->data;
	if (wh != &tr->wh)
		memmove(&tr->wh, wh, hdrlen);
790 791
	if (hdrlen != sizeof(tr->wh))
		memset(((void *)&tr->wh) + hdrlen, 0, sizeof(tr->wh) - hdrlen);
792 793 794 795 796 797

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

801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843
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);
}
844 845

/*
846
 * Packet reception for 88w8366 AP firmware.
847
 */
848
struct mwl8k_rxd_8366_ap {
849 850 851 852 853 854 855 856 857 858 859 860 861 862 863
	__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;
864
} __packed;
865

866 867 868
#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)
869

870
#define MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST	0x80
871

872 873 874 875 876 877 878
/* 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

879
static void mwl8k_rxd_8366_ap_init(void *_rxd, dma_addr_t next_dma_addr)
880
{
881
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
882 883

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
884
	rxd->rx_ctrl = MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST;
885 886
}

887
static void mwl8k_rxd_8366_ap_refill(void *_rxd, dma_addr_t addr, int len)
888
{
889
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
890 891 892 893 894 895 896 897

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

static int
898
mwl8k_rxd_8366_ap_process(void *_rxd, struct ieee80211_rx_status *status,
899
			  __le16 *qos, s8 *noise)
900
{
901
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
902

903
	if (!(rxd->rx_ctrl & MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST))
904 905 906 907 908 909
		return -1;
	rmb();

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

	status->signal = -rxd->rssi;
910
	*noise = -rxd->noise_floor;
911

912
	if (rxd->rate & MWL8K_8366_AP_RATE_INFO_MCS_FORMAT) {
913
		status->flag |= RX_FLAG_HT;
914
		if (rxd->rate & MWL8K_8366_AP_RATE_INFO_40MHZ)
915
			status->flag |= RX_FLAG_40MHZ;
916
		status->rate_idx = MWL8K_8366_AP_RATE_INFO_RATEID(rxd->rate);
917 918 919
	} else {
		int i;

920 921
		for (i = 0; i < ARRAY_SIZE(mwl8k_rates_24); i++) {
			if (mwl8k_rates_24[i].hw_value == rxd->rate) {
922 923 924 925 926 927
				status->rate_idx = i;
				break;
			}
		}
	}

928 929 930 931 932 933 934
	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;
	}
935 936
	status->freq = ieee80211_channel_to_frequency(rxd->channel,
						      status->band);
937

938 939
	*qos = rxd->qos_control;

940 941 942 943 944
	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;

945 946 947
	return le16_to_cpu(rxd->pkt_len);
}

948 949 950 951 952
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,
953 954 955
};

/*
956
 * Packet reception for STA firmware.
957
 */
958
struct mwl8k_rxd_sta {
959 960 961 962
	__le16 pkt_len;
	__u8 link_quality;
	__u8 noise_level;
	__le32 pkt_phys_addr;
963
	__le32 next_rxd_phys_addr;
964 965 966 967 968 969 970 971 972
	__le16 qos_control;
	__le16 rate_info;
	__le32 pad0[4];
	__u8 rssi;
	__u8 channel;
	__le16 pad1;
	__u8 rx_ctrl;
	__u8 rx_status;
	__u8 pad2[2];
973
} __packed;
974

975 976 977 978 979 980
#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
981

982
#define MWL8K_STA_RX_CTRL_OWNED_BY_HOST		0x02
983 984 985 986 987
#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
988

989
static void mwl8k_rxd_sta_init(void *_rxd, dma_addr_t next_dma_addr)
990
{
991
	struct mwl8k_rxd_sta *rxd = _rxd;
992 993

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
994
	rxd->rx_ctrl = MWL8K_STA_RX_CTRL_OWNED_BY_HOST;
995 996
}

997
static void mwl8k_rxd_sta_refill(void *_rxd, dma_addr_t addr, int len)
998
{
999
	struct mwl8k_rxd_sta *rxd = _rxd;
1000 1001 1002 1003 1004 1005 1006 1007

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

static int
1008
mwl8k_rxd_sta_process(void *_rxd, struct ieee80211_rx_status *status,
1009
		       __le16 *qos, s8 *noise)
1010
{
1011
	struct mwl8k_rxd_sta *rxd = _rxd;
1012 1013
	u16 rate_info;

1014
	if (!(rxd->rx_ctrl & MWL8K_STA_RX_CTRL_OWNED_BY_HOST))
1015 1016 1017 1018 1019 1020 1021 1022
		return -1;
	rmb();

	rate_info = le16_to_cpu(rxd->rate_info);

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

	status->signal = -rxd->rssi;
1023
	*noise = -rxd->noise_level;
1024 1025
	status->antenna = MWL8K_STA_RATE_INFO_ANTSELECT(rate_info);
	status->rate_idx = MWL8K_STA_RATE_INFO_RATEID(rate_info);
1026

1027
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTPRE)
1028
		status->flag |= RX_FLAG_SHORTPRE;
1029
	if (rate_info & MWL8K_STA_RATE_INFO_40MHZ)
1030
		status->flag |= RX_FLAG_40MHZ;
1031
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTGI)
1032
		status->flag |= RX_FLAG_SHORT_GI;
1033
	if (rate_info & MWL8K_STA_RATE_INFO_MCS_FORMAT)
1034 1035
		status->flag |= RX_FLAG_HT;

1036 1037 1038 1039 1040 1041 1042
	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;
	}
1043 1044
	status->freq = ieee80211_channel_to_frequency(rxd->channel,
						      status->band);
1045

1046
	*qos = rxd->qos_control;
1047 1048 1049
	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;
1050

1051 1052 1053
	return le16_to_cpu(rxd->pkt_len);
}

1054 1055 1056 1057 1058
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,
1059 1060 1061
};


1062 1063 1064 1065 1066 1067 1068 1069 1070 1071
#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;

1072 1073 1074
	rxq->rxd_count = 0;
	rxq->head = 0;
	rxq->tail = 0;
1075

1076
	size = MWL8K_RX_DESCS * priv->rxd_ops->rxd_size;
1077

1078 1079
	rxq->rxd = pci_alloc_consistent(priv->pdev, size, &rxq->rxd_dma);
	if (rxq->rxd == NULL) {
1080
		wiphy_err(hw->wiphy, "failed to alloc RX descriptors\n");
1081 1082
		return -ENOMEM;
	}
1083
	memset(rxq->rxd, 0, size);
1084

1085
	rxq->buf = kcalloc(MWL8K_RX_DESCS, sizeof(*rxq->buf), GFP_KERNEL);
1086
	if (rxq->buf == NULL) {
1087
		wiphy_err(hw->wiphy, "failed to alloc RX skbuff list\n");
1088
		pci_free_consistent(priv->pdev, size, rxq->rxd, rxq->rxd_dma);
1089 1090 1091 1092
		return -ENOMEM;
	}

	for (i = 0; i < MWL8K_RX_DESCS; i++) {
1093 1094
		int desc_size;
		void *rxd;
1095
		int nexti;
1096 1097 1098 1099
		dma_addr_t next_dma_addr;

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

1101 1102 1103 1104
		nexti = i + 1;
		if (nexti == MWL8K_RX_DESCS)
			nexti = 0;
		next_dma_addr = rxq->rxd_dma + (nexti * desc_size);
1105

1106
		priv->rxd_ops->rxd_init(rxd, next_dma_addr);
1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118
	}

	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;
1119
	while (rxq->rxd_count < MWL8K_RX_DESCS && limit--) {
1120
		struct sk_buff *skb;
1121
		dma_addr_t addr;
1122
		int rx;
1123
		void *rxd;
1124 1125 1126 1127 1128

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

1129 1130
		addr = pci_map_single(priv->pdev, skb->data,
				      MWL8K_RX_MAXSZ, DMA_FROM_DEVICE);
1131

1132 1133 1134 1135
		rxq->rxd_count++;
		rx = rxq->tail++;
		if (rxq->tail == MWL8K_RX_DESCS)
			rxq->tail = 0;
1136
		rxq->buf[rx].skb = skb;
1137
		dma_unmap_addr_set(&rxq->buf[rx], dma, addr);
1138 1139 1140

		rxd = rxq->rxd + (rx * priv->rxd_ops->rxd_size);
		priv->rxd_ops->rxd_refill(rxd, addr, MWL8K_RX_MAXSZ);
1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154

		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;

1155 1156 1157
	if (rxq->rxd == NULL)
		return;

1158
	for (i = 0; i < MWL8K_RX_DESCS; i++) {
1159 1160
		if (rxq->buf[i].skb != NULL) {
			pci_unmap_single(priv->pdev,
1161
					 dma_unmap_addr(&rxq->buf[i], dma),
1162
					 MWL8K_RX_MAXSZ, PCI_DMA_FROMDEVICE);
1163
			dma_unmap_addr_set(&rxq->buf[i], dma, 0);
1164 1165 1166

			kfree_skb(rxq->buf[i].skb);
			rxq->buf[i].skb = NULL;
1167 1168 1169
		}
	}

1170 1171
	kfree(rxq->buf);
	rxq->buf = NULL;
1172 1173

	pci_free_consistent(priv->pdev,
1174
			    MWL8K_RX_DESCS * priv->rxd_ops->rxd_size,
1175 1176
			    rxq->rxd, rxq->rxd_dma);
	rxq->rxd = NULL;
1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191
}


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

1192 1193
static inline void mwl8k_save_beacon(struct ieee80211_hw *hw,
				     struct sk_buff *skb)
1194
{
1195 1196
	struct mwl8k_priv *priv = hw->priv;

1197
	priv->capture_beacon = false;
1198
	memset(priv->capture_bssid, 0, ETH_ALEN);
1199 1200 1201 1202 1203 1204 1205 1206

	/*
	 * 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)
1207
		ieee80211_queue_work(hw, &priv->finalize_join_worker);
1208 1209
}

1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224
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;
}

1225 1226 1227
static int rxq_process(struct ieee80211_hw *hw, int index, int limit)
{
	struct mwl8k_priv *priv = hw->priv;
1228
	struct mwl8k_vif *mwl8k_vif = NULL;
1229 1230 1231 1232
	struct mwl8k_rx_queue *rxq = priv->rxq + index;
	int processed;

	processed = 0;
1233
	while (rxq->rxd_count && limit--) {
1234
		struct sk_buff *skb;
1235 1236
		void *rxd;
		int pkt_len;
1237
		struct ieee80211_rx_status status;
1238
		struct ieee80211_hdr *wh;
1239
		__le16 qos;
1240

1241
		skb = rxq->buf[rxq->head].skb;
1242 1243
		if (skb == NULL)
			break;
1244 1245 1246

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

1247 1248
		pkt_len = priv->rxd_ops->rxd_process(rxd, &status, &qos,
							&priv->noise);
1249 1250 1251
		if (pkt_len < 0)
			break;

1252 1253 1254
		rxq->buf[rxq->head].skb = NULL;

		pci_unmap_single(priv->pdev,
1255
				 dma_unmap_addr(&rxq->buf[rxq->head], dma),
1256
				 MWL8K_RX_MAXSZ, PCI_DMA_FROMDEVICE);
1257
		dma_unmap_addr_set(&rxq->buf[rxq->head], dma, 0);
1258

1259 1260 1261 1262
		rxq->head++;
		if (rxq->head == MWL8K_RX_DESCS)
			rxq->head = 0;

1263
		rxq->rxd_count--;
1264

1265
		wh = &((struct mwl8k_dma_data *)skb->data)->wh;
1266 1267

		/*
L
Lennert Buytenhek 已提交
1268 1269 1270
		 * 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.
1271
		 */
1272
		if (mwl8k_capture_bssid(priv, (void *)skb->data))
1273
			mwl8k_save_beacon(hw, skb);
1274

1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314
		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);
1315 1316
		memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
		ieee80211_rx_irqsafe(hw, skb);
1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334

		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

1335 1336 1337 1338 1339 1340
#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

1341 1342 1343 1344 1345 1346 1347
struct mwl8k_tx_desc {
	__le32 status;
	__u8 data_rate;
	__u8 tx_priority;
	__le16 qos_control;
	__le32 pkt_phys_addr;
	__le16 pkt_len;
1348
	__u8 dest_MAC_addr[ETH_ALEN];
1349
	__le32 next_txd_phys_addr;
1350
	__le32 timestamp;
1351 1352
	__le16 rate_info;
	__u8 peer_id;
1353
	__u8 tx_frag_cnt;
1354
} __packed;
1355 1356 1357 1358 1359 1360 1361 1362 1363 1364

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

1365
	txq->len = 0;
1366 1367
	txq->head = 0;
	txq->tail = 0;
1368 1369 1370

	size = MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc);

1371 1372
	txq->txd = pci_alloc_consistent(priv->pdev, size, &txq->txd_dma);
	if (txq->txd == NULL) {
1373
		wiphy_err(hw->wiphy, "failed to alloc TX descriptors\n");
1374 1375
		return -ENOMEM;
	}
1376
	memset(txq->txd, 0, size);
1377

1378
	txq->skb = kcalloc(MWL8K_TX_DESCS, sizeof(*txq->skb), GFP_KERNEL);
1379
	if (txq->skb == NULL) {
1380
		wiphy_err(hw->wiphy, "failed to alloc TX skbuff list\n");
1381
		pci_free_consistent(priv->pdev, size, txq->txd, txq->txd_dma);
1382 1383 1384 1385 1386 1387 1388
		return -ENOMEM;
	}

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

1389
		tx_desc = txq->txd + i;
1390 1391 1392
		nexti = (i + 1) % MWL8K_TX_DESCS;

		tx_desc->status = 0;
1393 1394
		tx_desc->next_txd_phys_addr =
			cpu_to_le32(txq->txd_dma + nexti * sizeof(*tx_desc));
1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408
	}

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

1409
static void mwl8k_dump_tx_rings(struct ieee80211_hw *hw)
1410
{
1411 1412 1413
	struct mwl8k_priv *priv = hw->priv;
	int i;

1414
	for (i = 0; i < mwl8k_tx_queues(priv); i++) {
1415 1416 1417 1418 1419 1420
		struct mwl8k_tx_queue *txq = priv->txq + i;
		int fw_owned = 0;
		int drv_owned = 0;
		int unused = 0;
		int desc;

1421
		for (desc = 0; desc < MWL8K_TX_DESCS; desc++) {
1422 1423
			struct mwl8k_tx_desc *tx_desc = txq->txd + desc;
			u32 status;
1424

1425
			status = le32_to_cpu(tx_desc->status);
1426
			if (status & MWL8K_TXD_STATUS_FW_OWNED)
1427
				fw_owned++;
1428
			else
1429
				drv_owned++;
1430 1431

			if (tx_desc->pkt_len == 0)
1432
				unused++;
1433 1434
		}

1435 1436 1437 1438 1439 1440
		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);
1441
	}
1442 1443
}

1444
/*
1445
 * Must be called with priv->fw_mutex held and tx queues stopped.
1446
 */
1447
#define MWL8K_TX_WAIT_TIMEOUT_MS	5000
1448

1449
static int mwl8k_tx_wait_empty(struct ieee80211_hw *hw)
1450 1451
{
	struct mwl8k_priv *priv = hw->priv;
1452
	DECLARE_COMPLETION_ONSTACK(tx_wait);
1453 1454
	int retry;
	int rc;
1455 1456 1457

	might_sleep();

1458 1459 1460 1461 1462 1463 1464 1465 1466 1467
	/*
	 * 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;

1468
	spin_lock_bh(&priv->tx_lock);
1469 1470 1471 1472
	priv->tx_wait = &tx_wait;
	while (!rc) {
		int oldcount;
		unsigned long timeout;
1473

1474
		oldcount = priv->pending_tx_pkts;
1475

1476
		spin_unlock_bh(&priv->tx_lock);
1477
		timeout = wait_for_completion_timeout(&tx_wait,
1478
			    msecs_to_jiffies(MWL8K_TX_WAIT_TIMEOUT_MS));
1479
		spin_lock_bh(&priv->tx_lock);
1480 1481 1482 1483

		if (timeout) {
			WARN_ON(priv->pending_tx_pkts);
			if (retry) {
1484
				wiphy_notice(hw->wiphy, "tx rings drained\n");
1485 1486 1487 1488 1489
			}
			break;
		}

		if (priv->pending_tx_pkts < oldcount) {
1490 1491 1492
			wiphy_notice(hw->wiphy,
				     "waiting for tx rings to drain (%d -> %d pkts)\n",
				     oldcount, priv->pending_tx_pkts);
1493 1494 1495 1496
			retry = 1;
			continue;
		}

1497 1498
		priv->tx_wait = NULL;

1499 1500
		wiphy_err(hw->wiphy, "tx rings stuck for %d ms\n",
			  MWL8K_TX_WAIT_TIMEOUT_MS);
1501 1502 1503
		mwl8k_dump_tx_rings(hw);

		rc = -ETIMEDOUT;
1504
	}
1505
	spin_unlock_bh(&priv->tx_lock);
1506

1507
	return rc;
1508 1509
}

1510 1511 1512 1513
#define MWL8K_TXD_SUCCESS(status)				\
	((status) & (MWL8K_TXD_STATUS_OK |			\
		     MWL8K_TXD_STATUS_OK_RETRY |		\
		     MWL8K_TXD_STATUS_OK_MORE_RETRY))
1514

1515 1516
static int
mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int limit, int force)
1517 1518 1519
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_tx_queue *txq = priv->txq + index;
1520
	int processed;
1521

1522
	processed = 0;
1523
	while (txq->len > 0 && limit--) {
1524 1525 1526
		int tx;
		struct mwl8k_tx_desc *tx_desc;
		unsigned long addr;
1527
		int size;
1528 1529 1530 1531
		struct sk_buff *skb;
		struct ieee80211_tx_info *info;
		u32 status;

1532 1533
		tx = txq->head;
		tx_desc = txq->txd + tx;
1534 1535 1536 1537 1538 1539 1540 1541 1542 1543

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

1544
		txq->head = (tx + 1) % MWL8K_TX_DESCS;
1545 1546
		BUG_ON(txq->len == 0);
		txq->len--;
1547 1548 1549
		priv->pending_tx_pkts--;

		addr = le32_to_cpu(tx_desc->pkt_phys_addr);
1550
		size = le16_to_cpu(tx_desc->pkt_len);
1551 1552
		skb = txq->skb[tx];
		txq->skb[tx] = NULL;
1553 1554 1555 1556

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

1557
		mwl8k_remove_dma_header(skb, tx_desc->qos_control);
1558 1559 1560 1561 1562 1563 1564

		/* 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);
1565 1566 1567 1568 1569 1570 1571

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

1572
		if (MWL8K_TXD_SUCCESS(status))
1573 1574 1575 1576
			info->flags |= IEEE80211_TX_STAT_ACK;

		ieee80211_tx_status_irqsafe(hw, skb);

1577
		processed++;
1578 1579
	}

1580
	if (processed && priv->radio_on && !mutex_is_locked(&priv->fw_mutex))
1581
		ieee80211_wake_queue(hw, index);
1582 1583

	return processed;
1584 1585 1586 1587 1588 1589 1590 1591
}

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

1592 1593 1594
	if (txq->txd == NULL)
		return;

1595
	mwl8k_txq_reclaim(hw, index, INT_MAX, 1);
1596

1597 1598
	kfree(txq->skb);
	txq->skb = NULL;
1599 1600 1601

	pci_free_consistent(priv->pdev,
			    MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc),
1602 1603
			    txq->txd, txq->txd_dma);
	txq->txd = NULL;
1604 1605
}

1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639 1640 1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
/* caller must hold priv->stream_lock when calling the stream functions */
struct mwl8k_ampdu_stream *
mwl8k_add_stream(struct ieee80211_hw *hw, struct ieee80211_sta *sta, u8 tid)
{
	struct mwl8k_ampdu_stream *stream;
	struct mwl8k_priv *priv = hw->priv;
	int i;

	for (i = 0; i < priv->num_ampdu_queues; i++) {
		stream = &priv->ampdu[i];
		if (stream->state == AMPDU_NO_STREAM) {
			stream->sta = sta;
			stream->state = AMPDU_STREAM_NEW;
			stream->tid = tid;
			stream->idx = i;
			stream->txq_idx = MWL8K_TX_WMM_QUEUES + i;
			wiphy_debug(hw->wiphy, "Added a new stream for %pM %d",
				    sta->addr, tid);
			return stream;
		}
	}
	return NULL;
}

static int
mwl8k_start_stream(struct ieee80211_hw *hw, struct mwl8k_ampdu_stream *stream)
{
	int ret;

	/* if the stream has already been started, don't start it again */
	if (stream->state != AMPDU_STREAM_NEW)
		return 0;
	ret = ieee80211_start_tx_ba_session(stream->sta, stream->tid, 0);
	if (ret)
		wiphy_debug(hw->wiphy, "Failed to start stream for %pM %d: "
			    "%d\n", stream->sta->addr, stream->tid, ret);
	else
		wiphy_debug(hw->wiphy, "Started stream for %pM %d\n",
			    stream->sta->addr, stream->tid);
	return ret;
}

static void
mwl8k_remove_stream(struct ieee80211_hw *hw, struct mwl8k_ampdu_stream *stream)
{
	wiphy_debug(hw->wiphy, "Remove stream for %pM %d\n", stream->sta->addr,
		    stream->tid);
	memset(stream, 0, sizeof(*stream));
}

static struct mwl8k_ampdu_stream *
mwl8k_lookup_stream(struct ieee80211_hw *hw, u8 *addr, u8 tid)
{
	struct mwl8k_priv *priv = hw->priv;
	int i;

	for (i = 0 ; i < priv->num_ampdu_queues; i++) {
		struct mwl8k_ampdu_stream *stream;
		stream = &priv->ampdu[i];
		if (stream->state == AMPDU_NO_STREAM)
			continue;
		if (!memcmp(stream->sta->addr, addr, ETH_ALEN) &&
		    stream->tid == tid)
			return stream;
	}
	return NULL;
}

1674
static void
1675 1676 1677 1678
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;
1679
	struct mwl8k_vif *mwl8k_vif;
1680 1681 1682 1683
	struct ieee80211_hdr *wh;
	struct mwl8k_tx_queue *txq;
	struct mwl8k_tx_desc *tx;
	dma_addr_t dma;
1684 1685 1686
	u32 txstatus;
	u8 txdatarate;
	u16 qos;
1687

1688 1689 1690 1691 1692
	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;
1693

1694 1695 1696 1697 1698
	if (priv->ap_fw)
		mwl8k_encapsulate_tx_frame(skb);
	else
		mwl8k_add_dma_header(skb, 0);

1699
	wh = &((struct mwl8k_dma_data *)skb->data)->wh;
1700 1701 1702 1703 1704 1705

	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);
1706 1707
		wh->seq_ctrl |= cpu_to_le16(mwl8k_vif->seqno);
		mwl8k_vif->seqno += 0x10;
1708 1709
	}

1710 1711 1712 1713 1714 1715
	/* 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;
1716
		qos |= MWL8K_QOS_QLEN_UNSPEC | MWL8K_QOS_EOSP;
1717 1718 1719 1720 1721
	} else if (ieee80211_is_data(wh->frame_control)) {
		txdatarate = 1;
		if (is_multicast_ether_addr(wh->addr1))
			txstatus |= MWL8K_TXD_STATUS_MULTICAST_TX;

1722
		qos &= ~MWL8K_QOS_ACK_POLICY_MASK;
1723
		if (tx_info->flags & IEEE80211_TX_CTL_AMPDU)
1724
			qos |= MWL8K_QOS_ACK_POLICY_BLOCKACK;
1725
		else
1726
			qos |= MWL8K_QOS_ACK_POLICY_NORMAL;
1727
	}
1728 1729 1730 1731 1732

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

	if (pci_dma_mapping_error(priv->pdev, dma)) {
1733 1734
		wiphy_debug(hw->wiphy,
			    "failed to dma map skb, dropping TX frame.\n");
1735
		dev_kfree_skb(skb);
1736
		return;
1737 1738
	}

1739
	spin_lock_bh(&priv->tx_lock);
1740

1741
	txq = priv->txq + index;
1742

1743 1744
	BUG_ON(txq->skb[txq->tail] != NULL);
	txq->skb[txq->tail] = skb;
1745

1746
	tx = txq->txd + txq->tail;
1747 1748
	tx->data_rate = txdatarate;
	tx->tx_priority = index;
1749 1750 1751
	tx->qos_control = cpu_to_le16(qos);
	tx->pkt_phys_addr = cpu_to_le32(dma);
	tx->pkt_len = cpu_to_le16(skb->len);
1752
	tx->rate_info = 0;
1753 1754 1755 1756
	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;
1757
	wmb();
1758 1759
	tx->status = cpu_to_le32(MWL8K_TXD_STATUS_FW_OWNED | txstatus);

1760
	txq->len++;
1761 1762
	priv->pending_tx_pkts++;

1763 1764 1765
	txq->tail++;
	if (txq->tail == MWL8K_TX_DESCS)
		txq->tail = 0;
1766

1767
	if (txq->head == txq->tail)
1768 1769
		ieee80211_stop_queue(hw, index);

1770
	mwl8k_tx_start(priv);
1771 1772 1773 1774 1775

	spin_unlock_bh(&priv->tx_lock);
}


1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829
/*
 * 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);
	}
}


1830 1831 1832 1833
/*
 * Command processing.
 */

1834 1835
/* Timeout firmware commands after 10s */
#define MWL8K_CMD_TIMEOUT_MS	10000
1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847

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

1848
	cmd->result = (__force __le16) 0xffff;
1849 1850 1851 1852 1853 1854
	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;

1855
	rc = mwl8k_fw_lock(hw);
1856 1857 1858
	if (rc) {
		pci_unmap_single(priv->pdev, dma_addr, dma_size,
						PCI_DMA_BIDIRECTIONAL);
1859
		return rc;
1860
	}
1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871

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

1872 1873 1874 1875
	priv->hostcmd_wait = NULL;

	mwl8k_fw_unlock(hw);

1876 1877 1878
	pci_unmap_single(priv->pdev, dma_addr, dma_size,
					PCI_DMA_BIDIRECTIONAL);

1879
	if (!timeout) {
1880
		wiphy_err(hw->wiphy, "Command %s timeout after %u ms\n",
1881 1882
			  mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
			  MWL8K_CMD_TIMEOUT_MS);
1883 1884
		rc = -ETIMEDOUT;
	} else {
1885 1886 1887 1888
		int ms;

		ms = MWL8K_CMD_TIMEOUT_MS - jiffies_to_msecs(timeout);

1889
		rc = cmd->result ? -EINVAL : 0;
1890
		if (rc)
1891
			wiphy_err(hw->wiphy, "Command %s error 0x%x\n",
1892 1893
				  mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
				  le16_to_cpu(cmd->result));
1894
		else if (ms > 2000)
1895
			wiphy_notice(hw->wiphy, "Command %s took %d ms\n",
1896 1897 1898
				     mwl8k_cmd_name(cmd->code,
						    buf, sizeof(buf)),
				     ms);
1899 1900 1901 1902 1903
	}

	return rc;
}

1904 1905 1906 1907 1908 1909 1910 1911 1912
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);
}

1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934
/*
 * 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;
}

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

1954
/*
1955
 * CMD_GET_HW_SPEC (STA version).
1956
 */
1957
struct mwl8k_cmd_get_hw_spec_sta {
1958 1959 1960 1961
	struct mwl8k_cmd_pkt header;
	__u8 hw_rev;
	__u8 host_interface;
	__le16 num_mcaddrs;
1962
	__u8 perm_addr[ETH_ALEN];
1963 1964 1965 1966 1967 1968 1969
	__le16 region_code;
	__le32 fw_rev;
	__le32 ps_cookie;
	__le32 caps;
	__u8 mcs_bitmap[16];
	__le32 rx_queue_ptr;
	__le32 num_tx_queues;
1970
	__le32 tx_queue_ptrs[MWL8K_TX_WMM_QUEUES];
1971 1972
	__le32 caps2;
	__le32 num_tx_desc_per_queue;
1973
	__le32 total_rxd;
1974
} __packed;
1975

1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986 1987
#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
1988 1989 1990
#define MWL8K_CAP_BAND_MASK		0x00000007
#define MWL8K_CAP_5GHZ			0x00000004
#define MWL8K_CAP_2GHZ4			0x00000001
1991

1992 1993 1994
static void
mwl8k_set_ht_caps(struct ieee80211_hw *hw,
		  struct ieee80211_supported_band *band, u32 cap)
1995 1996 1997 1998
{
	int rx_streams;
	int tx_streams;

1999
	band->ht_cap.ht_supported = 1;
2000 2001

	if (cap & MWL8K_CAP_MAX_AMSDU)
2002
		band->ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
2003
	if (cap & MWL8K_CAP_GREENFIELD)
2004
		band->ht_cap.cap |= IEEE80211_HT_CAP_GRN_FLD;
2005 2006
	if (cap & MWL8K_CAP_AMPDU) {
		hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
2007 2008
		band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
		band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
2009 2010
	}
	if (cap & MWL8K_CAP_RX_STBC)
2011
		band->ht_cap.cap |= IEEE80211_HT_CAP_RX_STBC;
2012
	if (cap & MWL8K_CAP_TX_STBC)
2013
		band->ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
2014
	if (cap & MWL8K_CAP_SHORTGI_40MHZ)
2015
		band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
2016
	if (cap & MWL8K_CAP_SHORTGI_20MHZ)
2017
		band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
2018
	if (cap & MWL8K_CAP_DELAY_BA)
2019
		band->ht_cap.cap |= IEEE80211_HT_CAP_DELAY_BA;
2020
	if (cap & MWL8K_CAP_40MHZ)
2021
		band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
2022 2023 2024 2025

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

2026
	band->ht_cap.mcs.rx_mask[0] = 0xff;
2027
	if (rx_streams >= 2)
2028
		band->ht_cap.mcs.rx_mask[1] = 0xff;
2029
	if (rx_streams >= 3)
2030 2031 2032
		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;
2033 2034

	if (rx_streams != tx_streams) {
2035 2036
		band->ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
		band->ht_cap.mcs.tx_params |= (tx_streams - 1) <<
2037 2038 2039 2040
				IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
	}
}

2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058
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);
	}
}

2059
static int mwl8k_cmd_get_hw_spec_sta(struct ieee80211_hw *hw)
2060 2061
{
	struct mwl8k_priv *priv = hw->priv;
2062
	struct mwl8k_cmd_get_hw_spec_sta *cmd;
2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074
	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);
2075
	cmd->rx_queue_ptr = cpu_to_le32(priv->rxq[0].rxd_dma);
2076 2077
	cmd->num_tx_queues = cpu_to_le32(mwl8k_tx_queues(priv));
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
2078
		cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[i].txd_dma);
2079
	cmd->num_tx_desc_per_queue = cpu_to_le32(MWL8K_TX_DESCS);
2080
	cmd->total_rxd = cpu_to_le32(MWL8K_RX_DESCS);
2081 2082 2083 2084 2085 2086

	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);
2087
		priv->fw_rev = le32_to_cpu(cmd->fw_rev);
2088
		priv->hw_rev = cmd->hw_rev;
2089
		mwl8k_set_caps(hw, le32_to_cpu(cmd->caps));
2090 2091
		priv->ap_macids_supported = 0x00000000;
		priv->sta_macids_supported = 0x00000001;
2092 2093 2094 2095 2096 2097
	}

	kfree(cmd);
	return rc;
}

2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117
/*
 * 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;
2118
	__le32 fw_api_version;
2119 2120 2121
	__le32 caps;
	__le32 num_of_ampdu_queues;
	__le32 wcbbase_ampdu[MWL8K_MAX_AMPDU_QUEUES];
2122
} __packed;
2123 2124 2125 2126 2127

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;
2128
	int rc, i;
2129
	u32 api_version;
2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145

	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;

2146 2147 2148 2149 2150 2151 2152 2153 2154 2155
		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;
		}
2156 2157 2158 2159
		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;
2160
		mwl8k_set_caps(hw, le32_to_cpu(cmd->caps));
2161 2162
		priv->ap_macids_supported = 0x000000ff;
		priv->sta_macids_supported = 0x00000000;
2163 2164 2165 2166 2167 2168 2169 2170
		priv->num_ampdu_queues = le32_to_cpu(cmd->num_of_ampdu_queues);
		if (priv->num_ampdu_queues > MWL8K_MAX_AMPDU_QUEUES) {
			wiphy_warn(hw->wiphy, "fw reported %d ampdu queues"
				   " but we only support %d.\n",
				   priv->num_ampdu_queues,
				   MWL8K_MAX_AMPDU_QUEUES);
			priv->num_ampdu_queues = MWL8K_MAX_AMPDU_QUEUES;
		}
2171
		off = le32_to_cpu(cmd->rxwrptr) & 0xffff;
2172
		iowrite32(priv->rxq[0].rxd_dma, priv->sram + off);
2173 2174

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

2177 2178 2179 2180
		priv->txq_offset[0] = le32_to_cpu(cmd->wcbbase0) & 0xffff;
		priv->txq_offset[1] = le32_to_cpu(cmd->wcbbase1) & 0xffff;
		priv->txq_offset[2] = le32_to_cpu(cmd->wcbbase2) & 0xffff;
		priv->txq_offset[3] = le32_to_cpu(cmd->wcbbase3) & 0xffff;
2181 2182

		for (i = 0; i < priv->num_ampdu_queues; i++)
2183
			priv->txq_offset[i + MWL8K_TX_WMM_QUEUES] =
2184
				le32_to_cpu(cmd->wcbbase_ampdu[i]) & 0xffff;
2185 2186
	}

2187
done:
2188 2189 2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206
	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;
2207
	__le32 tx_queue_ptrs[MWL8K_MAX_TX_QUEUES];
2208 2209 2210
	__le32 flags;
	__le32 num_tx_desc_per_queue;
	__le32 total_rxd;
2211
} __packed;
2212

2213 2214 2215 2216 2217 2218 2219 2220
/* If enabled, MWL8K_SET_HW_SPEC_FLAG_ENABLE_LIFE_TIME_EXPIRY will cause
 * packets to expire 500 ms after the timestamp in the tx descriptor.  That is,
 * the packets that are queued for more than 500ms, will be dropped in the
 * hardware. This helps minimizing the issues caused due to head-of-line
 * blocking where a slow client can hog the bandwidth and affect traffic to a
 * faster client.
 */
#define MWL8K_SET_HW_SPEC_FLAG_ENABLE_LIFE_TIME_EXPIRY	0x00000400
2221 2222 2223
#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
2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240

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);
2241
	cmd->num_tx_queues = cpu_to_le32(mwl8k_tx_queues(priv));
2242 2243 2244 2245 2246 2247 2248

	/*
	 * Mac80211 stack has Q0 as highest priority and Q3 as lowest in
	 * that order. Firmware has Q3 as highest priority and Q0 as lowest
	 * in that order. Map Q3 of mac80211 to Q0 of firmware so that the
	 * priority is interpreted the right way in firmware.
	 */
2249 2250
	for (i = 0; i < mwl8k_tx_queues(priv); i++) {
		int j = mwl8k_tx_queues(priv) - 1 - i;
2251 2252 2253
		cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[j].txd_dma);
	}

2254 2255 2256
	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);
2257 2258 2259 2260 2261 2262 2263 2264 2265
	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;
}

2266 2267 2268 2269 2270 2271 2272
/*
 * CMD_MAC_MULTICAST_ADR.
 */
struct mwl8k_cmd_mac_multicast_adr {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 numaddr;
2273
	__u8 addr[0][ETH_ALEN];
2274 2275
};

2276 2277 2278 2279
#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
2280

2281
static struct mwl8k_cmd_pkt *
L
Lennert Buytenhek 已提交
2282
__mwl8k_cmd_mac_multicast_adr(struct ieee80211_hw *hw, int allmulti,
2283
			      struct netdev_hw_addr_list *mc_list)
2284
{
2285
	struct mwl8k_priv *priv = hw->priv;
2286
	struct mwl8k_cmd_mac_multicast_adr *cmd;
2287
	int size;
2288 2289 2290 2291
	int mc_count = 0;

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

L
Lennert Buytenhek 已提交
2293
	if (allmulti || mc_count > priv->num_mcaddrs) {
2294 2295 2296
		allmulti = 1;
		mc_count = 0;
	}
2297 2298

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

2300
	cmd = kzalloc(size, GFP_ATOMIC);
2301
	if (cmd == NULL)
2302
		return NULL;
2303 2304 2305

	cmd->header.code = cpu_to_le16(MWL8K_CMD_MAC_MULTICAST_ADR);
	cmd->header.length = cpu_to_le16(size);
2306 2307 2308 2309 2310 2311
	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) {
2312 2313
		struct netdev_hw_addr *ha;
		int i = 0;
2314 2315 2316

		cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_MULTICAST);
		cmd->numaddr = cpu_to_le16(mc_count);
2317 2318
		netdev_hw_addr_list_for_each(ha, mc_list) {
			memcpy(cmd->addr[i], ha->addr, ETH_ALEN);
2319 2320 2321
		}
	}

2322
	return &cmd->header;
2323 2324 2325
}

/*
2326
 * CMD_GET_STAT.
2327
 */
2328
struct mwl8k_cmd_get_stat {
2329 2330
	struct mwl8k_cmd_pkt header;
	__le32 stats[64];
2331
} __packed;
2332 2333 2334 2335 2336 2337

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

2338 2339
static int mwl8k_cmd_get_stat(struct ieee80211_hw *hw,
			      struct ieee80211_low_level_stats *stats)
2340
{
2341
	struct mwl8k_cmd_get_stat *cmd;
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
	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;
}

/*
2368
 * CMD_RADIO_CONTROL.
2369
 */
2370
struct mwl8k_cmd_radio_control {
2371 2372 2373 2374
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 control;
	__le16 radio_on;
2375
} __packed;
2376

2377
static int
2378
mwl8k_cmd_radio_control(struct ieee80211_hw *hw, bool enable, bool force)
2379 2380
{
	struct mwl8k_priv *priv = hw->priv;
2381
	struct mwl8k_cmd_radio_control *cmd;
2382 2383
	int rc;

2384
	if (enable == priv->radio_on && !force)
2385 2386 2387 2388 2389 2390 2391 2392 2393
		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);
2394
	cmd->control = cpu_to_le16(priv->radio_short_preamble ? 3 : 1);
2395 2396 2397 2398 2399 2400
	cmd->radio_on = cpu_to_le16(enable ? 0x0001 : 0x0000);

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

	if (!rc)
2401
		priv->radio_on = enable;
2402 2403 2404 2405

	return rc;
}

2406
static int mwl8k_cmd_radio_disable(struct ieee80211_hw *hw)
2407
{
2408
	return mwl8k_cmd_radio_control(hw, 0, 0);
2409 2410
}

2411
static int mwl8k_cmd_radio_enable(struct ieee80211_hw *hw)
2412
{
2413
	return mwl8k_cmd_radio_control(hw, 1, 0);
2414 2415
}

2416 2417 2418
static int
mwl8k_set_radio_preamble(struct ieee80211_hw *hw, bool short_preamble)
{
2419
	struct mwl8k_priv *priv = hw->priv;
2420

2421
	priv->radio_short_preamble = short_preamble;
2422

2423
	return mwl8k_cmd_radio_control(hw, 1, 1);
2424 2425 2426
}

/*
2427
 * CMD_RF_TX_POWER.
2428
 */
2429
#define MWL8K_RF_TX_POWER_LEVEL_TOTAL	8
2430

2431
struct mwl8k_cmd_rf_tx_power {
2432 2433 2434 2435 2436
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 support_level;
	__le16 current_level;
	__le16 reserved;
2437
	__le16 power_level_list[MWL8K_RF_TX_POWER_LEVEL_TOTAL];
2438
} __packed;
2439

2440
static int mwl8k_cmd_rf_tx_power(struct ieee80211_hw *hw, int dBm)
2441
{
2442
	struct mwl8k_cmd_rf_tx_power *cmd;
2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459
	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;
}

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 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517 2518
/*
 * 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;
}

2519 2520 2521 2522 2523 2524 2525
/*
 * CMD_RF_ANTENNA.
 */
struct mwl8k_cmd_rf_antenna {
	struct mwl8k_cmd_pkt header;
	__le16 antenna;
	__le16 mode;
2526
} __packed;
2527 2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546 2547 2548 2549 2550 2551

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

2552 2553 2554 2555 2556 2557 2558 2559 2560
/*
 * CMD_SET_BEACON.
 */
struct mwl8k_cmd_set_beacon {
	struct mwl8k_cmd_pkt header;
	__le16 beacon_len;
	__u8 beacon[0];
};

2561 2562
static int mwl8k_cmd_set_beacon(struct ieee80211_hw *hw,
				struct ieee80211_vif *vif, u8 *beacon, int len)
2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575
{
	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);

2576
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2577 2578 2579 2580 2581
	kfree(cmd);

	return rc;
}

2582 2583 2584 2585 2586
/*
 * CMD_SET_PRE_SCAN.
 */
struct mwl8k_cmd_set_pre_scan {
	struct mwl8k_cmd_pkt header;
2587
} __packed;
2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612

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;
2613
	__u8 bssid[ETH_ALEN];
2614
} __packed;
2615 2616

static int
2617
mwl8k_cmd_set_post_scan(struct ieee80211_hw *hw, const __u8 *mac)
2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628
{
	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;
2629
	memcpy(cmd->bssid, mac, ETH_ALEN);
2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644

	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;
2645
} __packed;
2646 2647

static int mwl8k_cmd_set_rf_channel(struct ieee80211_hw *hw,
2648
				    struct ieee80211_conf *conf)
2649
{
2650
	struct ieee80211_channel *channel = conf->channel;
2651 2652 2653 2654 2655 2656 2657 2658 2659 2660 2661
	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;
2662

2663
	if (channel->band == IEEE80211_BAND_2GHZ)
2664
		cmd->channel_flags |= cpu_to_le32(0x00000001);
2665 2666
	else if (channel->band == IEEE80211_BAND_5GHZ)
		cmd->channel_flags |= cpu_to_le32(0x00000004);
2667 2668 2669 2670 2671 2672 2673 2674

	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);
2675 2676 2677 2678 2679 2680 2681 2682

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

	return rc;
}

/*
2683
 * CMD_SET_AID.
2684
 */
2685 2686 2687 2688
#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
2689

2690 2691 2692
struct mwl8k_cmd_update_set_aid {
	struct	mwl8k_cmd_pkt header;
	__le16	aid;
2693

2694 2695 2696 2697
	 /* AP's MAC address (BSSID) */
	__u8	bssid[ETH_ALEN];
	__le16	protection_mode;
	__u8	supp_rates[14];
2698
} __packed;
2699

L
Lennert Buytenhek 已提交
2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711
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))
2712
			rates[j++] = mwl8k_rates_24[i].hw_value;
L
Lennert Buytenhek 已提交
2713 2714 2715
	}
}

2716
static int
L
Lennert Buytenhek 已提交
2717 2718
mwl8k_cmd_set_aid(struct ieee80211_hw *hw,
		  struct ieee80211_vif *vif, u32 legacy_rate_mask)
2719
{
2720 2721
	struct mwl8k_cmd_update_set_aid *cmd;
	u16 prot_mode;
2722 2723 2724 2725 2726 2727
	int rc;

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

2728
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_AID);
2729
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2730
	cmd->aid = cpu_to_le16(vif->bss_conf.aid);
2731
	memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN);
2732

2733
	if (vif->bss_conf.use_cts_prot) {
2734 2735
		prot_mode = MWL8K_FRAME_PROT_11G;
	} else {
2736
		switch (vif->bss_conf.ht_operation_mode &
2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749
			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);
2750

L
Lennert Buytenhek 已提交
2751
	legacy_rate_mask_to_array(cmd->supp_rates, legacy_rate_mask);
2752 2753 2754 2755 2756 2757 2758

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

	return rc;
}

2759
/*
2760
 * CMD_SET_RATE.
2761
 */
2762 2763 2764 2765 2766 2767 2768
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];
2769
} __packed;
2770

2771
static int
L
Lennert Buytenhek 已提交
2772
mwl8k_cmd_set_rate(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2773
		   u32 legacy_rate_mask, u8 *mcs_rates)
2774
{
2775
	struct mwl8k_cmd_set_rate *cmd;
2776 2777 2778 2779 2780 2781
	int rc;

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

2782
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATE);
2783
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
2784
	legacy_rate_mask_to_array(cmd->legacy_rates, legacy_rate_mask);
2785
	memcpy(cmd->mcs_set, mcs_rates, 16);
2786 2787 2788 2789 2790 2791 2792

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

	return rc;
}

2793
/*
2794
 * CMD_FINALIZE_JOIN.
2795
 */
2796 2797 2798
#define MWL8K_FJ_BEACON_MAXLEN	128

struct mwl8k_cmd_finalize_join {
2799
	struct mwl8k_cmd_pkt header;
2800 2801
	__le32 sleep_interval;	/* Number of beacon periods to sleep */
	__u8 beacon_data[MWL8K_FJ_BEACON_MAXLEN];
2802
} __packed;
2803

2804 2805
static int mwl8k_cmd_finalize_join(struct ieee80211_hw *hw, void *frame,
				   int framelen, int dtim)
2806
{
2807 2808 2809
	struct mwl8k_cmd_finalize_join *cmd;
	struct ieee80211_mgmt *payload = frame;
	int payload_len;
2810 2811 2812 2813 2814 2815
	int rc;

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

2816
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_FINALIZE_JOIN);
2817
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2818 2819 2820 2821 2822 2823 2824 2825 2826
	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);
2827 2828 2829 2830 2831 2832 2833 2834

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

	return rc;
}

/*
2835
 * CMD_SET_RTS_THRESHOLD.
2836
 */
2837
struct mwl8k_cmd_set_rts_threshold {
2838 2839
	struct mwl8k_cmd_pkt header;
	__le16 action;
2840
	__le16 threshold;
2841
} __packed;
2842

L
Lennert Buytenhek 已提交
2843 2844
static int
mwl8k_cmd_set_rts_threshold(struct ieee80211_hw *hw, int rts_thresh)
2845
{
2846
	struct mwl8k_cmd_set_rts_threshold *cmd;
2847 2848 2849 2850 2851 2852
	int rc;

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

2853
	cmd->header.code = cpu_to_le16(MWL8K_CMD_RTS_THRESHOLD);
2854
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
2855 2856
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->threshold = cpu_to_le16(rts_thresh);
2857 2858 2859 2860 2861 2862 2863 2864

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

	return rc;
}

/*
2865
 * CMD_SET_SLOT.
2866
 */
2867
struct mwl8k_cmd_set_slot {
2868 2869
	struct mwl8k_cmd_pkt header;
	__le16 action;
2870
	__u8 short_slot;
2871
} __packed;
2872

2873
static int mwl8k_cmd_set_slot(struct ieee80211_hw *hw, bool short_slot_time)
2874
{
2875
	struct mwl8k_cmd_set_slot *cmd;
2876 2877 2878 2879 2880 2881
	int rc;

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

2882
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_SLOT);
2883
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2884 2885
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->short_slot = short_slot_time;
2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904

	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;

2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920 2921
	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;
2922

2923 2924
			/* Log exponent of min contention period: 0...15 */
			__u8 log_cw_min;
2925

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

2929 2930 2931 2932
			/* TX queue to configure */
			__u8 txq;
		} sta;
	};
2933
} __packed;
2934 2935 2936 2937 2938 2939 2940 2941 2942 2943

#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
2944 2945 2946
mwl8k_cmd_set_edca_params(struct ieee80211_hw *hw, __u8 qnum,
			  __u16 cw_min, __u16 cw_max,
			  __u8 aifs, __u16 txop)
2947
{
2948
	struct mwl8k_priv *priv = hw->priv;
2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959
	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);
2960 2961 2962 2963 2964 2965 2966 2967 2968 2969 2970
	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;
	}
2971 2972 2973 2974 2975 2976 2977 2978

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

	return rc;
}

/*
2979
 * CMD_SET_WMM_MODE.
2980
 */
2981
struct mwl8k_cmd_set_wmm_mode {
2982
	struct mwl8k_cmd_pkt header;
2983
	__le16 action;
2984
} __packed;
2985

2986
static int mwl8k_cmd_set_wmm_mode(struct ieee80211_hw *hw, bool enable)
2987
{
2988 2989
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_cmd_set_wmm_mode *cmd;
2990 2991 2992 2993 2994 2995
	int rc;

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

2996
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_WMM_MODE);
2997
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2998
	cmd->action = cpu_to_le16(!!enable);
2999 3000 3001

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

3003 3004
	if (!rc)
		priv->wmm_enabled = enable;
3005 3006 3007 3008 3009

	return rc;
}

/*
3010
 * CMD_MIMO_CONFIG.
3011
 */
3012 3013 3014 3015 3016
struct mwl8k_cmd_mimo_config {
	struct mwl8k_cmd_pkt header;
	__le32 action;
	__u8 rx_antenna_map;
	__u8 tx_antenna_map;
3017
} __packed;
3018

3019
static int mwl8k_cmd_mimo_config(struct ieee80211_hw *hw, __u8 rx, __u8 tx)
3020
{
3021
	struct mwl8k_cmd_mimo_config *cmd;
3022 3023 3024 3025 3026 3027
	int rc;

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

3028
	cmd->header.code = cpu_to_le16(MWL8K_CMD_MIMO_CONFIG);
3029
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
3030 3031 3032
	cmd->action = cpu_to_le32((u32)MWL8K_CMD_SET);
	cmd->rx_antenna_map = rx;
	cmd->tx_antenna_map = tx;
3033 3034 3035 3036 3037 3038 3039 3040

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

	return rc;
}

/*
3041
 * CMD_USE_FIXED_RATE (STA version).
3042
 */
3043 3044 3045 3046 3047 3048 3049 3050 3051 3052 3053 3054 3055 3056
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;
3057
} __packed;
3058

3059 3060
#define MWL8K_USE_AUTO_RATE	0x0002
#define MWL8K_UCAST_RATE	0
3061

3062
static int mwl8k_cmd_use_fixed_rate_sta(struct ieee80211_hw *hw)
3063
{
3064
	struct mwl8k_cmd_use_fixed_rate_sta *cmd;
3065 3066 3067 3068 3069 3070 3071 3072
	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));
3073 3074
	cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE);
	cmd->rate_type = cpu_to_le32(MWL8K_UCAST_RATE);
3075 3076 3077 3078 3079 3080 3081

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

	return rc;
}

3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098
/*
 * 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;
3099
} __packed;
3100 3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122

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

3123 3124 3125 3126 3127 3128
/*
 * CMD_ENABLE_SNIFFER.
 */
struct mwl8k_cmd_enable_sniffer {
	struct mwl8k_cmd_pkt header;
	__le32 action;
3129
} __packed;
3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160 3161

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];
	};
3162
} __packed;
3163

3164 3165 3166 3167
#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
3168

3169 3170
static int mwl8k_cmd_set_mac_addr(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif, u8 *mac)
3171 3172
{
	struct mwl8k_priv *priv = hw->priv;
3173
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
3174
	struct mwl8k_cmd_set_mac_addr *cmd;
3175
	int mac_type;
3176 3177
	int rc;

3178 3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189 3190
	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;
	}

3191 3192 3193 3194 3195 3196 3197
	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) {
3198
		cmd->mbss.mac_type = cpu_to_le16(mac_type);
3199 3200 3201 3202 3203
		memcpy(cmd->mbss.mac_addr, mac, ETH_ALEN);
	} else {
		memcpy(cmd->mac_addr, mac, ETH_ALEN);
	}

3204
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216
	kfree(cmd);

	return rc;
}

/*
 * CMD_SET_RATEADAPT_MODE.
 */
struct mwl8k_cmd_set_rate_adapt_mode {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 mode;
3217
} __packed;
3218 3219 3220 3221 3222 3223 3224 3225 3226 3227 3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238

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

3239 3240 3241 3242 3243 3244
/*
 * CMD_BSS_START.
 */
struct mwl8k_cmd_bss_start {
	struct mwl8k_cmd_pkt header;
	__le32 enable;
3245
} __packed;
3246

3247 3248
static int mwl8k_cmd_bss_start(struct ieee80211_hw *hw,
			       struct ieee80211_vif *vif, int enable)
3249 3250 3251 3252 3253 3254 3255 3256 3257 3258 3259 3260
{
	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);

3261
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3262 3263 3264 3265 3266
	kfree(cmd);

	return rc;
}

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
/*
 * CMD_BASTREAM.
 */

/*
 * UPSTREAM is tx direction
 */
#define BASTREAM_FLAG_DIRECTION_UPSTREAM	0x00
#define BASTREAM_FLAG_IMMEDIATE_TYPE		0x01

enum {
	MWL8K_BA_CREATE,
	MWL8K_BA_UPDATE,
	MWL8K_BA_DESTROY,
	MWL8K_BA_FLUSH,
	MWL8K_BA_CHECK,
} ba_stream_action_type;


struct mwl8k_create_ba_stream {
	__le32	flags;
	__le32	idle_thrs;
	__le32	bar_thrs;
	__le32	window_size;
	u8	peer_mac_addr[6];
	u8	dialog_token;
	u8	tid;
	u8	queue_id;
	u8	param_info;
	__le32	ba_context;
	u8	reset_seq_no_flag;
	__le16	curr_seq_no;
	u8	sta_src_mac_addr[6];
} __packed;

struct mwl8k_destroy_ba_stream {
	__le32	flags;
	__le32	ba_context;
} __packed;

struct mwl8k_cmd_bastream {
	struct mwl8k_cmd_pkt	header;
	__le32	action;
	union {
		struct mwl8k_create_ba_stream	create_params;
		struct mwl8k_destroy_ba_stream	destroy_params;
	};
} __packed;

static int
mwl8k_check_ba(struct ieee80211_hw *hw, struct mwl8k_ampdu_stream *stream)
{
	struct mwl8k_cmd_bastream *cmd;
	int rc;

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

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

	cmd->action = cpu_to_le32(MWL8K_BA_CHECK);

	cmd->create_params.queue_id = stream->idx;
	memcpy(&cmd->create_params.peer_mac_addr[0], stream->sta->addr,
	       ETH_ALEN);
	cmd->create_params.tid = stream->tid;

	cmd->create_params.flags =
		cpu_to_le32(BASTREAM_FLAG_IMMEDIATE_TYPE) |
		cpu_to_le32(BASTREAM_FLAG_DIRECTION_UPSTREAM);

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

	kfree(cmd);

	return rc;
}

static int
mwl8k_create_ba(struct ieee80211_hw *hw, struct mwl8k_ampdu_stream *stream,
		u8 buf_size)
{
	struct mwl8k_cmd_bastream *cmd;
	int rc;

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


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

	cmd->action = cpu_to_le32(MWL8K_BA_CREATE);

	cmd->create_params.bar_thrs = cpu_to_le32((u32)buf_size);
	cmd->create_params.window_size = cpu_to_le32((u32)buf_size);
	cmd->create_params.queue_id = stream->idx;

	memcpy(cmd->create_params.peer_mac_addr, stream->sta->addr, ETH_ALEN);
	cmd->create_params.tid = stream->tid;
	cmd->create_params.curr_seq_no = cpu_to_le16(0);
	cmd->create_params.reset_seq_no_flag = 1;

	cmd->create_params.param_info =
		(stream->sta->ht_cap.ampdu_factor &
		 IEEE80211_HT_AMPDU_PARM_FACTOR) |
		((stream->sta->ht_cap.ampdu_density << 2) &
		 IEEE80211_HT_AMPDU_PARM_DENSITY);

	cmd->create_params.flags =
		cpu_to_le32(BASTREAM_FLAG_IMMEDIATE_TYPE |
					BASTREAM_FLAG_DIRECTION_UPSTREAM);

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

	wiphy_debug(hw->wiphy, "Created a BA stream for %pM : tid %d\n",
		stream->sta->addr, stream->tid);
	kfree(cmd);

	return rc;
}

static void mwl8k_destroy_ba(struct ieee80211_hw *hw,
			     struct mwl8k_ampdu_stream *stream)
{
	struct mwl8k_cmd_bastream *cmd;

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

	cmd->header.code = cpu_to_le16(MWL8K_CMD_BASTREAM);
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
	cmd->action = cpu_to_le32(MWL8K_BA_DESTROY);

	cmd->destroy_params.ba_context = cpu_to_le32(stream->idx);
	mwl8k_post_cmd(hw, &cmd->header);

	wiphy_debug(hw->wiphy, "Deleted BA stream index %d\n", stream->idx);

	kfree(cmd);
}

3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431 3432 3433 3434 3435
/*
 * 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;
3436
} __packed;
3437 3438 3439 3440 3441 3442 3443 3444 3445

#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;
3446
	u32 rates;
3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458
	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);
3459 3460 3461 3462 3463
	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);
3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474
	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;
	}

3475
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3476 3477 3478 3479 3480
	kfree(cmd);

	return rc;
}

3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494
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);

3495
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3496 3497 3498 3499 3500
	kfree(cmd);

	return rc;
}

3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515
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);

3516
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3517 3518 3519 3520 3521
	kfree(cmd);

	return rc;
}

3522 3523 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 3552 3553 3554 3555 3556 3557 3558 3559 3560 3561 3562 3563 3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577 3578 3579 3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 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 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789
/*
 * 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;
}

3790 3791 3792
/*
 * CMD_UPDATE_STADB.
 */
3793 3794 3795 3796
struct ewc_ht_info {
	__le16	control1;
	__le16	control2;
	__le16	control3;
3797
} __packed;
3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809 3810 3811 3812 3813 3814 3815 3816 3817 3818 3819 3820 3821 3822 3823 3824 3825

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;
3826
} __packed;
3827

3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838 3839 3840
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;
3841
} __packed;
3842

3843 3844 3845 3846 3847 3848 3849
#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 已提交
3850
				      struct ieee80211_vif *vif,
3851
				      struct ieee80211_sta *sta)
3852 3853
{
	struct mwl8k_cmd_update_stadb *cmd;
3854
	struct peer_capability_info *p;
3855
	u32 rates;
3856 3857 3858 3859 3860 3861 3862 3863
	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));
3864
	cmd->action = cpu_to_le32(MWL8K_STA_DB_MODIFY_ENTRY);
3865
	memcpy(cmd->peer_addr, sta->addr, ETH_ALEN);
3866

3867 3868 3869
	p = &cmd->peer_info;
	p->peer_type = MWL8K_PEER_TYPE_ACCESSPOINT;
	p->basic_caps = cpu_to_le16(vif->bss_conf.assoc_capability);
3870
	p->ht_support = sta->ht_cap.ht_supported;
3871
	p->ht_caps = cpu_to_le16(sta->ht_cap.cap);
3872 3873
	p->extended_ht_caps = (sta->ht_cap.ampdu_factor & 3) |
		((sta->ht_cap.ampdu_density & 7) << 2);
3874 3875 3876 3877 3878
	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);
3879
	memcpy(p->ht_rates, sta->ht_cap.mcs.rx_mask, 16);
3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901
	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);
3902
	memcpy(cmd->peer_addr, addr, ETH_ALEN);
3903

3904
	rc = mwl8k_post_cmd(hw, &cmd->header);
3905 3906 3907 3908 3909
	kfree(cmd);

	return rc;
}

3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923

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

3924 3925 3926 3927 3928
	if (status & MWL8K_A2H_INT_TX_DONE) {
		status &= ~MWL8K_A2H_INT_TX_DONE;
		tasklet_schedule(&priv->poll_tx_task);
	}

3929
	if (status & MWL8K_A2H_INT_RX_READY) {
3930 3931
		status &= ~MWL8K_A2H_INT_RX_READY;
		tasklet_schedule(&priv->poll_rx_task);
3932 3933
	}

3934 3935 3936
	if (status)
		iowrite32(~status, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);

3937
	if (status & MWL8K_A2H_INT_OPC_DONE) {
3938
		if (priv->hostcmd_wait != NULL)
3939 3940 3941 3942
			complete(priv->hostcmd_wait);
	}

	if (status & MWL8K_A2H_INT_QUEUE_EMPTY) {
3943
		if (!mutex_is_locked(&priv->fw_mutex) &&
3944
		    priv->radio_on && priv->pending_tx_pkts)
3945
			mwl8k_tx_start(priv);
3946 3947 3948 3949 3950
	}

	return IRQ_HANDLED;
}

3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961
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);

3962
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979
		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);
	}
}

3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997
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);
	}
}

3998 3999 4000 4001

/*
 * Core driver operations.
 */
4002
static void mwl8k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
4003 4004 4005 4006
{
	struct mwl8k_priv *priv = hw->priv;
	int index = skb_get_queue_mapping(skb);

4007
	if (!priv->radio_on) {
4008 4009
		wiphy_debug(hw->wiphy,
			    "dropped TX frame since radio disabled\n");
4010
		dev_kfree_skb(skb);
4011
		return;
4012 4013
	}

4014
	mwl8k_txq_xmit(hw, index, skb);
4015 4016 4017 4018 4019 4020 4021
}

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

4022
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
4023 4024
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
4025
		wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
4026
		return -EIO;
4027 4028
	}

4029
	/* Enable TX reclaim and RX tasklets.  */
4030
	tasklet_enable(&priv->poll_tx_task);
4031
	tasklet_enable(&priv->poll_rx_task);
4032

4033
	/* Enable interrupts */
4034
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4035

4036 4037
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
4038
		rc = mwl8k_cmd_radio_enable(hw);
4039

4040 4041
		if (!priv->ap_fw) {
			if (!rc)
4042
				rc = mwl8k_cmd_enable_sniffer(hw, 0);
4043

4044 4045 4046 4047 4048 4049 4050
			if (!rc)
				rc = mwl8k_cmd_set_pre_scan(hw);

			if (!rc)
				rc = mwl8k_cmd_set_post_scan(hw,
						"\x00\x00\x00\x00\x00\x00");
		}
4051 4052

		if (!rc)
4053
			rc = mwl8k_cmd_set_rateadapt_mode(hw, 0);
4054

4055
		if (!rc)
4056
			rc = mwl8k_cmd_set_wmm_mode(hw, 0);
4057

4058 4059 4060 4061 4062 4063
		mwl8k_fw_unlock(hw);
	}

	if (rc) {
		iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
		free_irq(priv->pdev->irq, hw);
4064
		tasklet_disable(&priv->poll_tx_task);
4065
		tasklet_disable(&priv->poll_rx_task);
4066
	}
4067 4068 4069 4070 4071 4072 4073 4074 4075

	return rc;
}

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

4076
	mwl8k_cmd_radio_disable(hw);
4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088

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

4089
	/* Stop TX reclaim and RX tasklets.  */
4090
	tasklet_disable(&priv->poll_tx_task);
4091
	tasklet_disable(&priv->poll_rx_task);
4092 4093

	/* Return all skbs to mac80211 */
4094
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
4095
		mwl8k_txq_reclaim(hw, i, INT_MAX, 1);
4096 4097
}

4098 4099
static int mwl8k_reload_firmware(struct ieee80211_hw *hw, char *fw_image);

4100
static int mwl8k_add_interface(struct ieee80211_hw *hw,
4101
			       struct ieee80211_vif *vif)
4102 4103 4104
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_vif *mwl8k_vif;
4105
	u32 macids_supported;
4106 4107
	int macid, rc;
	struct mwl8k_device_info *di;
4108

4109 4110 4111
	/*
	 * Reject interface creation if sniffer mode is active, as
	 * STA operation is mutually exclusive with hardware sniffer
4112
	 * mode.  (Sniffer mode is only used on STA firmware.)
4113 4114
	 */
	if (priv->sniffer_enabled) {
4115 4116
		wiphy_info(hw->wiphy,
			   "unable to create STA interface because sniffer mode is enabled\n");
4117 4118 4119
		return -EINVAL;
	}

4120
	di = priv->device_info;
4121 4122
	switch (vif->type) {
	case NL80211_IFTYPE_AP:
4123 4124 4125 4126 4127 4128 4129 4130
		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;
		}
4131 4132 4133
		macids_supported = priv->ap_macids_supported;
		break;
	case NL80211_IFTYPE_STATION:
4134 4135 4136 4137 4138 4139 4140 4141
		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;
		}
4142 4143 4144 4145 4146 4147 4148 4149 4150 4151
		macids_supported = priv->sta_macids_supported;
		break;
	default:
		return -EINVAL;
	}

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

4152
	/* Setup driver private area. */
4153
	mwl8k_vif = MWL8K_VIF(vif);
4154
	memset(mwl8k_vif, 0, sizeof(*mwl8k_vif));
4155
	mwl8k_vif->vif = vif;
4156
	mwl8k_vif->macid = macid;
4157
	mwl8k_vif->seqno = 0;
4158 4159
	memcpy(mwl8k_vif->bssid, vif->addr, ETH_ALEN);
	mwl8k_vif->is_hw_crypto_enabled = false;
4160

4161 4162 4163 4164 4165 4166
	/* 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);

4167
	priv->macids_used |= 1 << mwl8k_vif->macid;
4168
	list_add_tail(&mwl8k_vif->list, &priv->vif_list);
4169 4170 4171 4172 4173

	return 0;
}

static void mwl8k_remove_interface(struct ieee80211_hw *hw,
4174
				   struct ieee80211_vif *vif)
4175 4176
{
	struct mwl8k_priv *priv = hw->priv;
4177
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
4178

4179 4180 4181
	if (priv->ap_fw)
		mwl8k_cmd_set_new_stn_del(hw, vif, vif->addr);

4182
	mwl8k_cmd_set_mac_addr(hw, vif, "\x00\x00\x00\x00\x00\x00");
4183

4184
	priv->macids_used &= ~(1 << mwl8k_vif->macid);
4185
	list_del(&mwl8k_vif->list);
4186 4187
}

4188
static int mwl8k_config(struct ieee80211_hw *hw, u32 changed)
4189 4190 4191
{
	struct ieee80211_conf *conf = &hw->conf;
	struct mwl8k_priv *priv = hw->priv;
4192
	int rc;
4193

L
Lennert Buytenhek 已提交
4194
	if (conf->flags & IEEE80211_CONF_IDLE) {
4195
		mwl8k_cmd_radio_disable(hw);
4196
		return 0;
L
Lennert Buytenhek 已提交
4197 4198
	}

4199 4200 4201
	rc = mwl8k_fw_lock(hw);
	if (rc)
		return rc;
4202

4203
	rc = mwl8k_cmd_radio_enable(hw);
4204 4205
	if (rc)
		goto out;
4206

4207
	rc = mwl8k_cmd_set_rf_channel(hw, conf);
4208 4209 4210
	if (rc)
		goto out;

4211 4212 4213
	if (conf->power_level > 18)
		conf->power_level = 18;

4214
	if (priv->ap_fw) {
4215 4216 4217 4218
		rc = mwl8k_cmd_tx_power(hw, conf, conf->power_level);
		if (rc)
			goto out;

4219 4220 4221 4222 4223 4224 4225
		rc = mwl8k_cmd_rf_antenna(hw, MWL8K_RF_ANTENNA_RX, 0x3);
		if (rc)
			wiphy_warn(hw->wiphy, "failed to set # of RX antennas");
		rc = mwl8k_cmd_rf_antenna(hw, MWL8K_RF_ANTENNA_TX, 0x7);
		if (rc)
			wiphy_warn(hw->wiphy, "failed to set # of TX antennas");

4226
	} else {
4227 4228 4229
		rc = mwl8k_cmd_rf_tx_power(hw, conf->power_level);
		if (rc)
			goto out;
4230 4231
		rc = mwl8k_cmd_mimo_config(hw, 0x7, 0x7);
	}
4232

4233 4234
out:
	mwl8k_fw_unlock(hw);
4235

4236
	return rc;
4237 4238
}

4239 4240 4241
static void
mwl8k_bss_info_changed_sta(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			   struct ieee80211_bss_conf *info, u32 changed)
4242 4243
{
	struct mwl8k_priv *priv = hw->priv;
4244
	u32 ap_legacy_rates;
4245
	u8 ap_mcs_rates[16];
4246 4247
	int rc;

4248
	if (mwl8k_fw_lock(hw))
4249
		return;
4250

4251 4252 4253 4254 4255
	/*
	 * 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;
4256

4257
	/*
4258
	 * Get the AP's legacy and MCS rates.
4259
	 */
4260
	if (vif->bss_conf.assoc) {
L
Lennert Buytenhek 已提交
4261
		struct ieee80211_sta *ap;
4262

L
Lennert Buytenhek 已提交
4263 4264
		rcu_read_lock();

4265 4266 4267
		ap = ieee80211_find_sta(vif, vif->bss_conf.bssid);
		if (ap == NULL) {
			rcu_read_unlock();
L
Lennert Buytenhek 已提交
4268
			goto out;
4269 4270
		}

4271 4272 4273 4274 4275 4276
		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;
		}
4277
		memcpy(ap_mcs_rates, ap->ht_cap.mcs.rx_mask, 16);
4278 4279 4280

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

4282
	if ((changed & BSS_CHANGED_ASSOC) && vif->bss_conf.assoc) {
4283
		rc = mwl8k_cmd_set_rate(hw, vif, ap_legacy_rates, ap_mcs_rates);
4284 4285
		if (rc)
			goto out;
4286

4287
		rc = mwl8k_cmd_use_fixed_rate_sta(hw);
4288 4289
		if (rc)
			goto out;
4290
	}
4291

4292
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4293 4294
		rc = mwl8k_set_radio_preamble(hw,
				vif->bss_conf.use_short_preamble);
4295 4296
		if (rc)
			goto out;
4297
	}
4298

4299
	if (changed & BSS_CHANGED_ERP_SLOT) {
4300
		rc = mwl8k_cmd_set_slot(hw, vif->bss_conf.use_short_slot);
4301 4302
		if (rc)
			goto out;
4303
	}
4304

4305 4306 4307
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_ERP_CTS_PROT |
			BSS_CHANGED_HT))) {
4308
		rc = mwl8k_cmd_set_aid(hw, vif, ap_legacy_rates);
4309 4310
		if (rc)
			goto out;
4311
	}
4312

4313 4314
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_BEACON_INT))) {
4315 4316 4317 4318
		/*
		 * Finalize the join.  Tell rx handler to process
		 * next beacon from our BSSID.
		 */
4319
		memcpy(priv->capture_bssid, vif->bss_conf.bssid, ETH_ALEN);
4320 4321 4322
		priv->capture_beacon = true;
	}

4323 4324
out:
	mwl8k_fw_unlock(hw);
4325 4326
}

4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347 4348 4349 4350 4351 4352
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);
4353 4354 4355 4356 4357 4358 4359
		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;
4360 4361 4362 4363 4364 4365 4366 4367 4368

		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) {
4369
			mwl8k_cmd_set_beacon(hw, vif, skb->data, skb->len);
4370 4371 4372 4373 4374
			kfree_skb(skb);
		}
	}

	if (changed & BSS_CHANGED_BEACON_ENABLED)
4375
		mwl8k_cmd_bss_start(hw, vif, info->enable_beacon);
4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387 4388 4389 4390 4391 4392

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

4393
static u64 mwl8k_prepare_multicast(struct ieee80211_hw *hw,
4394
				   struct netdev_hw_addr_list *mc_list)
4395 4396 4397
{
	struct mwl8k_cmd_pkt *cmd;

L
Lennert Buytenhek 已提交
4398 4399 4400 4401 4402 4403 4404
	/*
	 * 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().
	 */
4405
	cmd = __mwl8k_cmd_mac_multicast_adr(hw, 0, mc_list);
4406 4407 4408 4409

	return (unsigned long)cmd;
}

4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420 4421
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.
	 */
4422
	if (!list_empty(&priv->vif_list)) {
4423
		if (net_ratelimit())
4424 4425
			wiphy_info(hw->wiphy,
				   "not enabling sniffer mode because STA interface is active\n");
4426 4427 4428 4429
		return 0;
	}

	if (!priv->sniffer_enabled) {
4430
		if (mwl8k_cmd_enable_sniffer(hw, 1))
4431 4432 4433 4434 4435 4436 4437 4438 4439 4440 4441
			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;
}

4442 4443 4444 4445 4446 4447 4448 4449
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;
}

4450 4451 4452 4453 4454 4455
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;
4456 4457
	struct mwl8k_cmd_pkt *cmd = (void *)(unsigned long)multicast;

4458 4459 4460 4461 4462 4463 4464 4465 4466 4467
	/*
	 * 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;
	}

4468 4469 4470 4471 4472 4473 4474 4475 4476
	/*
	 * 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;
	}
4477

4478
	/* Clear unsupported feature flags */
L
Lennert Buytenhek 已提交
4479
	*total_flags &= FIF_ALLMULTI | FIF_BCN_PRBRESP_PROMISC;
4480

4481 4482
	if (mwl8k_fw_lock(hw)) {
		kfree(cmd);
4483
		return;
4484
	}
4485

4486
	if (priv->sniffer_enabled) {
4487
		mwl8k_cmd_enable_sniffer(hw, 0);
4488 4489 4490
		priv->sniffer_enabled = false;
	}

4491
	if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
4492 4493 4494 4495
		if (*total_flags & FIF_BCN_PRBRESP_PROMISC) {
			/*
			 * Disable the BSS filter.
			 */
4496
			mwl8k_cmd_set_pre_scan(hw);
4497
		} else {
4498
			struct mwl8k_vif *mwl8k_vif;
4499
			const u8 *bssid;
4500

4501 4502 4503 4504 4505 4506 4507 4508
			/*
			 * 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).
			 */
4509 4510 4511 4512 4513
			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";
4514

4515
			mwl8k_cmd_set_post_scan(hw, bssid);
4516 4517 4518
		}
	}

L
Lennert Buytenhek 已提交
4519 4520 4521 4522 4523 4524 4525 4526
	/*
	 * 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);
4527
		cmd = __mwl8k_cmd_mac_multicast_adr(hw, 1, NULL);
L
Lennert Buytenhek 已提交
4528 4529 4530 4531 4532
	}

	if (cmd != NULL) {
		mwl8k_post_cmd(hw, cmd);
		kfree(cmd);
4533
	}
4534

4535
	mwl8k_fw_unlock(hw);
4536 4537 4538 4539
}

static int mwl8k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
{
L
Lennert Buytenhek 已提交
4540
	return mwl8k_cmd_set_rts_threshold(hw, value);
4541 4542
}

4543 4544 4545
static int mwl8k_sta_remove(struct ieee80211_hw *hw,
			    struct ieee80211_vif *vif,
			    struct ieee80211_sta *sta)
4546 4547 4548
{
	struct mwl8k_priv *priv = hw->priv;

4549 4550 4551 4552
	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);
4553 4554
}

4555 4556 4557
static int mwl8k_sta_add(struct ieee80211_hw *hw,
			 struct ieee80211_vif *vif,
			 struct ieee80211_sta *sta)
4558 4559
{
	struct mwl8k_priv *priv = hw->priv;
4560
	int ret;
4561 4562 4563
	int i;
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
	struct ieee80211_key_conf *key;
4564

4565 4566 4567 4568
	if (!priv->ap_fw) {
		ret = mwl8k_cmd_update_stadb_add(hw, vif, sta);
		if (ret >= 0) {
			MWL8K_STA(sta)->peer_id = ret;
4569
			ret = 0;
4570
		}
4571

4572 4573
	} else {
		ret = mwl8k_cmd_set_new_stn_add(hw, vif, sta);
4574
	}
4575

4576 4577 4578 4579 4580
	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);
	}
4581
	return ret;
4582 4583
}

4584 4585 4586
static int mwl8k_conf_tx(struct ieee80211_hw *hw, u16 queue,
			 const struct ieee80211_tx_queue_params *params)
{
4587
	struct mwl8k_priv *priv = hw->priv;
4588 4589
	int rc;

4590 4591
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
4592
		BUG_ON(queue > MWL8K_TX_WMM_QUEUES - 1);
4593 4594
		memcpy(&priv->wmm_params[queue], params, sizeof(*params));

4595
		if (!priv->wmm_enabled)
4596
			rc = mwl8k_cmd_set_wmm_mode(hw, 1);
4597

4598
		if (!rc) {
4599
			int q = MWL8K_TX_WMM_QUEUES - 1 - queue;
4600
			rc = mwl8k_cmd_set_edca_params(hw, q,
4601 4602 4603 4604
						       params->cw_min,
						       params->cw_max,
						       params->aifs,
						       params->txop);
4605
		}
4606 4607

		mwl8k_fw_unlock(hw);
4608
	}
4609

4610 4611 4612 4613 4614 4615
	return rc;
}

static int mwl8k_get_stats(struct ieee80211_hw *hw,
			   struct ieee80211_low_level_stats *stats)
{
4616
	return mwl8k_cmd_get_stat(hw, stats);
4617 4618
}

4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634
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;
}

4635 4636 4637
static int
mwl8k_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		   enum ieee80211_ampdu_mlme_action action,
4638 4639
		   struct ieee80211_sta *sta, u16 tid, u16 *ssn,
		   u8 buf_size)
4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651
{
	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;
	}
}

4652 4653 4654 4655 4656 4657 4658 4659
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,
4660
	.prepare_multicast	= mwl8k_prepare_multicast,
4661
	.configure_filter	= mwl8k_configure_filter,
4662
	.set_key                = mwl8k_set_key,
4663
	.set_rts_threshold	= mwl8k_set_rts_threshold,
4664 4665
	.sta_add		= mwl8k_sta_add,
	.sta_remove		= mwl8k_sta_remove,
4666 4667
	.conf_tx		= mwl8k_conf_tx,
	.get_stats		= mwl8k_get_stats,
4668
	.get_survey		= mwl8k_get_survey,
4669
	.ampdu_action		= mwl8k_ampdu_action,
4670 4671 4672 4673 4674 4675 4676
};

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;
4677 4678 4679 4680 4681 4682 4683 4684
	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];
4685

4686
	mwl8k_cmd_finalize_join(priv->hw, skb->data, skb->len, dtim_period);
4687

4688
	dev_kfree_skb(skb);
4689 4690 4691
	priv->beacon_skb = NULL;
}

4692
enum {
4693 4694
	MWL8363 = 0,
	MWL8687,
4695
	MWL8366,
4696 4697
};

4698
#define MWL8K_8366_AP_FW_API 2
4699 4700 4701
#define _MWL8K_8366_AP_FW(api) "mwl8k/fmimage_8366_ap-" #api ".fw"
#define MWL8K_8366_AP_FW(api) _MWL8K_8366_AP_FW(api)

4702
static struct mwl8k_device_info mwl8k_info_tbl[] __devinitdata = {
4703 4704 4705
	[MWL8363] = {
		.part_name	= "88w8363",
		.helper_image	= "mwl8k/helper_8363.fw",
4706
		.fw_image_sta	= "mwl8k/fmimage_8363.fw",
4707
	},
4708
	[MWL8687] = {
4709 4710
		.part_name	= "88w8687",
		.helper_image	= "mwl8k/helper_8687.fw",
4711
		.fw_image_sta	= "mwl8k/fmimage_8687.fw",
4712
	},
4713
	[MWL8366] = {
4714 4715
		.part_name	= "88w8366",
		.helper_image	= "mwl8k/helper_8366.fw",
4716
		.fw_image_sta	= "mwl8k/fmimage_8366.fw",
4717 4718
		.fw_image_ap	= MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API),
		.fw_api_ap	= MWL8K_8366_AP_FW_API,
4719
		.ap_rxd_ops	= &rxd_8366_ap_ops,
4720
	},
4721 4722
};

4723 4724 4725 4726 4727 4728
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");
4729
MODULE_FIRMWARE(MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API));
4730

4731
static DEFINE_PCI_DEVICE_TABLE(mwl8k_pci_id_table) = {
4732
	{ PCI_VDEVICE(MARVELL, 0x2a0a), .driver_data = MWL8363, },
4733 4734
	{ PCI_VDEVICE(MARVELL, 0x2a0c), .driver_data = MWL8363, },
	{ PCI_VDEVICE(MARVELL, 0x2a24), .driver_data = MWL8363, },
4735 4736 4737
	{ PCI_VDEVICE(MARVELL, 0x2a2b), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a30), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a40), .driver_data = MWL8366, },
4738
	{ PCI_VDEVICE(MARVELL, 0x2a43), .driver_data = MWL8366, },
4739
	{ },
4740 4741 4742
};
MODULE_DEVICE_TABLE(pci, mwl8k_pci_id_table);

4743 4744 4745 4746 4747 4748 4749 4750 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 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835
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)
4836
{
4837
	struct mwl8k_priv *priv = hw->priv;
4838
	int rc;
4839 4840 4841 4842 4843

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

	/* Ask userland hotplug daemon for the device firmware */
4844
	rc = mwl8k_request_firmware(priv, fw_image, nowait);
4845
	if (rc) {
4846
		wiphy_err(hw->wiphy, "Firmware files not found\n");
4847
		return rc;
4848 4849
	}

4850 4851 4852
	if (nowait)
		return rc;

4853 4854
	/* Load firmware into hardware */
	rc = mwl8k_load_firmware(hw);
4855
	if (rc)
4856
		wiphy_err(hw->wiphy, "Cannot start firmware\n");
4857 4858 4859 4860

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

4861 4862 4863
	return rc;
}

4864 4865 4866 4867 4868 4869
static int mwl8k_init_txqs(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;
	int rc = 0;
	int i;

4870
	for (i = 0; i < mwl8k_tx_queues(priv); i++) {
4871 4872 4873 4874 4875 4876 4877 4878 4879 4880
		rc = mwl8k_txq_init(hw, i);
		if (rc)
			break;
		if (priv->ap_fw)
			iowrite32(priv->txq[i].txd_dma,
				  priv->sram + priv->txq_offset[i]);
	}
	return rc;
}

4881 4882 4883 4884 4885 4886
/* 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;
4887

4888
	if (priv->ap_fw) {
4889
		priv->rxd_ops = priv->device_info->ap_rxd_ops;
4890
		if (priv->rxd_ops == NULL) {
4891 4892
			wiphy_err(hw->wiphy,
				  "Driver does not have AP firmware image support for this hardware\n");
4893 4894 4895
			goto err_stop_firmware;
		}
	} else {
4896
		priv->rxd_ops = &rxd_sta_ops;
4897
	}
4898 4899 4900 4901 4902

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

4903 4904
	rc = mwl8k_rxq_init(hw, 0);
	if (rc)
4905
		goto err_stop_firmware;
4906 4907
	rxq_refill(hw, 0, INT_MAX);

4908 4909 4910 4911 4912 4913
	/* For the sta firmware, we need to know the dma addresses of tx queues
	 * before sending MWL8K_CMD_GET_HW_SPEC.  So we must initialize them
	 * prior to issuing this command.  But for the AP case, we learn the
	 * total number of queues from the result CMD_GET_HW_SPEC, so for this
	 * case we must initialize the tx queues after.
	 */
4914
	priv->num_ampdu_queues = 0;
4915 4916
	if (!priv->ap_fw) {
		rc = mwl8k_init_txqs(hw);
4917 4918 4919 4920 4921
		if (rc)
			goto err_free_queues;
	}

	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
4922
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4923
	iowrite32(MWL8K_A2H_INT_TX_DONE | MWL8K_A2H_INT_RX_READY,
4924
		  priv->regs + MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL);
4925 4926
	iowrite32(0xffffffff, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);

4927
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
4928 4929
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
4930
		wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
4931 4932 4933
		goto err_free_queues;
	}

4934 4935
	memset(priv->ampdu, 0, sizeof(priv->ampdu));

4936 4937
	/*
	 * Temporarily enable interrupts.  Initial firmware host
L
Lennert Buytenhek 已提交
4938
	 * commands use interrupts and avoid polling.  Disable
4939 4940
	 * interrupts when done.
	 */
4941
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4942 4943

	/* Get config data, mac addrs etc */
4944 4945
	if (priv->ap_fw) {
		rc = mwl8k_cmd_get_hw_spec_ap(hw);
4946 4947
		if (!rc)
			rc = mwl8k_init_txqs(hw);
4948 4949 4950 4951 4952
		if (!rc)
			rc = mwl8k_cmd_set_hw_spec(hw);
	} else {
		rc = mwl8k_cmd_get_hw_spec_sta(hw);
	}
4953
	if (rc) {
4954
		wiphy_err(hw->wiphy, "Cannot initialise firmware\n");
4955
		goto err_free_irq;
4956 4957 4958
	}

	/* Turn radio off */
4959
	rc = mwl8k_cmd_radio_disable(hw);
4960
	if (rc) {
4961
		wiphy_err(hw->wiphy, "Cannot disable\n");
4962
		goto err_free_irq;
4963 4964
	}

4965
	/* Clear MAC address */
4966
	rc = mwl8k_cmd_set_mac_addr(hw, NULL, "\x00\x00\x00\x00\x00\x00");
4967
	if (rc) {
4968
		wiphy_err(hw->wiphy, "Cannot clear MAC address\n");
4969
		goto err_free_irq;
4970 4971
	}

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

4976 4977 4978 4979 4980 4981
	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);
4982 4983 4984 4985 4986 4987 4988 4989

	return 0;

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

err_free_queues:
4990
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
4991 4992 4993
		mwl8k_txq_deinit(hw, i);
	mwl8k_rxq_deinit(hw, 0);

4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011
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);

5012
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5013 5014
		mwl8k_txq_deinit(hw, i);

5015
	rc = mwl8k_init_firmware(hw, fw_image, false);
5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030
	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;

5031
	for (i = 0; i < MWL8K_TX_WMM_QUEUES; i++) {
5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048
		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;

5049 5050 5051 5052 5053 5054 5055
	rc = mwl8k_load_firmware(hw);
	mwl8k_release_firmware(priv);
	if (rc) {
		wiphy_err(hw->wiphy, "Cannot start firmware\n");
		return rc;
	}

5056 5057 5058 5059 5060 5061 5062 5063 5064
	/*
	 * 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;

5065
	hw->queues = MWL8K_TX_WMM_QUEUES;
5066 5067

	/* Set rssi values to dBm */
5068
	hw->flags |= IEEE80211_HW_SIGNAL_DBM | IEEE80211_HW_HAS_RATE_CONTROL;
5069 5070 5071 5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099
	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);

5100 5101
	spin_lock_init(&priv->stream_lock);

5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122
	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:
5123
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5124 5125 5126
		mwl8k_txq_deinit(hw, i);
	mwl8k_rxq_deinit(hw, 0);

5127
err_free_cookie:
5128 5129 5130 5131
	if (priv->cookie != NULL)
		pci_free_consistent(priv->pdev, 4,
				priv->cookie, priv->cookie_dma);

5132 5133 5134 5135 5136 5137 5138 5139
	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;
5140
	struct mwl8k_device_info *di;
5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200
	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;
		}
	}

5201
	/*
5202 5203 5204
	 * 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.
5205
	 */
5206
	init_completion(&priv->firmware_loading_complete);
5207
	di = priv->device_info;
5208 5209 5210 5211 5212 5213 5214
	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) {
5215
		printk(KERN_WARNING "AP fw is unavailable.  Using STA fw.");
5216
		priv->fw_pref = di->fw_image_sta;
5217 5218
	} else if (!ap_mode_default && !di->fw_image_sta && di->fw_image_ap) {
		printk(KERN_WARNING "STA fw is unavailable.  Using AP fw.");
5219 5220 5221
		priv->fw_pref = di->fw_image_ap;
	}
	rc = mwl8k_init_firmware(hw, priv->fw_pref, true);
5222 5223
	if (rc)
		goto err_stop_firmware;
5224
	return rc;
5225

5226 5227 5228 5229
err_stop_firmware:
	mwl8k_hw_reset(priv);

err_iounmap:
5230 5231 5232
	if (priv->regs != NULL)
		pci_iounmap(pdev, priv->regs);

L
Lennert Buytenhek 已提交
5233 5234 5235
	if (priv->sram != NULL)
		pci_iounmap(pdev, priv->sram);

5236 5237 5238 5239 5240
	pci_set_drvdata(pdev, NULL);
	ieee80211_free_hw(hw);

err_free_reg:
	pci_release_regions(pdev);
5241 5242

err_disable_device:
5243 5244 5245 5246 5247
	pci_disable_device(pdev);

	return rc;
}

5248
static void __devexit mwl8k_shutdown(struct pci_dev *pdev)
5249 5250 5251 5252
{
	printk(KERN_ERR "===>%s(%u)\n", __func__, __LINE__);
}

5253
static void __devexit mwl8k_remove(struct pci_dev *pdev)
5254 5255 5256 5257 5258 5259 5260 5261 5262
{
	struct ieee80211_hw *hw = pci_get_drvdata(pdev);
	struct mwl8k_priv *priv;
	int i;

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

5263 5264 5265 5266 5267 5268 5269
	wait_for_completion(&priv->firmware_loading_complete);

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

5270 5271
	ieee80211_stop_queues(hw);

5272 5273
	ieee80211_unregister_hw(hw);

5274
	/* Remove TX reclaim and RX tasklets.  */
5275
	tasklet_kill(&priv->poll_tx_task);
5276
	tasklet_kill(&priv->poll_rx_task);
5277 5278 5279 5280 5281

	/* Stop hardware */
	mwl8k_hw_reset(priv);

	/* Return all skbs to mac80211 */
5282
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5283
		mwl8k_txq_reclaim(hw, i, INT_MAX, 1);
5284

5285
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5286 5287 5288 5289
		mwl8k_txq_deinit(hw, i);

	mwl8k_rxq_deinit(hw, 0);

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

5292
unmap:
5293
	pci_iounmap(pdev, priv->regs);
L
Lennert Buytenhek 已提交
5294
	pci_iounmap(pdev, priv->sram);
5295 5296 5297 5298 5299 5300 5301 5302
	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,
5303
	.id_table	= mwl8k_pci_id_table,
5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316 5317 5318 5319 5320
	.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 已提交
5321 5322 5323 5324 5325

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