mwl8k.c 138.2 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
#define  MWL8K_A2H_INT_DUMMY			 (1 << 20)
66
#define  MWL8K_A2H_INT_BA_WATCHDOG		 (1 << 14)
67 68 69 70 71 72 73 74 75
#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)
76

77 78 79 80 81 82 83 84
/* HW micro second timer register
 * located at offset 0xA600. This
 * will be used to timestamp tx
 * packets.
 */

#define	MWL8K_HW_TIMER_REGISTER			0x0000a600

85 86 87 88 89 90 91 92 93
#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 | \
94 95
				 MWL8K_A2H_INT_TX_DONE | \
				 MWL8K_A2H_INT_BA_WATCHDOG)
96 97

#define MWL8K_RX_QUEUES		1
98
#define MWL8K_TX_WMM_QUEUES	4
99
#define MWL8K_MAX_AMPDU_QUEUES	8
100 101
#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)
102

103 104 105 106
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);
107
	int (*rxd_process)(void *rxd, struct ieee80211_rx_status *status,
108
			   __le16 *qos, s8 *noise);
109 110
};

111
struct mwl8k_device_info {
112 113
	char *part_name;
	char *helper_image;
114 115
	char *fw_image_sta;
	char *fw_image_ap;
116
	struct rxd_ops *ap_rxd_ops;
117
	u32 fw_api_ap;
118 119
};

120
struct mwl8k_rx_queue {
121
	int rxd_count;
122 123

	/* hw receives here */
124
	int head;
125 126

	/* refill descs here */
127
	int tail;
128

129
	void *rxd;
130
	dma_addr_t rxd_dma;
131 132
	struct {
		struct sk_buff *skb;
133
		DEFINE_DMA_UNMAP_ADDR(dma);
134
	} *buf;
135 136 137 138
};

struct mwl8k_tx_queue {
	/* hw transmits here */
139
	int head;
140 141

	/* sw appends here */
142
	int tail;
143

144
	unsigned int len;
145 146 147
	struct mwl8k_tx_desc *txd;
	dma_addr_t txd_dma;
	struct sk_buff **skb;
148 149
};

150 151 152 153 154 155 156
enum {
	AMPDU_NO_STREAM,
	AMPDU_STREAM_NEW,
	AMPDU_STREAM_IN_PROGRESS,
	AMPDU_STREAM_ACTIVE,
};

157 158 159 160 161 162 163 164
struct mwl8k_ampdu_stream {
	struct ieee80211_sta *sta;
	u8 tid;
	u8 state;
	u8 idx;
	u8 txq_idx; /* index of this stream in priv->txq */
};

165 166 167
struct mwl8k_priv {
	struct ieee80211_hw *hw;
	struct pci_dev *pdev;
168
	int irq;
169

170 171
	struct mwl8k_device_info *device_info;

172 173 174 175
	void __iomem *sram;
	void __iomem *regs;

	/* firmware */
176 177
	const struct firmware *fw_helper;
	const struct firmware *fw_ucode;
178

179 180 181
	/* hardware/firmware parameters */
	bool ap_fw;
	struct rxd_ops *rxd_ops;
182 183 184
	struct ieee80211_supported_band band_24;
	struct ieee80211_channel channels_24[14];
	struct ieee80211_rate rates_24[14];
185 186 187
	struct ieee80211_supported_band band_50;
	struct ieee80211_channel channels_50[4];
	struct ieee80211_rate rates_50[9];
188 189
	u32 ap_macids_supported;
	u32 sta_macids_supported;
190

191 192
	/* Ampdu stream information */
	u8 num_ampdu_queues;
193 194
	spinlock_t stream_lock;
	struct mwl8k_ampdu_stream ampdu[MWL8K_MAX_AMPDU_QUEUES];
195
	struct work_struct watchdog_ba_handle;
196

197 198 199 200 201 202
	/* firmware access */
	struct mutex fw_mutex;
	struct task_struct *fw_mutex_owner;
	int fw_mutex_depth;
	struct completion *hostcmd_wait;

203 204 205
	/* lock held over TX and TX reap */
	spinlock_t tx_lock;

206 207 208
	/* TX quiesce completion, protected by fw_mutex and tx_lock */
	struct completion *tx_wait;

209
	/* List of interfaces.  */
210
	u32 macids_used;
211
	struct list_head vif_list;
212 213 214 215 216 217 218

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

	u16 num_mcaddrs;
	u8 hw_rev;
219
	u32 fw_rev;
220 221 222 223 224 225 226 227

	/*
	 * 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];
228 229
	struct mwl8k_tx_queue txq[MWL8K_MAX_TX_QUEUES];
	u32 txq_offset[MWL8K_MAX_TX_QUEUES];
230

231
	bool radio_on;
232
	bool radio_short_preamble;
233
	bool sniffer_enabled;
234
	bool wmm_enabled;
235 236 237

	/* XXX need to convert this to handle multiple interfaces */
	bool capture_beacon;
238
	u8 capture_bssid[ETH_ALEN];
239 240 241 242 243 244 245 246 247 248
	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;

249 250
	/* Tasklet to perform TX reclaim.  */
	struct tasklet_struct poll_tx_task;
251 252 253

	/* Tasklet to perform RX.  */
	struct tasklet_struct poll_rx_task;
254 255 256

	/* Most recently reported noise in dBm */
	s8 noise;
257 258 259 260 261

	/*
	 * preserve the queue configurations so they can be restored if/when
	 * the firmware image is swapped.
	 */
262
	struct ieee80211_tx_queue_params wmm_params[MWL8K_TX_WMM_QUEUES];
263 264 265 266 267 268

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

271 272 273
#define MAX_WEP_KEY_LEN         13
#define NUM_WEP_KEYS            4

274 275
/* Per interface specific private data */
struct mwl8k_vif {
276 277 278
	struct list_head list;
	struct ieee80211_vif *vif;

279 280 281
	/* Firmware macid for this vif.  */
	int macid;

L
Lennert Buytenhek 已提交
282
	/* Non AMPDU sequence number assigned by driver.  */
283
	u16 seqno;
284 285 286 287 288 289

	/* Saved WEP keys */
	struct {
		u8 enabled;
		u8 key[sizeof(struct ieee80211_key_conf) + MAX_WEP_KEY_LEN];
	} wep_key_conf[NUM_WEP_KEYS];
290 291 292 293 294 295

	/* BSSID */
	u8 bssid[ETH_ALEN];

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

300 301 302 303 304 305
struct tx_traffic_info {
	u32 start_time;
	u32 pkts;
};

#define MWL8K_MAX_TID 8
306 307 308
struct mwl8k_sta {
	/* Index into station database. Returned by UPDATE_STADB.  */
	u8 peer_id;
309
	u8 is_ampdu_allowed;
310
	struct tx_traffic_info tx_stats[MWL8K_MAX_TID];
311 312 313
};
#define MWL8K_STA(_sta) ((struct mwl8k_sta *)&((_sta)->drv_priv))

314
static const struct ieee80211_channel mwl8k_channels_24[] = {
315 316 317 318 319 320 321 322 323 324 325
	{ .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, },
326 327 328
	{ .center_freq = 2467, .hw_value = 12, },
	{ .center_freq = 2472, .hw_value = 13, },
	{ .center_freq = 2484, .hw_value = 14, },
329 330
};

331
static const struct ieee80211_rate mwl8k_rates_24[] = {
332 333 334
	{ .bitrate = 10, .hw_value = 2, },
	{ .bitrate = 20, .hw_value = 4, },
	{ .bitrate = 55, .hw_value = 11, },
335 336
	{ .bitrate = 110, .hw_value = 22, },
	{ .bitrate = 220, .hw_value = 44, },
337 338 339 340 341 342 343 344
	{ .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, },
345 346 347
	{ .bitrate = 720, .hw_value = 144, },
};

348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
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, },
};

367 368
/* Set or get info from Firmware */
#define MWL8K_CMD_GET			0x0000
369 370
#define MWL8K_CMD_SET			0x0001
#define MWL8K_CMD_SET_LIST		0x0002
371 372 373 374

/* Firmware command codes */
#define MWL8K_CMD_CODE_DNLD		0x0001
#define MWL8K_CMD_GET_HW_SPEC		0x0003
375
#define MWL8K_CMD_SET_HW_SPEC		0x0004
376 377
#define MWL8K_CMD_MAC_MULTICAST_ADR	0x0010
#define MWL8K_CMD_GET_STAT		0x0014
378 379
#define MWL8K_CMD_RADIO_CONTROL		0x001c
#define MWL8K_CMD_RF_TX_POWER		0x001e
380
#define MWL8K_CMD_TX_POWER		0x001f
381
#define MWL8K_CMD_RF_ANTENNA		0x0020
382
#define MWL8K_CMD_SET_BEACON		0x0100		/* per-vif */
383 384
#define MWL8K_CMD_SET_PRE_SCAN		0x0107
#define MWL8K_CMD_SET_POST_SCAN		0x0108
385 386 387 388 389
#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
390
#define MWL8K_CMD_SET_SLOT		0x0114
391 392
#define MWL8K_CMD_SET_EDCA_PARAMS	0x0115
#define MWL8K_CMD_SET_WMM_MODE		0x0123
393
#define MWL8K_CMD_MIMO_CONFIG		0x0125
394
#define MWL8K_CMD_USE_FIXED_RATE	0x0126
395
#define MWL8K_CMD_ENABLE_SNIFFER	0x0150
396
#define MWL8K_CMD_SET_MAC_ADDR		0x0202		/* per-vif */
397
#define MWL8K_CMD_SET_RATEADAPT_MODE	0x0203
398
#define MWL8K_CMD_GET_WATCHDOG_BITMAP	0x0205
399 400
#define MWL8K_CMD_BSS_START		0x1100		/* per-vif */
#define MWL8K_CMD_SET_NEW_STN		0x1111		/* per-vif */
401
#define MWL8K_CMD_UPDATE_ENCRYPTION	0x1122		/* per-vif */
402
#define MWL8K_CMD_UPDATE_STADB		0x1123
403
#define MWL8K_CMD_BASTREAM		0x1125
404

405
static const char *mwl8k_cmd_name(__le16 cmd, char *buf, int bufsize)
406
{
407 408
	u16 command = le16_to_cpu(cmd);

409 410 411 412
#define MWL8K_CMDNAME(x)	case MWL8K_CMD_##x: do {\
					snprintf(buf, bufsize, "%s", #x);\
					return buf;\
					} while (0)
413
	switch (command & ~0x8000) {
414 415
		MWL8K_CMDNAME(CODE_DNLD);
		MWL8K_CMDNAME(GET_HW_SPEC);
416
		MWL8K_CMDNAME(SET_HW_SPEC);
417 418 419 420
		MWL8K_CMDNAME(MAC_MULTICAST_ADR);
		MWL8K_CMDNAME(GET_STAT);
		MWL8K_CMDNAME(RADIO_CONTROL);
		MWL8K_CMDNAME(RF_TX_POWER);
421
		MWL8K_CMDNAME(TX_POWER);
422
		MWL8K_CMDNAME(RF_ANTENNA);
423
		MWL8K_CMDNAME(SET_BEACON);
424 425 426
		MWL8K_CMDNAME(SET_PRE_SCAN);
		MWL8K_CMDNAME(SET_POST_SCAN);
		MWL8K_CMDNAME(SET_RF_CHANNEL);
427 428 429 430
		MWL8K_CMDNAME(SET_AID);
		MWL8K_CMDNAME(SET_RATE);
		MWL8K_CMDNAME(SET_FINALIZE_JOIN);
		MWL8K_CMDNAME(RTS_THRESHOLD);
431
		MWL8K_CMDNAME(SET_SLOT);
432 433
		MWL8K_CMDNAME(SET_EDCA_PARAMS);
		MWL8K_CMDNAME(SET_WMM_MODE);
434
		MWL8K_CMDNAME(MIMO_CONFIG);
435
		MWL8K_CMDNAME(USE_FIXED_RATE);
436
		MWL8K_CMDNAME(ENABLE_SNIFFER);
437
		MWL8K_CMDNAME(SET_MAC_ADDR);
438
		MWL8K_CMDNAME(SET_RATEADAPT_MODE);
439
		MWL8K_CMDNAME(BSS_START);
440
		MWL8K_CMDNAME(SET_NEW_STN);
441
		MWL8K_CMDNAME(UPDATE_ENCRYPTION);
442
		MWL8K_CMDNAME(UPDATE_STADB);
443
		MWL8K_CMDNAME(BASTREAM);
444
		MWL8K_CMDNAME(GET_WATCHDOG_BITMAP);
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
	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 */
464
static void mwl8k_release_fw(const struct firmware **fw)
465 466 467 468 469 470 471 472 473
{
	if (*fw == NULL)
		return;
	release_firmware(*fw);
	*fw = NULL;
}

static void mwl8k_release_firmware(struct mwl8k_priv *priv)
{
474 475
	mwl8k_release_fw(&priv->fw_ucode);
	mwl8k_release_fw(&priv->fw_helper);
476 477
}

478 479 480 481 482 483 484 485 486
/* 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,
};

487 488
/* Request fw image */
static int mwl8k_request_fw(struct mwl8k_priv *priv,
489
			    const char *fname, const struct firmware **fw,
490
			    bool nowait)
491 492 493 494 495
{
	/* release current image */
	if (*fw != NULL)
		mwl8k_release_fw(fw);

496 497 498 499 500
	if (nowait)
		return request_firmware_nowait(THIS_MODULE, 1, fname,
					       &priv->pdev->dev, GFP_KERNEL,
					       priv, mwl8k_fw_state_machine);
	else
501
		return request_firmware(fw, fname, &priv->pdev->dev);
502 503
}

504 505
static int mwl8k_request_firmware(struct mwl8k_priv *priv, char *fw_image,
				  bool nowait)
506
{
507
	struct mwl8k_device_info *di = priv->device_info;
508 509
	int rc;

510
	if (di->helper_image != NULL) {
511 512 513 514 515 516 517 518 519 520 521
		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)
522
			return rc;
523 524
	}

525 526 527 528 529 530 531 532 533 534 535 536
	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);
537
	if (rc) {
L
Lennert Buytenhek 已提交
538
		printk(KERN_ERR "%s: Error requesting firmware file %s\n",
539
		       pci_name(priv->pdev), fw_image);
540
		mwl8k_release_fw(&priv->fw_helper);
541 542 543 544 545 546 547 548 549
		return rc;
	}

	return 0;
}

struct mwl8k_cmd_pkt {
	__le16	code;
	__le16	length;
550 551
	__u8	seq_num;
	__u8	macid;
552 553
	__le16	result;
	char	payload[0];
554
} __packed;
555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586

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

587
		cond_resched();
588 589 590 591 592
		udelay(1);
	} while (--loops);

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

593
	return loops ? 0 : -ETIMEDOUT;
594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
}

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;
609
	cmd->macid = 0;
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 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
	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 已提交
697
static int mwl8k_load_firmware(struct ieee80211_hw *hw)
698
{
L
Lennert Buytenhek 已提交
699
	struct mwl8k_priv *priv = hw->priv;
700
	const struct firmware *fw = priv->fw_ucode;
L
Lennert Buytenhek 已提交
701 702 703 704
	int rc;
	int loops;

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

L
Lennert Buytenhek 已提交
707 708 709 710 711
		if (helper == NULL) {
			printk(KERN_ERR "%s: helper image needed but none "
			       "given\n", pci_name(priv->pdev));
			return -EINVAL;
		}
712

L
Lennert Buytenhek 已提交
713
		rc = mwl8k_load_fw_image(priv, helper->data, helper->size);
714 715
		if (rc) {
			printk(KERN_ERR "%s: unable to load firmware "
L
Lennert Buytenhek 已提交
716
			       "helper image\n", pci_name(priv->pdev));
717 718
			return rc;
		}
719
		msleep(20);
720

L
Lennert Buytenhek 已提交
721
		rc = mwl8k_feed_fw_image(priv, fw->data, fw->size);
722
	} else {
L
Lennert Buytenhek 已提交
723
		rc = mwl8k_load_fw_image(priv, fw->data, fw->size);
724 725 726
	}

	if (rc) {
L
Lennert Buytenhek 已提交
727 728
		printk(KERN_ERR "%s: unable to load firmware image\n",
		       pci_name(priv->pdev));
729 730 731
		return rc;
	}

732
	iowrite32(MWL8K_MODE_STA, priv->regs + MWL8K_HIU_GEN_PTR);
733

734
	loops = 500000;
735
	do {
736 737 738 739 740 741 742 743
		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;
744
			break;
745 746 747
		}

		cond_resched();
748 749 750 751 752 753 754 755 756 757 758
		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;
759
	char data[0];
760
} __packed;
761 762

/* Routines to add/remove DMA header from skb.  */
763
static inline void mwl8k_remove_dma_header(struct sk_buff *skb, __le16 qos)
764
{
765 766 767 768 769 770 771 772 773 774 775 776 777
	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);
		}
778
	}
779 780 781

	if (hdrlen != sizeof(*tr))
		skb_pull(skb, sizeof(*tr) - hdrlen);
782 783
}

784 785
#define REDUCED_TX_HEADROOM	8

786
static void
787
mwl8k_add_dma_header(struct mwl8k_priv *priv, struct sk_buff *skb, int tail_pad)
788 789
{
	struct ieee80211_hdr *wh;
790
	int hdrlen;
791
	int reqd_hdrlen;
792 793
	struct mwl8k_dma_data *tr;

794 795 796 797 798 799
	/*
	 * 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).
	 */
800
	wh = (struct ieee80211_hdr *)skb->data;
801

802
	hdrlen = ieee80211_hdrlen(wh->frame_control);
803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818

	/*
	 * Check if skb_resize is required because of
	 * tx_headroom adjustment.
	 */
	if (priv->ap_fw && (hdrlen < (sizeof(struct ieee80211_cts)
						+ REDUCED_TX_HEADROOM))) {
		if (pskb_expand_head(skb, REDUCED_TX_HEADROOM, 0, GFP_ATOMIC)) {

			wiphy_err(priv->hw->wiphy,
					"Failed to reallocate TX buffer\n");
			return;
		}
		skb->truesize += REDUCED_TX_HEADROOM;
	}

819 820 821 822
	reqd_hdrlen = sizeof(*tr);

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

824
	if (ieee80211_is_data_qos(wh->frame_control))
825
		hdrlen -= IEEE80211_QOS_CTL_LEN;
826 827 828 829

	tr = (struct mwl8k_dma_data *)skb->data;
	if (wh != &tr->wh)
		memmove(&tr->wh, wh, hdrlen);
830 831
	if (hdrlen != sizeof(tr->wh))
		memset(((void *)&tr->wh) + hdrlen, 0, sizeof(tr->wh) - hdrlen);
832 833 834 835 836 837

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

841 842
static void mwl8k_encapsulate_tx_frame(struct mwl8k_priv *priv,
		struct sk_buff *skb)
843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859
{
	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
860 861
	 * payload has already been provided by mac80211, but it doesn't add
	 * tail padding when HW crypto is enabled.
862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
	 *
	 * 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;
		}
	}
883
	mwl8k_add_dma_header(priv, skb, data_pad);
884
}
885 886

/*
887
 * Packet reception for 88w8366 AP firmware.
888
 */
889
struct mwl8k_rxd_8366_ap {
890 891 892 893 894 895 896 897 898 899 900 901 902 903 904
	__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;
905
} __packed;
906

907 908 909
#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)
910

911
#define MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST	0x80
912

913 914 915 916 917 918 919
/* 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

920
static void mwl8k_rxd_8366_ap_init(void *_rxd, dma_addr_t next_dma_addr)
921
{
922
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
923 924

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
925
	rxd->rx_ctrl = MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST;
926 927
}

928
static void mwl8k_rxd_8366_ap_refill(void *_rxd, dma_addr_t addr, int len)
929
{
930
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
931 932 933 934 935 936 937 938

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

static int
939
mwl8k_rxd_8366_ap_process(void *_rxd, struct ieee80211_rx_status *status,
940
			  __le16 *qos, s8 *noise)
941
{
942
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
943

944
	if (!(rxd->rx_ctrl & MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST))
945 946 947 948 949 950
		return -1;
	rmb();

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

	status->signal = -rxd->rssi;
951
	*noise = -rxd->noise_floor;
952

953
	if (rxd->rate & MWL8K_8366_AP_RATE_INFO_MCS_FORMAT) {
954
		status->flag |= RX_FLAG_HT;
955
		if (rxd->rate & MWL8K_8366_AP_RATE_INFO_40MHZ)
956
			status->flag |= RX_FLAG_40MHZ;
957
		status->rate_idx = MWL8K_8366_AP_RATE_INFO_RATEID(rxd->rate);
958 959 960
	} else {
		int i;

961 962
		for (i = 0; i < ARRAY_SIZE(mwl8k_rates_24); i++) {
			if (mwl8k_rates_24[i].hw_value == rxd->rate) {
963 964 965 966 967 968
				status->rate_idx = i;
				break;
			}
		}
	}

969 970 971 972 973 974 975
	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;
	}
976 977
	status->freq = ieee80211_channel_to_frequency(rxd->channel,
						      status->band);
978

979 980
	*qos = rxd->qos_control;

981 982 983 984 985
	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;

986 987 988
	return le16_to_cpu(rxd->pkt_len);
}

989 990 991 992 993
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,
994 995 996
};

/*
997
 * Packet reception for STA firmware.
998
 */
999
struct mwl8k_rxd_sta {
1000 1001 1002 1003
	__le16 pkt_len;
	__u8 link_quality;
	__u8 noise_level;
	__le32 pkt_phys_addr;
1004
	__le32 next_rxd_phys_addr;
1005 1006 1007 1008 1009 1010 1011 1012 1013
	__le16 qos_control;
	__le16 rate_info;
	__le32 pad0[4];
	__u8 rssi;
	__u8 channel;
	__le16 pad1;
	__u8 rx_ctrl;
	__u8 rx_status;
	__u8 pad2[2];
1014
} __packed;
1015

1016 1017 1018 1019 1020 1021
#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
1022

1023
#define MWL8K_STA_RX_CTRL_OWNED_BY_HOST		0x02
1024 1025 1026 1027 1028
#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
1029

1030
static void mwl8k_rxd_sta_init(void *_rxd, dma_addr_t next_dma_addr)
1031
{
1032
	struct mwl8k_rxd_sta *rxd = _rxd;
1033 1034

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
1035
	rxd->rx_ctrl = MWL8K_STA_RX_CTRL_OWNED_BY_HOST;
1036 1037
}

1038
static void mwl8k_rxd_sta_refill(void *_rxd, dma_addr_t addr, int len)
1039
{
1040
	struct mwl8k_rxd_sta *rxd = _rxd;
1041 1042 1043 1044 1045 1046 1047 1048

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

static int
1049
mwl8k_rxd_sta_process(void *_rxd, struct ieee80211_rx_status *status,
1050
		       __le16 *qos, s8 *noise)
1051
{
1052
	struct mwl8k_rxd_sta *rxd = _rxd;
1053 1054
	u16 rate_info;

1055
	if (!(rxd->rx_ctrl & MWL8K_STA_RX_CTRL_OWNED_BY_HOST))
1056 1057 1058 1059 1060 1061 1062 1063
		return -1;
	rmb();

	rate_info = le16_to_cpu(rxd->rate_info);

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

	status->signal = -rxd->rssi;
1064
	*noise = -rxd->noise_level;
1065 1066
	status->antenna = MWL8K_STA_RATE_INFO_ANTSELECT(rate_info);
	status->rate_idx = MWL8K_STA_RATE_INFO_RATEID(rate_info);
1067

1068
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTPRE)
1069
		status->flag |= RX_FLAG_SHORTPRE;
1070
	if (rate_info & MWL8K_STA_RATE_INFO_40MHZ)
1071
		status->flag |= RX_FLAG_40MHZ;
1072
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTGI)
1073
		status->flag |= RX_FLAG_SHORT_GI;
1074
	if (rate_info & MWL8K_STA_RATE_INFO_MCS_FORMAT)
1075 1076
		status->flag |= RX_FLAG_HT;

1077 1078 1079 1080 1081 1082 1083
	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;
	}
1084 1085
	status->freq = ieee80211_channel_to_frequency(rxd->channel,
						      status->band);
1086

1087
	*qos = rxd->qos_control;
1088 1089 1090
	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;
1091

1092 1093 1094
	return le16_to_cpu(rxd->pkt_len);
}

1095 1096 1097 1098 1099
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,
1100 1101 1102
};


1103 1104 1105 1106 1107 1108 1109 1110 1111 1112
#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;

1113 1114 1115
	rxq->rxd_count = 0;
	rxq->head = 0;
	rxq->tail = 0;
1116

1117
	size = MWL8K_RX_DESCS * priv->rxd_ops->rxd_size;
1118

1119 1120
	rxq->rxd = pci_alloc_consistent(priv->pdev, size, &rxq->rxd_dma);
	if (rxq->rxd == NULL) {
1121
		wiphy_err(hw->wiphy, "failed to alloc RX descriptors\n");
1122 1123
		return -ENOMEM;
	}
1124
	memset(rxq->rxd, 0, size);
1125

1126
	rxq->buf = kcalloc(MWL8K_RX_DESCS, sizeof(*rxq->buf), GFP_KERNEL);
1127
	if (rxq->buf == NULL) {
1128
		wiphy_err(hw->wiphy, "failed to alloc RX skbuff list\n");
1129
		pci_free_consistent(priv->pdev, size, rxq->rxd, rxq->rxd_dma);
1130 1131 1132 1133
		return -ENOMEM;
	}

	for (i = 0; i < MWL8K_RX_DESCS; i++) {
1134 1135
		int desc_size;
		void *rxd;
1136
		int nexti;
1137 1138 1139 1140
		dma_addr_t next_dma_addr;

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

1142 1143 1144 1145
		nexti = i + 1;
		if (nexti == MWL8K_RX_DESCS)
			nexti = 0;
		next_dma_addr = rxq->rxd_dma + (nexti * desc_size);
1146

1147
		priv->rxd_ops->rxd_init(rxd, next_dma_addr);
1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159
	}

	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;
1160
	while (rxq->rxd_count < MWL8K_RX_DESCS && limit--) {
1161
		struct sk_buff *skb;
1162
		dma_addr_t addr;
1163
		int rx;
1164
		void *rxd;
1165 1166 1167 1168 1169

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

1170 1171
		addr = pci_map_single(priv->pdev, skb->data,
				      MWL8K_RX_MAXSZ, DMA_FROM_DEVICE);
1172

1173 1174 1175 1176
		rxq->rxd_count++;
		rx = rxq->tail++;
		if (rxq->tail == MWL8K_RX_DESCS)
			rxq->tail = 0;
1177
		rxq->buf[rx].skb = skb;
1178
		dma_unmap_addr_set(&rxq->buf[rx], dma, addr);
1179 1180 1181

		rxd = rxq->rxd + (rx * priv->rxd_ops->rxd_size);
		priv->rxd_ops->rxd_refill(rxd, addr, MWL8K_RX_MAXSZ);
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195

		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;

1196 1197 1198
	if (rxq->rxd == NULL)
		return;

1199
	for (i = 0; i < MWL8K_RX_DESCS; i++) {
1200 1201
		if (rxq->buf[i].skb != NULL) {
			pci_unmap_single(priv->pdev,
1202
					 dma_unmap_addr(&rxq->buf[i], dma),
1203
					 MWL8K_RX_MAXSZ, PCI_DMA_FROMDEVICE);
1204
			dma_unmap_addr_set(&rxq->buf[i], dma, 0);
1205 1206 1207

			kfree_skb(rxq->buf[i].skb);
			rxq->buf[i].skb = NULL;
1208 1209 1210
		}
	}

1211 1212
	kfree(rxq->buf);
	rxq->buf = NULL;
1213 1214

	pci_free_consistent(priv->pdev,
1215
			    MWL8K_RX_DESCS * priv->rxd_ops->rxd_size,
1216 1217
			    rxq->rxd, rxq->rxd_dma);
	rxq->rxd = NULL;
1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232
}


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

1233 1234
static inline void mwl8k_save_beacon(struct ieee80211_hw *hw,
				     struct sk_buff *skb)
1235
{
1236 1237
	struct mwl8k_priv *priv = hw->priv;

1238
	priv->capture_beacon = false;
1239
	memset(priv->capture_bssid, 0, ETH_ALEN);
1240 1241 1242 1243 1244 1245 1246 1247

	/*
	 * 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)
1248
		ieee80211_queue_work(hw, &priv->finalize_join_worker);
1249 1250
}

1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265
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;
}

1266 1267 1268
static int rxq_process(struct ieee80211_hw *hw, int index, int limit)
{
	struct mwl8k_priv *priv = hw->priv;
1269
	struct mwl8k_vif *mwl8k_vif = NULL;
1270 1271 1272 1273
	struct mwl8k_rx_queue *rxq = priv->rxq + index;
	int processed;

	processed = 0;
1274
	while (rxq->rxd_count && limit--) {
1275
		struct sk_buff *skb;
1276 1277
		void *rxd;
		int pkt_len;
1278
		struct ieee80211_rx_status status;
1279
		struct ieee80211_hdr *wh;
1280
		__le16 qos;
1281

1282
		skb = rxq->buf[rxq->head].skb;
1283 1284
		if (skb == NULL)
			break;
1285 1286 1287

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

1288 1289
		pkt_len = priv->rxd_ops->rxd_process(rxd, &status, &qos,
							&priv->noise);
1290 1291 1292
		if (pkt_len < 0)
			break;

1293 1294 1295
		rxq->buf[rxq->head].skb = NULL;

		pci_unmap_single(priv->pdev,
1296
				 dma_unmap_addr(&rxq->buf[rxq->head], dma),
1297
				 MWL8K_RX_MAXSZ, PCI_DMA_FROMDEVICE);
1298
		dma_unmap_addr_set(&rxq->buf[rxq->head], dma, 0);
1299

1300 1301 1302 1303
		rxq->head++;
		if (rxq->head == MWL8K_RX_DESCS)
			rxq->head = 0;

1304
		rxq->rxd_count--;
1305

1306
		wh = &((struct mwl8k_dma_data *)skb->data)->wh;
1307 1308

		/*
L
Lennert Buytenhek 已提交
1309 1310 1311
		 * 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.
1312
		 */
1313
		if (mwl8k_capture_bssid(priv, (void *)skb->data))
1314
			mwl8k_save_beacon(hw, skb);
1315

1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355
		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);
1356 1357
		memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
		ieee80211_rx_irqsafe(hw, skb);
1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375

		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

1376 1377 1378 1379 1380 1381
#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

1382 1383 1384 1385 1386 1387 1388
struct mwl8k_tx_desc {
	__le32 status;
	__u8 data_rate;
	__u8 tx_priority;
	__le16 qos_control;
	__le32 pkt_phys_addr;
	__le16 pkt_len;
1389
	__u8 dest_MAC_addr[ETH_ALEN];
1390
	__le32 next_txd_phys_addr;
1391
	__le32 timestamp;
1392 1393
	__le16 rate_info;
	__u8 peer_id;
1394
	__u8 tx_frag_cnt;
1395
} __packed;
1396 1397 1398 1399 1400 1401 1402 1403 1404 1405

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

1406
	txq->len = 0;
1407 1408
	txq->head = 0;
	txq->tail = 0;
1409 1410 1411

	size = MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc);

1412 1413
	txq->txd = pci_alloc_consistent(priv->pdev, size, &txq->txd_dma);
	if (txq->txd == NULL) {
1414
		wiphy_err(hw->wiphy, "failed to alloc TX descriptors\n");
1415 1416
		return -ENOMEM;
	}
1417
	memset(txq->txd, 0, size);
1418

1419
	txq->skb = kcalloc(MWL8K_TX_DESCS, sizeof(*txq->skb), GFP_KERNEL);
1420
	if (txq->skb == NULL) {
1421
		wiphy_err(hw->wiphy, "failed to alloc TX skbuff list\n");
1422
		pci_free_consistent(priv->pdev, size, txq->txd, txq->txd_dma);
1423 1424 1425 1426 1427 1428 1429
		return -ENOMEM;
	}

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

1430
		tx_desc = txq->txd + i;
1431 1432 1433
		nexti = (i + 1) % MWL8K_TX_DESCS;

		tx_desc->status = 0;
1434 1435
		tx_desc->next_txd_phys_addr =
			cpu_to_le32(txq->txd_dma + nexti * sizeof(*tx_desc));
1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449
	}

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

1450
static void mwl8k_dump_tx_rings(struct ieee80211_hw *hw)
1451
{
1452 1453 1454
	struct mwl8k_priv *priv = hw->priv;
	int i;

1455
	for (i = 0; i < mwl8k_tx_queues(priv); i++) {
1456 1457 1458 1459 1460 1461
		struct mwl8k_tx_queue *txq = priv->txq + i;
		int fw_owned = 0;
		int drv_owned = 0;
		int unused = 0;
		int desc;

1462
		for (desc = 0; desc < MWL8K_TX_DESCS; desc++) {
1463 1464
			struct mwl8k_tx_desc *tx_desc = txq->txd + desc;
			u32 status;
1465

1466
			status = le32_to_cpu(tx_desc->status);
1467
			if (status & MWL8K_TXD_STATUS_FW_OWNED)
1468
				fw_owned++;
1469
			else
1470
				drv_owned++;
1471 1472

			if (tx_desc->pkt_len == 0)
1473
				unused++;
1474 1475
		}

1476 1477 1478 1479 1480 1481
		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);
1482
	}
1483 1484
}

1485
/*
1486
 * Must be called with priv->fw_mutex held and tx queues stopped.
1487
 */
1488
#define MWL8K_TX_WAIT_TIMEOUT_MS	5000
1489

1490
static int mwl8k_tx_wait_empty(struct ieee80211_hw *hw)
1491 1492
{
	struct mwl8k_priv *priv = hw->priv;
1493
	DECLARE_COMPLETION_ONSTACK(tx_wait);
1494 1495
	int retry;
	int rc;
1496 1497 1498

	might_sleep();

1499 1500 1501 1502 1503 1504 1505 1506 1507 1508
	/*
	 * 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;

1509
	spin_lock_bh(&priv->tx_lock);
1510 1511 1512 1513
	priv->tx_wait = &tx_wait;
	while (!rc) {
		int oldcount;
		unsigned long timeout;
1514

1515
		oldcount = priv->pending_tx_pkts;
1516

1517
		spin_unlock_bh(&priv->tx_lock);
1518
		timeout = wait_for_completion_timeout(&tx_wait,
1519
			    msecs_to_jiffies(MWL8K_TX_WAIT_TIMEOUT_MS));
1520
		spin_lock_bh(&priv->tx_lock);
1521 1522 1523

		if (timeout) {
			WARN_ON(priv->pending_tx_pkts);
1524
			if (retry)
1525
				wiphy_notice(hw->wiphy, "tx rings drained\n");
1526 1527 1528 1529
			break;
		}

		if (priv->pending_tx_pkts < oldcount) {
1530 1531 1532
			wiphy_notice(hw->wiphy,
				     "waiting for tx rings to drain (%d -> %d pkts)\n",
				     oldcount, priv->pending_tx_pkts);
1533 1534 1535 1536
			retry = 1;
			continue;
		}

1537 1538
		priv->tx_wait = NULL;

1539 1540
		wiphy_err(hw->wiphy, "tx rings stuck for %d ms\n",
			  MWL8K_TX_WAIT_TIMEOUT_MS);
1541 1542 1543
		mwl8k_dump_tx_rings(hw);

		rc = -ETIMEDOUT;
1544
	}
1545
	spin_unlock_bh(&priv->tx_lock);
1546

1547
	return rc;
1548 1549
}

1550 1551 1552 1553
#define MWL8K_TXD_SUCCESS(status)				\
	((status) & (MWL8K_TXD_STATUS_OK |			\
		     MWL8K_TXD_STATUS_OK_RETRY |		\
		     MWL8K_TXD_STATUS_OK_MORE_RETRY))
1554

1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581
static int mwl8k_tid_queue_mapping(u8 tid)
{
	BUG_ON(tid > 7);

	switch (tid) {
	case 0:
	case 3:
		return IEEE80211_AC_BE;
		break;
	case 1:
	case 2:
		return IEEE80211_AC_BK;
		break;
	case 4:
	case 5:
		return IEEE80211_AC_VI;
		break;
	case 6:
	case 7:
		return IEEE80211_AC_VO;
		break;
	default:
		return -1;
		break;
	}
}

1582 1583
/* The firmware will fill in the rate information
 * for each packet that gets queued in the hardware
1584
 * and these macros will interpret that info.
1585 1586
 */

1587 1588
#define RI_FORMAT(a)		  (a & 0x0001)
#define RI_RATE_ID_MCS(a)	 ((a & 0x01f8) >> 3)
1589

1590 1591
static int
mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int limit, int force)
1592 1593 1594
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_tx_queue *txq = priv->txq + index;
1595
	int processed;
1596

1597
	processed = 0;
1598
	while (txq->len > 0 && limit--) {
1599 1600 1601
		int tx;
		struct mwl8k_tx_desc *tx_desc;
		unsigned long addr;
1602
		int size;
1603 1604 1605
		struct sk_buff *skb;
		struct ieee80211_tx_info *info;
		u32 status;
1606 1607 1608 1609
		struct ieee80211_sta *sta;
		struct mwl8k_sta *sta_info = NULL;
		u16 rate_info;
		struct ieee80211_hdr *wh;
1610

1611 1612
		tx = txq->head;
		tx_desc = txq->txd + tx;
1613 1614 1615 1616 1617 1618 1619 1620 1621 1622

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

1623
		txq->head = (tx + 1) % MWL8K_TX_DESCS;
1624 1625
		BUG_ON(txq->len == 0);
		txq->len--;
1626 1627 1628
		priv->pending_tx_pkts--;

		addr = le32_to_cpu(tx_desc->pkt_phys_addr);
1629
		size = le16_to_cpu(tx_desc->pkt_len);
1630 1631
		skb = txq->skb[tx];
		txq->skb[tx] = NULL;
1632 1633 1634 1635

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

1636
		mwl8k_remove_dma_header(skb, tx_desc->qos_control);
1637

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

1640 1641 1642 1643 1644
		/* Mark descriptor as unused */
		tx_desc->pkt_phys_addr = 0;
		tx_desc->pkt_len = 0;

		info = IEEE80211_SKB_CB(skb);
1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655
		if (ieee80211_is_data(wh->frame_control)) {
			sta = info->control.sta;
			if (sta) {
				sta_info = MWL8K_STA(sta);
				BUG_ON(sta_info == NULL);
				rate_info = le16_to_cpu(tx_desc->rate_info);
				/* If rate is < 6.5 Mpbs for an ht station
				 * do not form an ampdu. If the station is a
				 * legacy station (format = 0), do not form an
				 * ampdu
				 */
1656 1657
				if (RI_RATE_ID_MCS(rate_info) < 1 ||
				    RI_FORMAT(rate_info) == 0) {
1658 1659 1660 1661 1662 1663 1664
					sta_info->is_ampdu_allowed = false;
				} else {
					sta_info->is_ampdu_allowed = true;
				}
			}
		}

1665
		ieee80211_tx_info_clear_status(info);
1666 1667 1668 1669

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

1673
		if (MWL8K_TXD_SUCCESS(status))
1674 1675 1676 1677
			info->flags |= IEEE80211_TX_STAT_ACK;

		ieee80211_tx_status_irqsafe(hw, skb);

1678
		processed++;
1679 1680
	}

1681
	return processed;
1682 1683 1684 1685 1686 1687 1688 1689
}

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

1690 1691 1692
	if (txq->txd == NULL)
		return;

1693
	mwl8k_txq_reclaim(hw, index, INT_MAX, 1);
1694

1695 1696
	kfree(txq->skb);
	txq->skb = NULL;
1697 1698 1699

	pci_free_consistent(priv->pdev,
			    MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc),
1700 1701
			    txq->txd, txq->txd_dma);
	txq->txd = NULL;
1702 1703
}

1704
/* caller must hold priv->stream_lock when calling the stream functions */
1705
static struct mwl8k_ampdu_stream *
1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771
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;
}

1772 1773 1774 1775 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
#define MWL8K_AMPDU_PACKET_THRESHOLD 64
static inline bool mwl8k_ampdu_allowed(struct ieee80211_sta *sta, u8 tid)
{
	struct mwl8k_sta *sta_info = MWL8K_STA(sta);
	struct tx_traffic_info *tx_stats;

	BUG_ON(tid >= MWL8K_MAX_TID);
	tx_stats = &sta_info->tx_stats[tid];

	return sta_info->is_ampdu_allowed &&
		tx_stats->pkts > MWL8K_AMPDU_PACKET_THRESHOLD;
}

static inline void mwl8k_tx_count_packet(struct ieee80211_sta *sta, u8 tid)
{
	struct mwl8k_sta *sta_info = MWL8K_STA(sta);
	struct tx_traffic_info *tx_stats;

	BUG_ON(tid >= MWL8K_MAX_TID);
	tx_stats = &sta_info->tx_stats[tid];

	if (tx_stats->start_time == 0)
		tx_stats->start_time = jiffies;

	/* reset the packet count after each second elapses.  If the number of
	 * packets ever exceeds the ampdu_min_traffic threshold, we will allow
	 * an ampdu stream to be started.
	 */
	if (jiffies - tx_stats->start_time > HZ) {
		tx_stats->pkts = 0;
		tx_stats->start_time = 0;
	} else
		tx_stats->pkts++;
}

1807
static void
1808 1809 1810 1811
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;
1812
	struct mwl8k_vif *mwl8k_vif;
N
Nishant Sarmukadam 已提交
1813
	struct ieee80211_sta *sta;
1814 1815 1816 1817
	struct ieee80211_hdr *wh;
	struct mwl8k_tx_queue *txq;
	struct mwl8k_tx_desc *tx;
	dma_addr_t dma;
1818 1819 1820
	u32 txstatus;
	u8 txdatarate;
	u16 qos;
N
Nishant Sarmukadam 已提交
1821 1822 1823 1824
	int txpriority;
	u8 tid = 0;
	struct mwl8k_ampdu_stream *stream = NULL;
	bool start_ba_session = false;
1825
	bool mgmtframe = false;
1826
	struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)skb->data;
1827

1828 1829 1830 1831 1832
	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;
1833

1834 1835 1836
	if (ieee80211_is_mgmt(wh->frame_control))
		mgmtframe = true;

1837
	if (priv->ap_fw)
1838
		mwl8k_encapsulate_tx_frame(priv, skb);
1839
	else
1840
		mwl8k_add_dma_header(priv, skb, 0);
1841

1842
	wh = &((struct mwl8k_dma_data *)skb->data)->wh;
1843 1844

	tx_info = IEEE80211_SKB_CB(skb);
N
Nishant Sarmukadam 已提交
1845
	sta = tx_info->control.sta;
1846 1847 1848 1849
	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);
1850 1851
		wh->seq_ctrl |= cpu_to_le16(mwl8k_vif->seqno);
		mwl8k_vif->seqno += 0x10;
1852 1853
	}

1854 1855 1856 1857 1858 1859
	/* 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;
1860
		qos |= MWL8K_QOS_QLEN_UNSPEC | MWL8K_QOS_EOSP;
1861 1862 1863 1864 1865
	} else if (ieee80211_is_data(wh->frame_control)) {
		txdatarate = 1;
		if (is_multicast_ether_addr(wh->addr1))
			txstatus |= MWL8K_TXD_STATUS_MULTICAST_TX;

1866
		qos &= ~MWL8K_QOS_ACK_POLICY_MASK;
1867
		if (tx_info->flags & IEEE80211_TX_CTL_AMPDU)
1868
			qos |= MWL8K_QOS_ACK_POLICY_BLOCKACK;
1869
		else
1870
			qos |= MWL8K_QOS_ACK_POLICY_NORMAL;
1871
	}
1872

1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890
	/* Queue ADDBA request in the respective data queue.  While setting up
	 * the ampdu stream, mac80211 queues further packets for that
	 * particular ra/tid pair.  However, packets piled up in the hardware
	 * for that ra/tid pair will still go out. ADDBA request and the
	 * related data packets going out from different queues asynchronously
	 * will cause a shift in the receiver window which might result in
	 * ampdu packets getting dropped at the receiver after the stream has
	 * been setup.
	 */
	if (unlikely(ieee80211_is_action(wh->frame_control) &&
	    mgmt->u.action.category == WLAN_CATEGORY_BACK &&
	    mgmt->u.action.u.addba_req.action_code == WLAN_ACTION_ADDBA_REQ &&
	    priv->ap_fw)) {
		u16 capab = le16_to_cpu(mgmt->u.action.u.addba_req.capab);
		tid = (capab & IEEE80211_ADDBA_PARAM_TID_MASK) >> 2;
		index = mwl8k_tid_queue_mapping(tid);
	}

N
Nishant Sarmukadam 已提交
1891 1892 1893 1894 1895 1896
	txpriority = index;

	if (ieee80211_is_data_qos(wh->frame_control) &&
	    skb->protocol != cpu_to_be16(ETH_P_PAE) &&
	    sta->ht_cap.ht_supported && priv->ap_fw) {
		tid = qos & 0xf;
1897
		mwl8k_tx_count_packet(sta, tid);
N
Nishant Sarmukadam 已提交
1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925 1926 1927 1928 1929 1930 1931 1932 1933 1934 1935 1936 1937
		spin_lock(&priv->stream_lock);
		stream = mwl8k_lookup_stream(hw, sta->addr, tid);
		if (stream != NULL) {
			if (stream->state == AMPDU_STREAM_ACTIVE) {
				txpriority = stream->txq_idx;
				index = stream->txq_idx;
			} else if (stream->state == AMPDU_STREAM_NEW) {
				/* We get here if the driver sends us packets
				 * after we've initiated a stream, but before
				 * our ampdu_action routine has been called
				 * with IEEE80211_AMPDU_TX_START to get the SSN
				 * for the ADDBA request.  So this packet can
				 * go out with no risk of sequence number
				 * mismatch.  No special handling is required.
				 */
			} else {
				/* Drop packets that would go out after the
				 * ADDBA request was sent but before the ADDBA
				 * response is received.  If we don't do this,
				 * the recipient would probably receive it
				 * after the ADDBA request with SSN 0.  This
				 * will cause the recipient's BA receive window
				 * to shift, which would cause the subsequent
				 * packets in the BA stream to be discarded.
				 * mac80211 queues our packets for us in this
				 * case, so this is really just a safety check.
				 */
				wiphy_warn(hw->wiphy,
					   "Cannot send packet while ADDBA "
					   "dialog is underway.\n");
				spin_unlock(&priv->stream_lock);
				dev_kfree_skb(skb);
				return;
			}
		} else {
			/* Defer calling mwl8k_start_stream so that the current
			 * skb can go out before the ADDBA request.  This
			 * prevents sequence number mismatch at the recepient
			 * as described above.
			 */
1938
			if (mwl8k_ampdu_allowed(sta, tid)) {
1939 1940 1941 1942
				stream = mwl8k_add_stream(hw, sta, tid);
				if (stream != NULL)
					start_ba_session = true;
			}
N
Nishant Sarmukadam 已提交
1943 1944 1945 1946
		}
		spin_unlock(&priv->stream_lock);
	}

1947 1948 1949 1950
	dma = pci_map_single(priv->pdev, skb->data,
				skb->len, PCI_DMA_TODEVICE);

	if (pci_dma_mapping_error(priv->pdev, dma)) {
1951 1952
		wiphy_debug(hw->wiphy,
			    "failed to dma map skb, dropping TX frame.\n");
N
Nishant Sarmukadam 已提交
1953 1954 1955 1956 1957
		if (start_ba_session) {
			spin_lock(&priv->stream_lock);
			mwl8k_remove_stream(hw, stream);
			spin_unlock(&priv->stream_lock);
		}
1958
		dev_kfree_skb(skb);
1959
		return;
1960 1961
	}

1962
	spin_lock_bh(&priv->tx_lock);
1963

1964
	txq = priv->txq + index;
1965

1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984
	/* Mgmt frames that go out frequently are probe
	 * responses. Other mgmt frames got out relatively
	 * infrequently. Hence reserve 2 buffers so that
	 * other mgmt frames do not get dropped due to an
	 * already queued probe response in one of the
	 * reserved buffers.
	 */

	if (txq->len >= MWL8K_TX_DESCS - 2) {
		if (mgmtframe == false ||
			txq->len == MWL8K_TX_DESCS) {
			if (start_ba_session) {
				spin_lock(&priv->stream_lock);
				mwl8k_remove_stream(hw, stream);
				spin_unlock(&priv->stream_lock);
			}
			spin_unlock_bh(&priv->tx_lock);
			dev_kfree_skb(skb);
			return;
P
Pradeep Nemavat 已提交
1985
		}
N
Nishant Sarmukadam 已提交
1986 1987
	}

1988 1989
	BUG_ON(txq->skb[txq->tail] != NULL);
	txq->skb[txq->tail] = skb;
1990

1991
	tx = txq->txd + txq->tail;
1992
	tx->data_rate = txdatarate;
N
Nishant Sarmukadam 已提交
1993
	tx->tx_priority = txpriority;
1994 1995 1996
	tx->qos_control = cpu_to_le16(qos);
	tx->pkt_phys_addr = cpu_to_le32(dma);
	tx->pkt_len = cpu_to_le16(skb->len);
1997
	tx->rate_info = 0;
1998 1999 2000 2001
	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;
2002 2003 2004 2005 2006

	if (priv->ap_fw)
		tx->timestamp = cpu_to_le32(ioread32(priv->regs +
						MWL8K_HW_TIMER_REGISTER));

2007
	wmb();
2008 2009
	tx->status = cpu_to_le32(MWL8K_TXD_STATUS_FW_OWNED | txstatus);

2010
	txq->len++;
2011 2012
	priv->pending_tx_pkts++;

2013 2014 2015
	txq->tail++;
	if (txq->tail == MWL8K_TX_DESCS)
		txq->tail = 0;
2016 2017

	mwl8k_tx_start(priv);
2018 2019

	spin_unlock_bh(&priv->tx_lock);
N
Nishant Sarmukadam 已提交
2020 2021 2022 2023 2024 2025 2026 2027

	/* Initiate the ampdu session here */
	if (start_ba_session) {
		spin_lock(&priv->stream_lock);
		if (mwl8k_start_stream(hw, stream))
			mwl8k_remove_stream(hw, stream);
		spin_unlock(&priv->stream_lock);
	}
2028 2029 2030
}


2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084
/*
 * 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);
	}
}


2085 2086 2087 2088
/*
 * Command processing.
 */

2089 2090
/* Timeout firmware commands after 10s */
#define MWL8K_CMD_TIMEOUT_MS	10000
2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102

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

2103
	cmd->result = (__force __le16) 0xffff;
2104 2105 2106 2107 2108 2109
	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;

2110
	rc = mwl8k_fw_lock(hw);
2111 2112 2113
	if (rc) {
		pci_unmap_single(priv->pdev, dma_addr, dma_size,
						PCI_DMA_BIDIRECTIONAL);
2114
		return rc;
2115
	}
2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126

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

2127 2128 2129 2130
	priv->hostcmd_wait = NULL;

	mwl8k_fw_unlock(hw);

2131 2132 2133
	pci_unmap_single(priv->pdev, dma_addr, dma_size,
					PCI_DMA_BIDIRECTIONAL);

2134
	if (!timeout) {
2135
		wiphy_err(hw->wiphy, "Command %s timeout after %u ms\n",
2136 2137
			  mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
			  MWL8K_CMD_TIMEOUT_MS);
2138 2139
		rc = -ETIMEDOUT;
	} else {
2140 2141 2142 2143
		int ms;

		ms = MWL8K_CMD_TIMEOUT_MS - jiffies_to_msecs(timeout);

2144
		rc = cmd->result ? -EINVAL : 0;
2145
		if (rc)
2146
			wiphy_err(hw->wiphy, "Command %s error 0x%x\n",
2147 2148
				  mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
				  le16_to_cpu(cmd->result));
2149
		else if (ms > 2000)
2150
			wiphy_notice(hw->wiphy, "Command %s took %d ms\n",
2151 2152 2153
				     mwl8k_cmd_name(cmd->code,
						    buf, sizeof(buf)),
				     ms);
2154 2155 2156 2157 2158
	}

	return rc;
}

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

2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189
/*
 * 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;
}

2190 2191 2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208
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;
}

2209
/*
2210
 * CMD_GET_HW_SPEC (STA version).
2211
 */
2212
struct mwl8k_cmd_get_hw_spec_sta {
2213 2214 2215 2216
	struct mwl8k_cmd_pkt header;
	__u8 hw_rev;
	__u8 host_interface;
	__le16 num_mcaddrs;
2217
	__u8 perm_addr[ETH_ALEN];
2218 2219 2220 2221 2222 2223 2224
	__le16 region_code;
	__le32 fw_rev;
	__le32 ps_cookie;
	__le32 caps;
	__u8 mcs_bitmap[16];
	__le32 rx_queue_ptr;
	__le32 num_tx_queues;
2225
	__le32 tx_queue_ptrs[MWL8K_TX_WMM_QUEUES];
2226 2227
	__le32 caps2;
	__le32 num_tx_desc_per_queue;
2228
	__le32 total_rxd;
2229
} __packed;
2230

2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242
#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
2243 2244 2245
#define MWL8K_CAP_BAND_MASK		0x00000007
#define MWL8K_CAP_5GHZ			0x00000004
#define MWL8K_CAP_2GHZ4			0x00000001
2246

2247 2248 2249
static void
mwl8k_set_ht_caps(struct ieee80211_hw *hw,
		  struct ieee80211_supported_band *band, u32 cap)
2250 2251 2252 2253
{
	int rx_streams;
	int tx_streams;

2254
	band->ht_cap.ht_supported = 1;
2255 2256

	if (cap & MWL8K_CAP_MAX_AMSDU)
2257
		band->ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
2258
	if (cap & MWL8K_CAP_GREENFIELD)
2259
		band->ht_cap.cap |= IEEE80211_HT_CAP_GRN_FLD;
2260 2261
	if (cap & MWL8K_CAP_AMPDU) {
		hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
2262 2263
		band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
		band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
2264 2265
	}
	if (cap & MWL8K_CAP_RX_STBC)
2266
		band->ht_cap.cap |= IEEE80211_HT_CAP_RX_STBC;
2267
	if (cap & MWL8K_CAP_TX_STBC)
2268
		band->ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
2269
	if (cap & MWL8K_CAP_SHORTGI_40MHZ)
2270
		band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
2271
	if (cap & MWL8K_CAP_SHORTGI_20MHZ)
2272
		band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
2273
	if (cap & MWL8K_CAP_DELAY_BA)
2274
		band->ht_cap.cap |= IEEE80211_HT_CAP_DELAY_BA;
2275
	if (cap & MWL8K_CAP_40MHZ)
2276
		band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
2277 2278 2279 2280

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

2281
	band->ht_cap.mcs.rx_mask[0] = 0xff;
2282
	if (rx_streams >= 2)
2283
		band->ht_cap.mcs.rx_mask[1] = 0xff;
2284
	if (rx_streams >= 3)
2285 2286 2287
		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;
2288 2289

	if (rx_streams != tx_streams) {
2290 2291
		band->ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
		band->ht_cap.mcs.tx_params |= (tx_streams - 1) <<
2292 2293 2294 2295
				IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
	}
}

2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313
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);
	}
}

2314
static int mwl8k_cmd_get_hw_spec_sta(struct ieee80211_hw *hw)
2315 2316
{
	struct mwl8k_priv *priv = hw->priv;
2317
	struct mwl8k_cmd_get_hw_spec_sta *cmd;
2318 2319 2320 2321 2322 2323 2324 2325 2326 2327 2328 2329
	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);
2330
	cmd->rx_queue_ptr = cpu_to_le32(priv->rxq[0].rxd_dma);
2331 2332
	cmd->num_tx_queues = cpu_to_le32(mwl8k_tx_queues(priv));
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
2333
		cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[i].txd_dma);
2334
	cmd->num_tx_desc_per_queue = cpu_to_le32(MWL8K_TX_DESCS);
2335
	cmd->total_rxd = cpu_to_le32(MWL8K_RX_DESCS);
2336 2337 2338 2339 2340 2341

	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);
2342
		priv->fw_rev = le32_to_cpu(cmd->fw_rev);
2343
		priv->hw_rev = cmd->hw_rev;
2344
		mwl8k_set_caps(hw, le32_to_cpu(cmd->caps));
2345 2346
		priv->ap_macids_supported = 0x00000000;
		priv->sta_macids_supported = 0x00000001;
2347 2348 2349 2350 2351 2352
	}

	kfree(cmd);
	return rc;
}

2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372
/*
 * 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;
2373
	__le32 fw_api_version;
2374 2375 2376
	__le32 caps;
	__le32 num_of_ampdu_queues;
	__le32 wcbbase_ampdu[MWL8K_MAX_AMPDU_QUEUES];
2377
} __packed;
2378 2379 2380 2381 2382

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;
2383
	int rc, i;
2384
	u32 api_version;
2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400

	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;

2401 2402 2403 2404 2405 2406 2407 2408 2409 2410
		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;
		}
2411 2412 2413 2414
		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;
2415
		mwl8k_set_caps(hw, le32_to_cpu(cmd->caps));
2416 2417
		priv->ap_macids_supported = 0x000000ff;
		priv->sta_macids_supported = 0x00000000;
2418 2419 2420 2421 2422 2423 2424 2425
		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;
		}
2426
		off = le32_to_cpu(cmd->rxwrptr) & 0xffff;
2427
		iowrite32(priv->rxq[0].rxd_dma, priv->sram + off);
2428 2429

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

2432 2433 2434 2435
		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;
2436 2437

		for (i = 0; i < priv->num_ampdu_queues; i++)
2438
			priv->txq_offset[i + MWL8K_TX_WMM_QUEUES] =
2439
				le32_to_cpu(cmd->wcbbase_ampdu[i]) & 0xffff;
2440 2441
	}

2442
done:
2443 2444 2445 2446 2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461
	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;
2462
	__le32 tx_queue_ptrs[MWL8K_MAX_TX_QUEUES];
2463 2464 2465
	__le32 flags;
	__le32 num_tx_desc_per_queue;
	__le32 total_rxd;
2466
} __packed;
2467

2468 2469 2470 2471 2472 2473 2474 2475
/* 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
2476 2477 2478
#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
2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495

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);
2496
	cmd->num_tx_queues = cpu_to_le32(mwl8k_tx_queues(priv));
2497 2498 2499 2500 2501 2502 2503

	/*
	 * 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.
	 */
2504 2505
	for (i = 0; i < mwl8k_tx_queues(priv); i++) {
		int j = mwl8k_tx_queues(priv) - 1 - i;
2506 2507 2508
		cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[j].txd_dma);
	}

2509 2510
	cmd->flags = cpu_to_le32(MWL8K_SET_HW_SPEC_FLAG_HOST_DECR_MGMT |
				 MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_PROBERESP |
2511 2512
				 MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_BEACON |
				 MWL8K_SET_HW_SPEC_FLAG_ENABLE_LIFE_TIME_EXPIRY);
2513 2514 2515 2516 2517 2518 2519 2520 2521
	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;
}

2522 2523 2524 2525 2526 2527 2528
/*
 * CMD_MAC_MULTICAST_ADR.
 */
struct mwl8k_cmd_mac_multicast_adr {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 numaddr;
2529
	__u8 addr[0][ETH_ALEN];
2530 2531
};

2532 2533 2534 2535
#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
2536

2537
static struct mwl8k_cmd_pkt *
L
Lennert Buytenhek 已提交
2538
__mwl8k_cmd_mac_multicast_adr(struct ieee80211_hw *hw, int allmulti,
2539
			      struct netdev_hw_addr_list *mc_list)
2540
{
2541
	struct mwl8k_priv *priv = hw->priv;
2542
	struct mwl8k_cmd_mac_multicast_adr *cmd;
2543
	int size;
2544 2545 2546 2547
	int mc_count = 0;

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

L
Lennert Buytenhek 已提交
2549
	if (allmulti || mc_count > priv->num_mcaddrs) {
2550 2551 2552
		allmulti = 1;
		mc_count = 0;
	}
2553 2554

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

2556
	cmd = kzalloc(size, GFP_ATOMIC);
2557
	if (cmd == NULL)
2558
		return NULL;
2559 2560 2561

	cmd->header.code = cpu_to_le16(MWL8K_CMD_MAC_MULTICAST_ADR);
	cmd->header.length = cpu_to_le16(size);
2562 2563 2564 2565 2566 2567
	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) {
2568 2569
		struct netdev_hw_addr *ha;
		int i = 0;
2570 2571 2572

		cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_MULTICAST);
		cmd->numaddr = cpu_to_le16(mc_count);
2573 2574
		netdev_hw_addr_list_for_each(ha, mc_list) {
			memcpy(cmd->addr[i], ha->addr, ETH_ALEN);
2575 2576 2577
		}
	}

2578
	return &cmd->header;
2579 2580 2581
}

/*
2582
 * CMD_GET_STAT.
2583
 */
2584
struct mwl8k_cmd_get_stat {
2585 2586
	struct mwl8k_cmd_pkt header;
	__le32 stats[64];
2587
} __packed;
2588 2589 2590 2591 2592 2593

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

2594 2595
static int mwl8k_cmd_get_stat(struct ieee80211_hw *hw,
			      struct ieee80211_low_level_stats *stats)
2596
{
2597
	struct mwl8k_cmd_get_stat *cmd;
2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621 2622 2623
	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;
}

/*
2624
 * CMD_RADIO_CONTROL.
2625
 */
2626
struct mwl8k_cmd_radio_control {
2627 2628 2629 2630
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 control;
	__le16 radio_on;
2631
} __packed;
2632

2633
static int
2634
mwl8k_cmd_radio_control(struct ieee80211_hw *hw, bool enable, bool force)
2635 2636
{
	struct mwl8k_priv *priv = hw->priv;
2637
	struct mwl8k_cmd_radio_control *cmd;
2638 2639
	int rc;

2640
	if (enable == priv->radio_on && !force)
2641 2642 2643 2644 2645 2646 2647 2648 2649
		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);
2650
	cmd->control = cpu_to_le16(priv->radio_short_preamble ? 3 : 1);
2651 2652 2653 2654 2655 2656
	cmd->radio_on = cpu_to_le16(enable ? 0x0001 : 0x0000);

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

	if (!rc)
2657
		priv->radio_on = enable;
2658 2659 2660 2661

	return rc;
}

2662
static int mwl8k_cmd_radio_disable(struct ieee80211_hw *hw)
2663
{
2664
	return mwl8k_cmd_radio_control(hw, 0, 0);
2665 2666
}

2667
static int mwl8k_cmd_radio_enable(struct ieee80211_hw *hw)
2668
{
2669
	return mwl8k_cmd_radio_control(hw, 1, 0);
2670 2671
}

2672 2673 2674
static int
mwl8k_set_radio_preamble(struct ieee80211_hw *hw, bool short_preamble)
{
2675
	struct mwl8k_priv *priv = hw->priv;
2676

2677
	priv->radio_short_preamble = short_preamble;
2678

2679
	return mwl8k_cmd_radio_control(hw, 1, 1);
2680 2681 2682
}

/*
2683
 * CMD_RF_TX_POWER.
2684
 */
2685
#define MWL8K_RF_TX_POWER_LEVEL_TOTAL	8
2686

2687
struct mwl8k_cmd_rf_tx_power {
2688 2689 2690 2691 2692
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 support_level;
	__le16 current_level;
	__le16 reserved;
2693
	__le16 power_level_list[MWL8K_RF_TX_POWER_LEVEL_TOTAL];
2694
} __packed;
2695

2696
static int mwl8k_cmd_rf_tx_power(struct ieee80211_hw *hw, int dBm)
2697
{
2698
	struct mwl8k_cmd_rf_tx_power *cmd;
2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714 2715
	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;
}

2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728
/*
 * 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];
2729
} __packed;
2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774

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

2775 2776 2777 2778 2779 2780 2781
/*
 * CMD_RF_ANTENNA.
 */
struct mwl8k_cmd_rf_antenna {
	struct mwl8k_cmd_pkt header;
	__le16 antenna;
	__le16 mode;
2782
} __packed;
2783 2784 2785 2786 2787 2788 2789 2790 2791 2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805 2806 2807

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

2808 2809 2810 2811 2812 2813 2814 2815 2816
/*
 * CMD_SET_BEACON.
 */
struct mwl8k_cmd_set_beacon {
	struct mwl8k_cmd_pkt header;
	__le16 beacon_len;
	__u8 beacon[0];
};

2817 2818
static int mwl8k_cmd_set_beacon(struct ieee80211_hw *hw,
				struct ieee80211_vif *vif, u8 *beacon, int len)
2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831
{
	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);

2832
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2833 2834 2835 2836 2837
	kfree(cmd);

	return rc;
}

2838 2839 2840 2841 2842
/*
 * CMD_SET_PRE_SCAN.
 */
struct mwl8k_cmd_set_pre_scan {
	struct mwl8k_cmd_pkt header;
2843
} __packed;
2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868

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;
2869
	__u8 bssid[ETH_ALEN];
2870
} __packed;
2871 2872

static int
2873
mwl8k_cmd_set_post_scan(struct ieee80211_hw *hw, const __u8 *mac)
2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884
{
	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;
2885
	memcpy(cmd->bssid, mac, ETH_ALEN);
2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900

	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;
2901
} __packed;
2902 2903

static int mwl8k_cmd_set_rf_channel(struct ieee80211_hw *hw,
2904
				    struct ieee80211_conf *conf)
2905
{
2906
	struct ieee80211_channel *channel = conf->channel;
2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917
	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;
2918

2919
	if (channel->band == IEEE80211_BAND_2GHZ)
2920
		cmd->channel_flags |= cpu_to_le32(0x00000001);
2921 2922
	else if (channel->band == IEEE80211_BAND_5GHZ)
		cmd->channel_flags |= cpu_to_le32(0x00000004);
2923 2924 2925 2926 2927 2928 2929 2930

	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);
2931 2932 2933 2934 2935 2936 2937 2938

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

	return rc;
}

/*
2939
 * CMD_SET_AID.
2940
 */
2941 2942 2943 2944
#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
2945

2946 2947 2948
struct mwl8k_cmd_update_set_aid {
	struct	mwl8k_cmd_pkt header;
	__le16	aid;
2949

2950 2951 2952 2953
	 /* AP's MAC address (BSSID) */
	__u8	bssid[ETH_ALEN];
	__le16	protection_mode;
	__u8	supp_rates[14];
2954
} __packed;
2955

L
Lennert Buytenhek 已提交
2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967
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))
2968
			rates[j++] = mwl8k_rates_24[i].hw_value;
L
Lennert Buytenhek 已提交
2969 2970 2971
	}
}

2972
static int
L
Lennert Buytenhek 已提交
2973 2974
mwl8k_cmd_set_aid(struct ieee80211_hw *hw,
		  struct ieee80211_vif *vif, u32 legacy_rate_mask)
2975
{
2976 2977
	struct mwl8k_cmd_update_set_aid *cmd;
	u16 prot_mode;
2978 2979 2980 2981 2982 2983
	int rc;

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

2984
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_AID);
2985
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2986
	cmd->aid = cpu_to_le16(vif->bss_conf.aid);
2987
	memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN);
2988

2989
	if (vif->bss_conf.use_cts_prot) {
2990 2991
		prot_mode = MWL8K_FRAME_PROT_11G;
	} else {
2992
		switch (vif->bss_conf.ht_operation_mode &
2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005
			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);
3006

L
Lennert Buytenhek 已提交
3007
	legacy_rate_mask_to_array(cmd->supp_rates, legacy_rate_mask);
3008 3009 3010 3011 3012 3013 3014

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

	return rc;
}

3015
/*
3016
 * CMD_SET_RATE.
3017
 */
3018 3019 3020 3021 3022 3023 3024
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];
3025
} __packed;
3026

3027
static int
L
Lennert Buytenhek 已提交
3028
mwl8k_cmd_set_rate(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
3029
		   u32 legacy_rate_mask, u8 *mcs_rates)
3030
{
3031
	struct mwl8k_cmd_set_rate *cmd;
3032 3033 3034 3035 3036 3037
	int rc;

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

3038
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATE);
3039
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
3040
	legacy_rate_mask_to_array(cmd->legacy_rates, legacy_rate_mask);
3041
	memcpy(cmd->mcs_set, mcs_rates, 16);
3042 3043 3044 3045 3046 3047 3048

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

	return rc;
}

3049
/*
3050
 * CMD_FINALIZE_JOIN.
3051
 */
3052 3053 3054
#define MWL8K_FJ_BEACON_MAXLEN	128

struct mwl8k_cmd_finalize_join {
3055
	struct mwl8k_cmd_pkt header;
3056 3057
	__le32 sleep_interval;	/* Number of beacon periods to sleep */
	__u8 beacon_data[MWL8K_FJ_BEACON_MAXLEN];
3058
} __packed;
3059

3060 3061
static int mwl8k_cmd_finalize_join(struct ieee80211_hw *hw, void *frame,
				   int framelen, int dtim)
3062
{
3063 3064 3065
	struct mwl8k_cmd_finalize_join *cmd;
	struct ieee80211_mgmt *payload = frame;
	int payload_len;
3066 3067 3068 3069 3070 3071
	int rc;

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

3072
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_FINALIZE_JOIN);
3073
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
3074 3075 3076 3077 3078 3079 3080 3081 3082
	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);
3083 3084 3085 3086 3087 3088 3089 3090

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

	return rc;
}

/*
3091
 * CMD_SET_RTS_THRESHOLD.
3092
 */
3093
struct mwl8k_cmd_set_rts_threshold {
3094 3095
	struct mwl8k_cmd_pkt header;
	__le16 action;
3096
	__le16 threshold;
3097
} __packed;
3098

L
Lennert Buytenhek 已提交
3099 3100
static int
mwl8k_cmd_set_rts_threshold(struct ieee80211_hw *hw, int rts_thresh)
3101
{
3102
	struct mwl8k_cmd_set_rts_threshold *cmd;
3103 3104 3105 3106 3107 3108
	int rc;

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

3109
	cmd->header.code = cpu_to_le16(MWL8K_CMD_RTS_THRESHOLD);
3110
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
3111 3112
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->threshold = cpu_to_le16(rts_thresh);
3113 3114 3115 3116 3117 3118 3119 3120

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

	return rc;
}

/*
3121
 * CMD_SET_SLOT.
3122
 */
3123
struct mwl8k_cmd_set_slot {
3124 3125
	struct mwl8k_cmd_pkt header;
	__le16 action;
3126
	__u8 short_slot;
3127
} __packed;
3128

3129
static int mwl8k_cmd_set_slot(struct ieee80211_hw *hw, bool short_slot_time)
3130
{
3131
	struct mwl8k_cmd_set_slot *cmd;
3132 3133 3134 3135 3136 3137
	int rc;

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

3138
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_SLOT);
3139
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
3140 3141
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->short_slot = short_slot_time;
3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159 3160

	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;

3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177
	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;
3178

3179 3180
			/* Log exponent of min contention period: 0...15 */
			__u8 log_cw_min;
3181

3182 3183
			/* Adaptive interframe spacing in units of 32us */
			__u8 aifs;
3184

3185 3186 3187 3188
			/* TX queue to configure */
			__u8 txq;
		} sta;
	};
3189
} __packed;
3190 3191 3192 3193 3194 3195 3196 3197 3198 3199

#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
3200 3201 3202
mwl8k_cmd_set_edca_params(struct ieee80211_hw *hw, __u8 qnum,
			  __u16 cw_min, __u16 cw_max,
			  __u8 aifs, __u16 txop)
3203
{
3204
	struct mwl8k_priv *priv = hw->priv;
3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215
	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);
3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226
	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;
	}
3227 3228 3229 3230 3231 3232 3233 3234

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

	return rc;
}

/*
3235
 * CMD_SET_WMM_MODE.
3236
 */
3237
struct mwl8k_cmd_set_wmm_mode {
3238
	struct mwl8k_cmd_pkt header;
3239
	__le16 action;
3240
} __packed;
3241

3242
static int mwl8k_cmd_set_wmm_mode(struct ieee80211_hw *hw, bool enable)
3243
{
3244 3245
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_cmd_set_wmm_mode *cmd;
3246 3247 3248 3249 3250 3251
	int rc;

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

3252
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_WMM_MODE);
3253
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
3254
	cmd->action = cpu_to_le16(!!enable);
3255 3256 3257

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

3259 3260
	if (!rc)
		priv->wmm_enabled = enable;
3261 3262 3263 3264 3265

	return rc;
}

/*
3266
 * CMD_MIMO_CONFIG.
3267
 */
3268 3269 3270 3271 3272
struct mwl8k_cmd_mimo_config {
	struct mwl8k_cmd_pkt header;
	__le32 action;
	__u8 rx_antenna_map;
	__u8 tx_antenna_map;
3273
} __packed;
3274

3275
static int mwl8k_cmd_mimo_config(struct ieee80211_hw *hw, __u8 rx, __u8 tx)
3276
{
3277
	struct mwl8k_cmd_mimo_config *cmd;
3278 3279 3280 3281 3282 3283
	int rc;

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

3284
	cmd->header.code = cpu_to_le16(MWL8K_CMD_MIMO_CONFIG);
3285
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
3286 3287 3288
	cmd->action = cpu_to_le32((u32)MWL8K_CMD_SET);
	cmd->rx_antenna_map = rx;
	cmd->tx_antenna_map = tx;
3289 3290 3291 3292 3293 3294 3295 3296

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

	return rc;
}

/*
3297
 * CMD_USE_FIXED_RATE (STA version).
3298
 */
3299 3300 3301 3302 3303 3304 3305 3306 3307 3308 3309 3310 3311 3312
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;
3313
} __packed;
3314

3315 3316
#define MWL8K_USE_AUTO_RATE	0x0002
#define MWL8K_UCAST_RATE	0
3317

3318
static int mwl8k_cmd_use_fixed_rate_sta(struct ieee80211_hw *hw)
3319
{
3320
	struct mwl8k_cmd_use_fixed_rate_sta *cmd;
3321 3322 3323 3324 3325 3326 3327 3328
	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));
3329 3330
	cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE);
	cmd->rate_type = cpu_to_le32(MWL8K_UCAST_RATE);
3331 3332 3333 3334 3335 3336 3337

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

	return rc;
}

3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354
/*
 * 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;
3355
} __packed;
3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378

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

3379 3380 3381 3382 3383 3384
/*
 * CMD_ENABLE_SNIFFER.
 */
struct mwl8k_cmd_enable_sniffer {
	struct mwl8k_cmd_pkt header;
	__le32 action;
3385
} __packed;
3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417

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];
	};
3418
} __packed;
3419

3420 3421 3422 3423
#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
3424

3425 3426
static int mwl8k_cmd_set_mac_addr(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif, u8 *mac)
3427 3428
{
	struct mwl8k_priv *priv = hw->priv;
3429
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
3430
	struct mwl8k_cmd_set_mac_addr *cmd;
3431
	int mac_type;
3432 3433
	int rc;

3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446
	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;
	}

3447 3448 3449 3450 3451 3452 3453
	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) {
3454
		cmd->mbss.mac_type = cpu_to_le16(mac_type);
3455 3456 3457 3458 3459
		memcpy(cmd->mbss.mac_addr, mac, ETH_ALEN);
	} else {
		memcpy(cmd->mac_addr, mac, ETH_ALEN);
	}

3460
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472
	kfree(cmd);

	return rc;
}

/*
 * CMD_SET_RATEADAPT_MODE.
 */
struct mwl8k_cmd_set_rate_adapt_mode {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 mode;
3473
} __packed;
3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494

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

3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 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
/*
 * CMD_GET_WATCHDOG_BITMAP.
 */
struct mwl8k_cmd_get_watchdog_bitmap {
	struct mwl8k_cmd_pkt header;
	u8	bitmap;
} __packed;

static int mwl8k_cmd_get_watchdog_bitmap(struct ieee80211_hw *hw, u8 *bitmap)
{
	struct mwl8k_cmd_get_watchdog_bitmap *cmd;
	int rc;

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

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

	rc = mwl8k_post_cmd(hw, &cmd->header);
	if (!rc)
		*bitmap = cmd->bitmap;

	kfree(cmd);

	return rc;
}

#define INVALID_BA	0xAA
static void mwl8k_watchdog_ba_events(struct work_struct *work)
{
	int rc;
	u8 bitmap = 0, stream_index;
	struct mwl8k_ampdu_stream *streams;
	struct mwl8k_priv *priv =
		container_of(work, struct mwl8k_priv, watchdog_ba_handle);

	rc = mwl8k_cmd_get_watchdog_bitmap(priv->hw, &bitmap);
	if (rc)
		return;

	if (bitmap == INVALID_BA)
		return;

	/* the bitmap is the hw queue number.  Map it to the ampdu queue. */
	stream_index = bitmap - MWL8K_TX_WMM_QUEUES;

	BUG_ON(stream_index >= priv->num_ampdu_queues);

	streams = &priv->ampdu[stream_index];

	if (streams->state == AMPDU_STREAM_ACTIVE)
		ieee80211_stop_tx_ba_session(streams->sta, streams->tid);

	return;
}


3554 3555 3556 3557 3558 3559
/*
 * CMD_BSS_START.
 */
struct mwl8k_cmd_bss_start {
	struct mwl8k_cmd_pkt header;
	__le32 enable;
3560
} __packed;
3561

3562 3563
static int mwl8k_cmd_bss_start(struct ieee80211_hw *hw,
			       struct ieee80211_vif *vif, int enable)
3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575
{
	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);

3576
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3577 3578 3579 3580 3581
	kfree(cmd);

	return rc;
}

3582 3583 3584 3585 3586 3587 3588 3589 3590 3591
/*
 * CMD_BASTREAM.
 */

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

3592
enum ba_stream_action_type {
3593 3594 3595 3596 3597
	MWL8K_BA_CREATE,
	MWL8K_BA_UPDATE,
	MWL8K_BA_DESTROY,
	MWL8K_BA_FLUSH,
	MWL8K_BA_CHECK,
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


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

3728 3729 3730 3731 3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750
/*
 * 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;
3751
} __packed;
3752 3753 3754 3755 3756 3757 3758 3759 3760

#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;
3761
	u32 rates;
3762 3763 3764 3765 3766 3767 3768 3769 3770 3771 3772 3773
	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);
3774 3775 3776 3777 3778
	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);
3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789
	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;
	}

3790
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3791 3792 3793 3794 3795
	kfree(cmd);

	return rc;
}

3796 3797 3798 3799 3800 3801 3802 3803 3804 3805 3806 3807 3808 3809
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);

3810
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3811 3812 3813 3814 3815
	kfree(cmd);

	return rc;
}

3816 3817 3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830
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);

3831
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3832 3833 3834 3835 3836
	kfree(cmd);

	return rc;
}

3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851
/*
 * 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;

3852
} __packed;
3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871

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];
3872
} __packed;
3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903 3904 3905 3906 3907 3908 3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999

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

Y
Yogesh Ashok Powar 已提交
4000
		keymlen = key->keylen;
4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104
		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;
}

4105 4106 4107
/*
 * CMD_UPDATE_STADB.
 */
4108 4109 4110 4111
struct ewc_ht_info {
	__le16	control1;
	__le16	control2;
	__le16	control3;
4112
} __packed;
4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136 4137 4138 4139 4140

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;
4141
} __packed;
4142

4143 4144 4145 4146 4147 4148 4149 4150 4151 4152 4153 4154 4155
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;
4156
} __packed;
4157

4158 4159 4160 4161 4162 4163 4164
#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 已提交
4165
				      struct ieee80211_vif *vif,
4166
				      struct ieee80211_sta *sta)
4167 4168
{
	struct mwl8k_cmd_update_stadb *cmd;
4169
	struct peer_capability_info *p;
4170
	u32 rates;
4171 4172 4173 4174 4175 4176 4177 4178
	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));
4179
	cmd->action = cpu_to_le32(MWL8K_STA_DB_MODIFY_ENTRY);
4180
	memcpy(cmd->peer_addr, sta->addr, ETH_ALEN);
4181

4182 4183 4184
	p = &cmd->peer_info;
	p->peer_type = MWL8K_PEER_TYPE_ACCESSPOINT;
	p->basic_caps = cpu_to_le16(vif->bss_conf.assoc_capability);
4185
	p->ht_support = sta->ht_cap.ht_supported;
4186
	p->ht_caps = cpu_to_le16(sta->ht_cap.cap);
4187 4188
	p->extended_ht_caps = (sta->ht_cap.ampdu_factor & 3) |
		((sta->ht_cap.ampdu_density & 7) << 2);
4189 4190 4191 4192 4193
	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);
4194
	memcpy(p->ht_rates, sta->ht_cap.mcs.rx_mask, 16);
4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216
	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);
4217
	memcpy(cmd->peer_addr, addr, ETH_ALEN);
4218

4219
	rc = mwl8k_post_cmd(hw, &cmd->header);
4220 4221 4222 4223 4224
	kfree(cmd);

	return rc;
}

4225 4226 4227 4228 4229 4230 4231 4232 4233 4234 4235 4236 4237 4238

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

4239 4240 4241 4242 4243
	if (status & MWL8K_A2H_INT_TX_DONE) {
		status &= ~MWL8K_A2H_INT_TX_DONE;
		tasklet_schedule(&priv->poll_tx_task);
	}

4244
	if (status & MWL8K_A2H_INT_RX_READY) {
4245 4246
		status &= ~MWL8K_A2H_INT_RX_READY;
		tasklet_schedule(&priv->poll_rx_task);
4247 4248
	}

4249 4250 4251 4252 4253
	if (status & MWL8K_A2H_INT_BA_WATCHDOG) {
		status &= ~MWL8K_A2H_INT_BA_WATCHDOG;
		ieee80211_queue_work(hw, &priv->watchdog_ba_handle);
	}

4254 4255 4256
	if (status)
		iowrite32(~status, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);

4257
	if (status & MWL8K_A2H_INT_OPC_DONE) {
4258
		if (priv->hostcmd_wait != NULL)
4259 4260 4261 4262
			complete(priv->hostcmd_wait);
	}

	if (status & MWL8K_A2H_INT_QUEUE_EMPTY) {
4263
		if (!mutex_is_locked(&priv->fw_mutex) &&
4264
		    priv->radio_on && priv->pending_tx_pkts)
4265
			mwl8k_tx_start(priv);
4266 4267 4268 4269 4270
	}

	return IRQ_HANDLED;
}

4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281
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);

4282
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299
		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);
	}
}

4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317
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);
	}
}

4318 4319 4320 4321

/*
 * Core driver operations.
 */
4322
static void mwl8k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
4323 4324 4325 4326
{
	struct mwl8k_priv *priv = hw->priv;
	int index = skb_get_queue_mapping(skb);

4327
	if (!priv->radio_on) {
4328 4329
		wiphy_debug(hw->wiphy,
			    "dropped TX frame since radio disabled\n");
4330
		dev_kfree_skb(skb);
4331
		return;
4332 4333
	}

4334
	mwl8k_txq_xmit(hw, index, skb);
4335 4336 4337 4338 4339 4340 4341
}

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

4342
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
4343 4344
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
4345
		priv->irq = -1;
4346
		wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
4347
		return -EIO;
4348
	}
4349
	priv->irq = priv->pdev->irq;
4350

4351
	/* Enable TX reclaim and RX tasklets.  */
4352
	tasklet_enable(&priv->poll_tx_task);
4353
	tasklet_enable(&priv->poll_rx_task);
4354

4355
	/* Enable interrupts */
4356
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4357 4358
	iowrite32(MWL8K_A2H_EVENTS,
		  priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);
4359

4360 4361
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
4362
		rc = mwl8k_cmd_radio_enable(hw);
4363

4364 4365
		if (!priv->ap_fw) {
			if (!rc)
4366
				rc = mwl8k_cmd_enable_sniffer(hw, 0);
4367

4368 4369 4370 4371 4372 4373 4374
			if (!rc)
				rc = mwl8k_cmd_set_pre_scan(hw);

			if (!rc)
				rc = mwl8k_cmd_set_post_scan(hw,
						"\x00\x00\x00\x00\x00\x00");
		}
4375 4376

		if (!rc)
4377
			rc = mwl8k_cmd_set_rateadapt_mode(hw, 0);
4378

4379
		if (!rc)
4380
			rc = mwl8k_cmd_set_wmm_mode(hw, 0);
4381

4382 4383 4384 4385 4386 4387
		mwl8k_fw_unlock(hw);
	}

	if (rc) {
		iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
		free_irq(priv->pdev->irq, hw);
4388
		priv->irq = -1;
4389
		tasklet_disable(&priv->poll_tx_task);
4390
		tasklet_disable(&priv->poll_rx_task);
4391
	}
4392 4393 4394 4395 4396 4397 4398 4399 4400

	return rc;
}

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

4401
	mwl8k_cmd_radio_disable(hw);
4402 4403 4404 4405 4406

	ieee80211_stop_queues(hw);

	/* Disable interrupts */
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4407 4408 4409 4410
	if (priv->irq != -1) {
		free_irq(priv->pdev->irq, hw);
		priv->irq = -1;
	}
4411 4412 4413

	/* Stop finalize join worker */
	cancel_work_sync(&priv->finalize_join_worker);
4414
	cancel_work_sync(&priv->watchdog_ba_handle);
4415 4416 4417
	if (priv->beacon_skb != NULL)
		dev_kfree_skb(priv->beacon_skb);

4418
	/* Stop TX reclaim and RX tasklets.  */
4419
	tasklet_disable(&priv->poll_tx_task);
4420
	tasklet_disable(&priv->poll_rx_task);
4421 4422

	/* Return all skbs to mac80211 */
4423
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
4424
		mwl8k_txq_reclaim(hw, i, INT_MAX, 1);
4425 4426
}

4427 4428
static int mwl8k_reload_firmware(struct ieee80211_hw *hw, char *fw_image);

4429
static int mwl8k_add_interface(struct ieee80211_hw *hw,
4430
			       struct ieee80211_vif *vif)
4431 4432 4433
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_vif *mwl8k_vif;
4434
	u32 macids_supported;
4435 4436
	int macid, rc;
	struct mwl8k_device_info *di;
4437

4438 4439 4440
	/*
	 * Reject interface creation if sniffer mode is active, as
	 * STA operation is mutually exclusive with hardware sniffer
4441
	 * mode.  (Sniffer mode is only used on STA firmware.)
4442 4443
	 */
	if (priv->sniffer_enabled) {
4444 4445
		wiphy_info(hw->wiphy,
			   "unable to create STA interface because sniffer mode is enabled\n");
4446 4447 4448
		return -EINVAL;
	}

4449
	di = priv->device_info;
4450 4451
	switch (vif->type) {
	case NL80211_IFTYPE_AP:
4452 4453 4454 4455 4456 4457 4458 4459
		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;
		}
4460 4461 4462
		macids_supported = priv->ap_macids_supported;
		break;
	case NL80211_IFTYPE_STATION:
4463 4464 4465 4466 4467 4468 4469 4470
		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;
		}
4471 4472 4473 4474 4475 4476 4477 4478 4479 4480
		macids_supported = priv->sta_macids_supported;
		break;
	default:
		return -EINVAL;
	}

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

4481
	/* Setup driver private area. */
4482
	mwl8k_vif = MWL8K_VIF(vif);
4483
	memset(mwl8k_vif, 0, sizeof(*mwl8k_vif));
4484
	mwl8k_vif->vif = vif;
4485
	mwl8k_vif->macid = macid;
4486
	mwl8k_vif->seqno = 0;
4487 4488
	memcpy(mwl8k_vif->bssid, vif->addr, ETH_ALEN);
	mwl8k_vif->is_hw_crypto_enabled = false;
4489

4490 4491 4492 4493 4494 4495
	/* 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);

4496
	priv->macids_used |= 1 << mwl8k_vif->macid;
4497
	list_add_tail(&mwl8k_vif->list, &priv->vif_list);
4498 4499 4500 4501 4502

	return 0;
}

static void mwl8k_remove_interface(struct ieee80211_hw *hw,
4503
				   struct ieee80211_vif *vif)
4504 4505
{
	struct mwl8k_priv *priv = hw->priv;
4506
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
4507

4508 4509 4510
	if (priv->ap_fw)
		mwl8k_cmd_set_new_stn_del(hw, vif, vif->addr);

4511
	mwl8k_cmd_set_mac_addr(hw, vif, "\x00\x00\x00\x00\x00\x00");
4512

4513
	priv->macids_used &= ~(1 << mwl8k_vif->macid);
4514
	list_del(&mwl8k_vif->list);
4515 4516
}

4517
static int mwl8k_config(struct ieee80211_hw *hw, u32 changed)
4518 4519 4520
{
	struct ieee80211_conf *conf = &hw->conf;
	struct mwl8k_priv *priv = hw->priv;
4521
	int rc;
4522

L
Lennert Buytenhek 已提交
4523
	if (conf->flags & IEEE80211_CONF_IDLE) {
4524
		mwl8k_cmd_radio_disable(hw);
4525
		return 0;
L
Lennert Buytenhek 已提交
4526 4527
	}

4528 4529 4530
	rc = mwl8k_fw_lock(hw);
	if (rc)
		return rc;
4531

4532
	rc = mwl8k_cmd_radio_enable(hw);
4533 4534
	if (rc)
		goto out;
4535

4536
	rc = mwl8k_cmd_set_rf_channel(hw, conf);
4537 4538 4539
	if (rc)
		goto out;

4540 4541 4542
	if (conf->power_level > 18)
		conf->power_level = 18;

4543
	if (priv->ap_fw) {
4544 4545 4546 4547 4548 4549

		if (conf->flags & IEEE80211_CONF_CHANGE_POWER) {
			rc = mwl8k_cmd_tx_power(hw, conf, conf->power_level);
			if (rc)
				goto out;
		}
4550

4551 4552 4553 4554 4555 4556 4557
		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");

4558
	} else {
4559 4560 4561
		rc = mwl8k_cmd_rf_tx_power(hw, conf->power_level);
		if (rc)
			goto out;
4562 4563
		rc = mwl8k_cmd_mimo_config(hw, 0x7, 0x7);
	}
4564

4565 4566
out:
	mwl8k_fw_unlock(hw);
4567

4568
	return rc;
4569 4570
}

4571 4572 4573
static void
mwl8k_bss_info_changed_sta(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			   struct ieee80211_bss_conf *info, u32 changed)
4574 4575
{
	struct mwl8k_priv *priv = hw->priv;
4576
	u32 ap_legacy_rates = 0;
4577
	u8 ap_mcs_rates[16];
4578 4579
	int rc;

4580
	if (mwl8k_fw_lock(hw))
4581
		return;
4582

4583 4584 4585 4586 4587
	/*
	 * 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;
4588

4589
	/*
4590
	 * Get the AP's legacy and MCS rates.
4591
	 */
4592
	if (vif->bss_conf.assoc) {
L
Lennert Buytenhek 已提交
4593
		struct ieee80211_sta *ap;
4594

L
Lennert Buytenhek 已提交
4595 4596
		rcu_read_lock();

4597 4598 4599
		ap = ieee80211_find_sta(vif, vif->bss_conf.bssid);
		if (ap == NULL) {
			rcu_read_unlock();
L
Lennert Buytenhek 已提交
4600
			goto out;
4601 4602
		}

4603 4604 4605 4606 4607 4608
		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;
		}
4609
		memcpy(ap_mcs_rates, ap->ht_cap.mcs.rx_mask, 16);
4610 4611 4612

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

4614
	if ((changed & BSS_CHANGED_ASSOC) && vif->bss_conf.assoc) {
4615
		rc = mwl8k_cmd_set_rate(hw, vif, ap_legacy_rates, ap_mcs_rates);
4616 4617
		if (rc)
			goto out;
4618

4619
		rc = mwl8k_cmd_use_fixed_rate_sta(hw);
4620 4621
		if (rc)
			goto out;
4622
	}
4623

4624
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4625 4626
		rc = mwl8k_set_radio_preamble(hw,
				vif->bss_conf.use_short_preamble);
4627 4628
		if (rc)
			goto out;
4629
	}
4630

4631
	if (changed & BSS_CHANGED_ERP_SLOT) {
4632
		rc = mwl8k_cmd_set_slot(hw, vif->bss_conf.use_short_slot);
4633 4634
		if (rc)
			goto out;
4635
	}
4636

4637 4638 4639
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_ERP_CTS_PROT |
			BSS_CHANGED_HT))) {
4640
		rc = mwl8k_cmd_set_aid(hw, vif, ap_legacy_rates);
4641 4642
		if (rc)
			goto out;
4643
	}
4644

4645 4646
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_BEACON_INT))) {
4647 4648 4649 4650
		/*
		 * Finalize the join.  Tell rx handler to process
		 * next beacon from our BSSID.
		 */
4651
		memcpy(priv->capture_bssid, vif->bss_conf.bssid, ETH_ALEN);
4652 4653 4654
		priv->capture_beacon = true;
	}

4655 4656
out:
	mwl8k_fw_unlock(hw);
4657 4658
}

4659 4660 4661 4662 4663 4664 4665 4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684
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);
4685 4686 4687 4688 4689 4690 4691
		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;
4692 4693 4694 4695 4696 4697 4698 4699 4700

		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) {
4701
			mwl8k_cmd_set_beacon(hw, vif, skb->data, skb->len);
4702 4703 4704 4705 4706
			kfree_skb(skb);
		}
	}

	if (changed & BSS_CHANGED_BEACON_ENABLED)
4707
		mwl8k_cmd_bss_start(hw, vif, info->enable_beacon);
4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724

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

4725
static u64 mwl8k_prepare_multicast(struct ieee80211_hw *hw,
4726
				   struct netdev_hw_addr_list *mc_list)
4727 4728 4729
{
	struct mwl8k_cmd_pkt *cmd;

L
Lennert Buytenhek 已提交
4730 4731 4732 4733 4734 4735 4736
	/*
	 * 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().
	 */
4737
	cmd = __mwl8k_cmd_mac_multicast_adr(hw, 0, mc_list);
4738 4739 4740 4741

	return (unsigned long)cmd;
}

4742 4743 4744 4745 4746 4747 4748 4749 4750 4751 4752 4753
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.
	 */
4754
	if (!list_empty(&priv->vif_list)) {
4755
		if (net_ratelimit())
4756 4757
			wiphy_info(hw->wiphy,
				   "not enabling sniffer mode because STA interface is active\n");
4758 4759 4760 4761
		return 0;
	}

	if (!priv->sniffer_enabled) {
4762
		if (mwl8k_cmd_enable_sniffer(hw, 1))
4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773
			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;
}

4774 4775 4776 4777 4778 4779 4780 4781
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;
}

4782 4783 4784 4785 4786 4787
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;
4788 4789
	struct mwl8k_cmd_pkt *cmd = (void *)(unsigned long)multicast;

4790 4791 4792 4793 4794 4795 4796 4797 4798 4799
	/*
	 * 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;
	}

4800 4801 4802 4803 4804 4805 4806 4807 4808
	/*
	 * 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;
	}
4809

4810
	/* Clear unsupported feature flags */
L
Lennert Buytenhek 已提交
4811
	*total_flags &= FIF_ALLMULTI | FIF_BCN_PRBRESP_PROMISC;
4812

4813 4814
	if (mwl8k_fw_lock(hw)) {
		kfree(cmd);
4815
		return;
4816
	}
4817

4818
	if (priv->sniffer_enabled) {
4819
		mwl8k_cmd_enable_sniffer(hw, 0);
4820 4821 4822
		priv->sniffer_enabled = false;
	}

4823
	if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
4824 4825 4826 4827
		if (*total_flags & FIF_BCN_PRBRESP_PROMISC) {
			/*
			 * Disable the BSS filter.
			 */
4828
			mwl8k_cmd_set_pre_scan(hw);
4829
		} else {
4830
			struct mwl8k_vif *mwl8k_vif;
4831
			const u8 *bssid;
4832

4833 4834 4835 4836 4837 4838 4839 4840
			/*
			 * 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).
			 */
4841 4842 4843 4844 4845
			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";
4846

4847
			mwl8k_cmd_set_post_scan(hw, bssid);
4848 4849 4850
		}
	}

L
Lennert Buytenhek 已提交
4851 4852 4853 4854 4855 4856 4857 4858
	/*
	 * 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);
4859
		cmd = __mwl8k_cmd_mac_multicast_adr(hw, 1, NULL);
L
Lennert Buytenhek 已提交
4860 4861 4862 4863 4864
	}

	if (cmd != NULL) {
		mwl8k_post_cmd(hw, cmd);
		kfree(cmd);
4865
	}
4866

4867
	mwl8k_fw_unlock(hw);
4868 4869 4870 4871
}

static int mwl8k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
{
L
Lennert Buytenhek 已提交
4872
	return mwl8k_cmd_set_rts_threshold(hw, value);
4873 4874
}

4875 4876 4877
static int mwl8k_sta_remove(struct ieee80211_hw *hw,
			    struct ieee80211_vif *vif,
			    struct ieee80211_sta *sta)
4878 4879 4880
{
	struct mwl8k_priv *priv = hw->priv;

4881 4882 4883 4884
	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);
4885 4886
}

4887 4888 4889
static int mwl8k_sta_add(struct ieee80211_hw *hw,
			 struct ieee80211_vif *vif,
			 struct ieee80211_sta *sta)
4890 4891
{
	struct mwl8k_priv *priv = hw->priv;
4892
	int ret;
4893 4894 4895
	int i;
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
	struct ieee80211_key_conf *key;
4896

4897 4898 4899 4900
	if (!priv->ap_fw) {
		ret = mwl8k_cmd_update_stadb_add(hw, vif, sta);
		if (ret >= 0) {
			MWL8K_STA(sta)->peer_id = ret;
4901 4902
			if (sta->ht_cap.ht_supported)
				MWL8K_STA(sta)->is_ampdu_allowed = true;
4903
			ret = 0;
4904
		}
4905

4906 4907
	} else {
		ret = mwl8k_cmd_set_new_stn_add(hw, vif, sta);
4908
	}
4909

4910 4911 4912 4913 4914
	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);
	}
4915
	return ret;
4916 4917
}

4918 4919 4920
static int mwl8k_conf_tx(struct ieee80211_hw *hw, u16 queue,
			 const struct ieee80211_tx_queue_params *params)
{
4921
	struct mwl8k_priv *priv = hw->priv;
4922 4923
	int rc;

4924 4925
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
4926
		BUG_ON(queue > MWL8K_TX_WMM_QUEUES - 1);
4927 4928
		memcpy(&priv->wmm_params[queue], params, sizeof(*params));

4929
		if (!priv->wmm_enabled)
4930
			rc = mwl8k_cmd_set_wmm_mode(hw, 1);
4931

4932
		if (!rc) {
4933
			int q = MWL8K_TX_WMM_QUEUES - 1 - queue;
4934
			rc = mwl8k_cmd_set_edca_params(hw, q,
4935 4936 4937 4938
						       params->cw_min,
						       params->cw_max,
						       params->aifs,
						       params->txop);
4939
		}
4940 4941

		mwl8k_fw_unlock(hw);
4942
	}
4943

4944 4945 4946 4947 4948 4949
	return rc;
}

static int mwl8k_get_stats(struct ieee80211_hw *hw,
			   struct ieee80211_low_level_stats *stats)
{
4950
	return mwl8k_cmd_get_stat(hw, stats);
4951 4952
}

4953 4954 4955 4956 4957 4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968
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;
}

N
Nishant Sarmukadam 已提交
4969 4970
#define MAX_AMPDU_ATTEMPTS 5

4971 4972 4973
static int
mwl8k_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		   enum ieee80211_ampdu_mlme_action action,
4974 4975
		   struct ieee80211_sta *sta, u16 tid, u16 *ssn,
		   u8 buf_size)
4976
{
N
Nishant Sarmukadam 已提交
4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988

	int i, rc = 0;
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_ampdu_stream *stream;
	u8 *addr = sta->addr;

	if (!(hw->flags & IEEE80211_HW_AMPDU_AGGREGATION))
		return -ENOTSUPP;

	spin_lock(&priv->stream_lock);
	stream = mwl8k_lookup_stream(hw, addr, tid);

4989 4990 4991
	switch (action) {
	case IEEE80211_AMPDU_RX_START:
	case IEEE80211_AMPDU_RX_STOP:
N
Nishant Sarmukadam 已提交
4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009 5010 5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047 5048 5049 5050 5051 5052 5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070 5071 5072 5073 5074
		break;
	case IEEE80211_AMPDU_TX_START:
		/* By the time we get here the hw queues may contain outgoing
		 * packets for this RA/TID that are not part of this BA
		 * session.  The hw will assign sequence numbers to these
		 * packets as they go out.  So if we query the hw for its next
		 * sequence number and use that for the SSN here, it may end up
		 * being wrong, which will lead to sequence number mismatch at
		 * the recipient.  To avoid this, we reset the sequence number
		 * to O for the first MPDU in this BA stream.
		 */
		*ssn = 0;
		if (stream == NULL) {
			/* This means that somebody outside this driver called
			 * ieee80211_start_tx_ba_session.  This is unexpected
			 * because we do our own rate control.  Just warn and
			 * move on.
			 */
			wiphy_warn(hw->wiphy, "Unexpected call to %s.  "
				   "Proceeding anyway.\n", __func__);
			stream = mwl8k_add_stream(hw, sta, tid);
		}
		if (stream == NULL) {
			wiphy_debug(hw->wiphy, "no free AMPDU streams\n");
			rc = -EBUSY;
			break;
		}
		stream->state = AMPDU_STREAM_IN_PROGRESS;

		/* Release the lock before we do the time consuming stuff */
		spin_unlock(&priv->stream_lock);
		for (i = 0; i < MAX_AMPDU_ATTEMPTS; i++) {
			rc = mwl8k_check_ba(hw, stream);

			if (!rc)
				break;
			/*
			 * HW queues take time to be flushed, give them
			 * sufficient time
			 */

			msleep(1000);
		}
		spin_lock(&priv->stream_lock);
		if (rc) {
			wiphy_err(hw->wiphy, "Stream for tid %d busy after %d"
				" attempts\n", tid, MAX_AMPDU_ATTEMPTS);
			mwl8k_remove_stream(hw, stream);
			rc = -EBUSY;
			break;
		}
		ieee80211_start_tx_ba_cb_irqsafe(vif, addr, tid);
		break;
	case IEEE80211_AMPDU_TX_STOP:
		if (stream == NULL)
			break;
		if (stream->state == AMPDU_STREAM_ACTIVE) {
			spin_unlock(&priv->stream_lock);
			mwl8k_destroy_ba(hw, stream);
			spin_lock(&priv->stream_lock);
		}
		mwl8k_remove_stream(hw, stream);
		ieee80211_stop_tx_ba_cb_irqsafe(vif, addr, tid);
		break;
	case IEEE80211_AMPDU_TX_OPERATIONAL:
		BUG_ON(stream == NULL);
		BUG_ON(stream->state != AMPDU_STREAM_IN_PROGRESS);
		spin_unlock(&priv->stream_lock);
		rc = mwl8k_create_ba(hw, stream, buf_size);
		spin_lock(&priv->stream_lock);
		if (!rc)
			stream->state = AMPDU_STREAM_ACTIVE;
		else {
			spin_unlock(&priv->stream_lock);
			mwl8k_destroy_ba(hw, stream);
			spin_lock(&priv->stream_lock);
			wiphy_debug(hw->wiphy,
				"Failed adding stream for sta %pM tid %d\n",
				addr, tid);
			mwl8k_remove_stream(hw, stream);
		}
		break;

5075
	default:
N
Nishant Sarmukadam 已提交
5076
		rc = -ENOTSUPP;
5077
	}
N
Nishant Sarmukadam 已提交
5078 5079 5080

	spin_unlock(&priv->stream_lock);
	return rc;
5081 5082
}

5083 5084 5085 5086 5087 5088 5089 5090
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,
5091
	.prepare_multicast	= mwl8k_prepare_multicast,
5092
	.configure_filter	= mwl8k_configure_filter,
5093
	.set_key                = mwl8k_set_key,
5094
	.set_rts_threshold	= mwl8k_set_rts_threshold,
5095 5096
	.sta_add		= mwl8k_sta_add,
	.sta_remove		= mwl8k_sta_remove,
5097 5098
	.conf_tx		= mwl8k_conf_tx,
	.get_stats		= mwl8k_get_stats,
5099
	.get_survey		= mwl8k_get_survey,
5100
	.ampdu_action		= mwl8k_ampdu_action,
5101 5102 5103 5104 5105 5106 5107
};

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;
5108 5109 5110 5111 5112 5113 5114 5115
	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];
5116

5117
	mwl8k_cmd_finalize_join(priv->hw, skb->data, skb->len, dtim_period);
5118

5119
	dev_kfree_skb(skb);
5120 5121 5122
	priv->beacon_skb = NULL;
}

5123
enum {
5124 5125
	MWL8363 = 0,
	MWL8687,
5126
	MWL8366,
5127 5128
};

5129
#define MWL8K_8366_AP_FW_API 2
5130 5131 5132
#define _MWL8K_8366_AP_FW(api) "mwl8k/fmimage_8366_ap-" #api ".fw"
#define MWL8K_8366_AP_FW(api) _MWL8K_8366_AP_FW(api)

5133
static struct mwl8k_device_info mwl8k_info_tbl[] __devinitdata = {
5134 5135 5136
	[MWL8363] = {
		.part_name	= "88w8363",
		.helper_image	= "mwl8k/helper_8363.fw",
5137
		.fw_image_sta	= "mwl8k/fmimage_8363.fw",
5138
	},
5139
	[MWL8687] = {
5140 5141
		.part_name	= "88w8687",
		.helper_image	= "mwl8k/helper_8687.fw",
5142
		.fw_image_sta	= "mwl8k/fmimage_8687.fw",
5143
	},
5144
	[MWL8366] = {
5145 5146
		.part_name	= "88w8366",
		.helper_image	= "mwl8k/helper_8366.fw",
5147
		.fw_image_sta	= "mwl8k/fmimage_8366.fw",
5148 5149
		.fw_image_ap	= MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API),
		.fw_api_ap	= MWL8K_8366_AP_FW_API,
5150
		.ap_rxd_ops	= &rxd_8366_ap_ops,
5151
	},
5152 5153
};

5154 5155 5156 5157 5158 5159
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");
5160
MODULE_FIRMWARE(MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API));
5161

5162
static DEFINE_PCI_DEVICE_TABLE(mwl8k_pci_id_table) = {
5163
	{ PCI_VDEVICE(MARVELL, 0x2a0a), .driver_data = MWL8363, },
5164 5165
	{ PCI_VDEVICE(MARVELL, 0x2a0c), .driver_data = MWL8363, },
	{ PCI_VDEVICE(MARVELL, 0x2a24), .driver_data = MWL8363, },
5166 5167 5168
	{ PCI_VDEVICE(MARVELL, 0x2a2b), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a30), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a40), .driver_data = MWL8366, },
5169
	{ PCI_VDEVICE(MARVELL, 0x2a43), .driver_data = MWL8366, },
5170
	{ },
5171 5172 5173
};
MODULE_DEVICE_TABLE(pci, mwl8k_pci_id_table);

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 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264 5265 5266
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)
5267
{
5268
	struct mwl8k_priv *priv = hw->priv;
5269
	int rc;
5270 5271 5272 5273 5274

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

	/* Ask userland hotplug daemon for the device firmware */
5275
	rc = mwl8k_request_firmware(priv, fw_image, nowait);
5276
	if (rc) {
5277
		wiphy_err(hw->wiphy, "Firmware files not found\n");
5278
		return rc;
5279 5280
	}

5281 5282 5283
	if (nowait)
		return rc;

5284 5285
	/* Load firmware into hardware */
	rc = mwl8k_load_firmware(hw);
5286
	if (rc)
5287
		wiphy_err(hw->wiphy, "Cannot start firmware\n");
5288 5289 5290 5291

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

5292 5293 5294
	return rc;
}

5295 5296 5297 5298 5299 5300
static int mwl8k_init_txqs(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;
	int rc = 0;
	int i;

5301
	for (i = 0; i < mwl8k_tx_queues(priv); i++) {
5302 5303 5304 5305 5306 5307 5308 5309 5310 5311
		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;
}

5312 5313 5314 5315 5316 5317
/* 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;
5318

5319
	if (priv->ap_fw) {
5320
		priv->rxd_ops = priv->device_info->ap_rxd_ops;
5321
		if (priv->rxd_ops == NULL) {
5322 5323
			wiphy_err(hw->wiphy,
				  "Driver does not have AP firmware image support for this hardware\n");
5324 5325 5326
			goto err_stop_firmware;
		}
	} else {
5327
		priv->rxd_ops = &rxd_sta_ops;
5328
	}
5329 5330 5331 5332 5333

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

5334 5335
	rc = mwl8k_rxq_init(hw, 0);
	if (rc)
5336
		goto err_stop_firmware;
5337 5338
	rxq_refill(hw, 0, INT_MAX);

5339 5340 5341 5342 5343 5344
	/* 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.
	 */
5345
	priv->num_ampdu_queues = 0;
5346 5347
	if (!priv->ap_fw) {
		rc = mwl8k_init_txqs(hw);
5348 5349 5350 5351 5352
		if (rc)
			goto err_free_queues;
	}

	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
5353
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
5354 5355
	iowrite32(MWL8K_A2H_INT_TX_DONE|MWL8K_A2H_INT_RX_READY|
		  MWL8K_A2H_INT_BA_WATCHDOG,
5356
		  priv->regs + MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL);
5357 5358
	iowrite32(MWL8K_A2H_INT_OPC_DONE,
		  priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);
5359

5360
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
5361 5362
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
5363
		wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
5364 5365 5366
		goto err_free_queues;
	}

5367 5368
	memset(priv->ampdu, 0, sizeof(priv->ampdu));

5369 5370
	/*
	 * Temporarily enable interrupts.  Initial firmware host
L
Lennert Buytenhek 已提交
5371
	 * commands use interrupts and avoid polling.  Disable
5372 5373
	 * interrupts when done.
	 */
5374
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
5375 5376

	/* Get config data, mac addrs etc */
5377 5378
	if (priv->ap_fw) {
		rc = mwl8k_cmd_get_hw_spec_ap(hw);
5379 5380
		if (!rc)
			rc = mwl8k_init_txqs(hw);
5381 5382 5383 5384 5385
		if (!rc)
			rc = mwl8k_cmd_set_hw_spec(hw);
	} else {
		rc = mwl8k_cmd_get_hw_spec_sta(hw);
	}
5386
	if (rc) {
5387
		wiphy_err(hw->wiphy, "Cannot initialise firmware\n");
5388
		goto err_free_irq;
5389 5390 5391
	}

	/* Turn radio off */
5392
	rc = mwl8k_cmd_radio_disable(hw);
5393
	if (rc) {
5394
		wiphy_err(hw->wiphy, "Cannot disable\n");
5395
		goto err_free_irq;
5396 5397
	}

5398
	/* Clear MAC address */
5399
	rc = mwl8k_cmd_set_mac_addr(hw, NULL, "\x00\x00\x00\x00\x00\x00");
5400
	if (rc) {
5401
		wiphy_err(hw->wiphy, "Cannot clear MAC address\n");
5402
		goto err_free_irq;
5403 5404
	}

5405 5406 5407 5408
	/* Disable interrupts */
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
	free_irq(priv->pdev->irq, hw);

5409 5410 5411 5412 5413 5414
	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);
5415 5416 5417 5418 5419 5420 5421 5422

	return 0;

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

err_free_queues:
5423
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5424 5425 5426
		mwl8k_txq_deinit(hw, i);
	mwl8k_rxq_deinit(hw, 0);

5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444
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);

5445
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5446 5447
		mwl8k_txq_deinit(hw, i);

5448
	rc = mwl8k_init_firmware(hw, fw_image, false);
5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463
	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;

5464
	for (i = 0; i < MWL8K_TX_WMM_QUEUES; i++) {
5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481
		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;

5482 5483 5484 5485 5486 5487 5488
	rc = mwl8k_load_firmware(hw);
	mwl8k_release_firmware(priv);
	if (rc) {
		wiphy_err(hw->wiphy, "Cannot start firmware\n");
		return rc;
	}

5489 5490 5491 5492 5493 5494 5495
	/*
	 * 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);

5496 5497
	hw->extra_tx_headroom -= priv->ap_fw ? REDUCED_TX_HEADROOM : 0;

5498 5499
	hw->channel_change_time = 10;

5500
	hw->queues = MWL8K_TX_WMM_QUEUES;
5501 5502

	/* Set rssi values to dBm */
5503
	hw->flags |= IEEE80211_HW_SIGNAL_DBM | IEEE80211_HW_HAS_RATE_CONTROL;
5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515
	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);
5516 5517
	/* Handle watchdog ba events */
	INIT_WORK(&priv->watchdog_ba_handle, mwl8k_watchdog_ba_events);
5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536

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

5537 5538
	spin_lock_init(&priv->stream_lock);

5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552 5553 5554 5555 5556 5557 5558 5559
	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:
5560
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5561 5562 5563
		mwl8k_txq_deinit(hw, i);
	mwl8k_rxq_deinit(hw, 0);

5564
err_free_cookie:
5565 5566 5567 5568
	if (priv->cookie != NULL)
		pci_free_consistent(priv->pdev, 4,
				priv->cookie, priv->cookie_dma);

5569 5570 5571 5572 5573 5574 5575 5576
	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;
5577
	struct mwl8k_device_info *di;
5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637
	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;
		}
	}

5638
	/*
5639 5640 5641
	 * 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.
5642
	 */
5643
	init_completion(&priv->firmware_loading_complete);
5644
	di = priv->device_info;
5645 5646 5647 5648 5649 5650 5651
	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) {
5652
		printk(KERN_WARNING "AP fw is unavailable.  Using STA fw.");
5653
		priv->fw_pref = di->fw_image_sta;
5654 5655
	} else if (!ap_mode_default && !di->fw_image_sta && di->fw_image_ap) {
		printk(KERN_WARNING "STA fw is unavailable.  Using AP fw.");
5656 5657 5658
		priv->fw_pref = di->fw_image_ap;
	}
	rc = mwl8k_init_firmware(hw, priv->fw_pref, true);
5659 5660
	if (rc)
		goto err_stop_firmware;
5661
	return rc;
5662

5663 5664 5665 5666
err_stop_firmware:
	mwl8k_hw_reset(priv);

err_iounmap:
5667 5668 5669
	if (priv->regs != NULL)
		pci_iounmap(pdev, priv->regs);

L
Lennert Buytenhek 已提交
5670 5671 5672
	if (priv->sram != NULL)
		pci_iounmap(pdev, priv->sram);

5673 5674 5675 5676 5677
	pci_set_drvdata(pdev, NULL);
	ieee80211_free_hw(hw);

err_free_reg:
	pci_release_regions(pdev);
5678 5679

err_disable_device:
5680 5681 5682 5683 5684
	pci_disable_device(pdev);

	return rc;
}

5685
static void __devexit mwl8k_shutdown(struct pci_dev *pdev)
5686 5687 5688 5689
{
	printk(KERN_ERR "===>%s(%u)\n", __func__, __LINE__);
}

5690
static void __devexit mwl8k_remove(struct pci_dev *pdev)
5691 5692 5693 5694 5695 5696 5697 5698 5699
{
	struct ieee80211_hw *hw = pci_get_drvdata(pdev);
	struct mwl8k_priv *priv;
	int i;

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

5700 5701 5702 5703 5704 5705 5706
	wait_for_completion(&priv->firmware_loading_complete);

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

5707 5708
	ieee80211_stop_queues(hw);

5709 5710
	ieee80211_unregister_hw(hw);

5711
	/* Remove TX reclaim and RX tasklets.  */
5712
	tasklet_kill(&priv->poll_tx_task);
5713
	tasklet_kill(&priv->poll_rx_task);
5714 5715 5716 5717 5718

	/* Stop hardware */
	mwl8k_hw_reset(priv);

	/* Return all skbs to mac80211 */
5719
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5720
		mwl8k_txq_reclaim(hw, i, INT_MAX, 1);
5721

5722
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5723 5724 5725 5726
		mwl8k_txq_deinit(hw, i);

	mwl8k_rxq_deinit(hw, 0);

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

5729
unmap:
5730
	pci_iounmap(pdev, priv->regs);
L
Lennert Buytenhek 已提交
5731
	pci_iounmap(pdev, priv->sram);
5732 5733 5734 5735 5736 5737 5738 5739
	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,
5740
	.id_table	= mwl8k_pci_id_table,
5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757
	.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 已提交
5758 5759 5760 5761 5762

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