mwl8k.c 137.7 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
static void
mwl8k_add_dma_header(struct sk_buff *skb, int tail_pad)
786 787
{
	struct ieee80211_hdr *wh;
788
	int hdrlen;
789
	int reqd_hdrlen;
790 791
	struct mwl8k_dma_data *tr;

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

800
	hdrlen = ieee80211_hdrlen(wh->frame_control);
801 802 803 804
	reqd_hdrlen = sizeof(*tr);

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

806
	if (ieee80211_is_data_qos(wh->frame_control))
807
		hdrlen -= IEEE80211_QOS_CTL_LEN;
808 809 810 811

	tr = (struct mwl8k_dma_data *)skb->data;
	if (wh != &tr->wh)
		memmove(&tr->wh, wh, hdrlen);
812 813
	if (hdrlen != sizeof(tr->wh))
		memset(((void *)&tr->wh) + hdrlen, 0, sizeof(tr->wh) - hdrlen);
814 815 816 817 818 819

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

823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840
static void mwl8k_encapsulate_tx_frame(struct sk_buff *skb)
{
	struct ieee80211_hdr *wh;
	struct ieee80211_tx_info *tx_info;
	struct ieee80211_key_conf *key_conf;
	int data_pad;

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

	tx_info = IEEE80211_SKB_CB(skb);

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

	/*
	 * Make sure the packet header is in the DMA header format (4-address
	 * without QoS), the necessary crypto padding between the header and the
841 842
	 * payload has already been provided by mac80211, but it doesn't add
	 * tail padding when HW crypto is enabled.
843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865
	 *
	 * We have the following trailer padding requirements:
	 * - WEP: 4 trailer bytes (ICV)
	 * - TKIP: 12 trailer bytes (8 MIC + 4 ICV)
	 * - CCMP: 8 trailer bytes (MIC)
	 */
	data_pad = 0;
	if (key_conf != NULL) {
		switch (key_conf->cipher) {
		case WLAN_CIPHER_SUITE_WEP40:
		case WLAN_CIPHER_SUITE_WEP104:
			data_pad = 4;
			break;
		case WLAN_CIPHER_SUITE_TKIP:
			data_pad = 12;
			break;
		case WLAN_CIPHER_SUITE_CCMP:
			data_pad = 8;
			break;
		}
	}
	mwl8k_add_dma_header(skb, data_pad);
}
866 867

/*
868
 * Packet reception for 88w8366 AP firmware.
869
 */
870
struct mwl8k_rxd_8366_ap {
871 872 873 874 875 876 877 878 879 880 881 882 883 884 885
	__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;
886
} __packed;
887

888 889 890
#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)
891

892
#define MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST	0x80
893

894 895 896 897 898 899 900
/* 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

901
static void mwl8k_rxd_8366_ap_init(void *_rxd, dma_addr_t next_dma_addr)
902
{
903
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
904 905

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
906
	rxd->rx_ctrl = MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST;
907 908
}

909
static void mwl8k_rxd_8366_ap_refill(void *_rxd, dma_addr_t addr, int len)
910
{
911
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
912 913 914 915 916 917 918 919

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

static int
920
mwl8k_rxd_8366_ap_process(void *_rxd, struct ieee80211_rx_status *status,
921
			  __le16 *qos, s8 *noise)
922
{
923
	struct mwl8k_rxd_8366_ap *rxd = _rxd;
924

925
	if (!(rxd->rx_ctrl & MWL8K_8366_AP_RX_CTRL_OWNED_BY_HOST))
926 927 928 929 930 931
		return -1;
	rmb();

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

	status->signal = -rxd->rssi;
932
	*noise = -rxd->noise_floor;
933

934
	if (rxd->rate & MWL8K_8366_AP_RATE_INFO_MCS_FORMAT) {
935
		status->flag |= RX_FLAG_HT;
936
		if (rxd->rate & MWL8K_8366_AP_RATE_INFO_40MHZ)
937
			status->flag |= RX_FLAG_40MHZ;
938
		status->rate_idx = MWL8K_8366_AP_RATE_INFO_RATEID(rxd->rate);
939 940 941
	} else {
		int i;

942 943
		for (i = 0; i < ARRAY_SIZE(mwl8k_rates_24); i++) {
			if (mwl8k_rates_24[i].hw_value == rxd->rate) {
944 945 946 947 948 949
				status->rate_idx = i;
				break;
			}
		}
	}

950 951 952 953 954 955 956
	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;
	}
957 958
	status->freq = ieee80211_channel_to_frequency(rxd->channel,
						      status->band);
959

960 961
	*qos = rxd->qos_control;

962 963 964 965 966
	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;

967 968 969
	return le16_to_cpu(rxd->pkt_len);
}

970 971 972 973 974
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,
975 976 977
};

/*
978
 * Packet reception for STA firmware.
979
 */
980
struct mwl8k_rxd_sta {
981 982 983 984
	__le16 pkt_len;
	__u8 link_quality;
	__u8 noise_level;
	__le32 pkt_phys_addr;
985
	__le32 next_rxd_phys_addr;
986 987 988 989 990 991 992 993 994
	__le16 qos_control;
	__le16 rate_info;
	__le32 pad0[4];
	__u8 rssi;
	__u8 channel;
	__le16 pad1;
	__u8 rx_ctrl;
	__u8 rx_status;
	__u8 pad2[2];
995
} __packed;
996

997 998 999 1000 1001 1002
#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
1003

1004
#define MWL8K_STA_RX_CTRL_OWNED_BY_HOST		0x02
1005 1006 1007 1008 1009
#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
1010

1011
static void mwl8k_rxd_sta_init(void *_rxd, dma_addr_t next_dma_addr)
1012
{
1013
	struct mwl8k_rxd_sta *rxd = _rxd;
1014 1015

	rxd->next_rxd_phys_addr = cpu_to_le32(next_dma_addr);
1016
	rxd->rx_ctrl = MWL8K_STA_RX_CTRL_OWNED_BY_HOST;
1017 1018
}

1019
static void mwl8k_rxd_sta_refill(void *_rxd, dma_addr_t addr, int len)
1020
{
1021
	struct mwl8k_rxd_sta *rxd = _rxd;
1022 1023 1024 1025 1026 1027 1028 1029

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

static int
1030
mwl8k_rxd_sta_process(void *_rxd, struct ieee80211_rx_status *status,
1031
		       __le16 *qos, s8 *noise)
1032
{
1033
	struct mwl8k_rxd_sta *rxd = _rxd;
1034 1035
	u16 rate_info;

1036
	if (!(rxd->rx_ctrl & MWL8K_STA_RX_CTRL_OWNED_BY_HOST))
1037 1038 1039 1040 1041 1042 1043 1044
		return -1;
	rmb();

	rate_info = le16_to_cpu(rxd->rate_info);

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

	status->signal = -rxd->rssi;
1045
	*noise = -rxd->noise_level;
1046 1047
	status->antenna = MWL8K_STA_RATE_INFO_ANTSELECT(rate_info);
	status->rate_idx = MWL8K_STA_RATE_INFO_RATEID(rate_info);
1048

1049
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTPRE)
1050
		status->flag |= RX_FLAG_SHORTPRE;
1051
	if (rate_info & MWL8K_STA_RATE_INFO_40MHZ)
1052
		status->flag |= RX_FLAG_40MHZ;
1053
	if (rate_info & MWL8K_STA_RATE_INFO_SHORTGI)
1054
		status->flag |= RX_FLAG_SHORT_GI;
1055
	if (rate_info & MWL8K_STA_RATE_INFO_MCS_FORMAT)
1056 1057
		status->flag |= RX_FLAG_HT;

1058 1059 1060 1061 1062 1063 1064
	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;
	}
1065 1066
	status->freq = ieee80211_channel_to_frequency(rxd->channel,
						      status->band);
1067

1068
	*qos = rxd->qos_control;
1069 1070 1071
	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;
1072

1073 1074 1075
	return le16_to_cpu(rxd->pkt_len);
}

1076 1077 1078 1079 1080
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,
1081 1082 1083
};


1084 1085 1086 1087 1088 1089 1090 1091 1092 1093
#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;

1094 1095 1096
	rxq->rxd_count = 0;
	rxq->head = 0;
	rxq->tail = 0;
1097

1098
	size = MWL8K_RX_DESCS * priv->rxd_ops->rxd_size;
1099

1100 1101
	rxq->rxd = pci_alloc_consistent(priv->pdev, size, &rxq->rxd_dma);
	if (rxq->rxd == NULL) {
1102
		wiphy_err(hw->wiphy, "failed to alloc RX descriptors\n");
1103 1104
		return -ENOMEM;
	}
1105
	memset(rxq->rxd, 0, size);
1106

1107
	rxq->buf = kcalloc(MWL8K_RX_DESCS, sizeof(*rxq->buf), GFP_KERNEL);
1108
	if (rxq->buf == NULL) {
1109
		wiphy_err(hw->wiphy, "failed to alloc RX skbuff list\n");
1110
		pci_free_consistent(priv->pdev, size, rxq->rxd, rxq->rxd_dma);
1111 1112 1113 1114
		return -ENOMEM;
	}

	for (i = 0; i < MWL8K_RX_DESCS; i++) {
1115 1116
		int desc_size;
		void *rxd;
1117
		int nexti;
1118 1119 1120 1121
		dma_addr_t next_dma_addr;

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

1123 1124 1125 1126
		nexti = i + 1;
		if (nexti == MWL8K_RX_DESCS)
			nexti = 0;
		next_dma_addr = rxq->rxd_dma + (nexti * desc_size);
1127

1128
		priv->rxd_ops->rxd_init(rxd, next_dma_addr);
1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140
	}

	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;
1141
	while (rxq->rxd_count < MWL8K_RX_DESCS && limit--) {
1142
		struct sk_buff *skb;
1143
		dma_addr_t addr;
1144
		int rx;
1145
		void *rxd;
1146 1147 1148 1149 1150

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

1151 1152
		addr = pci_map_single(priv->pdev, skb->data,
				      MWL8K_RX_MAXSZ, DMA_FROM_DEVICE);
1153

1154 1155 1156 1157
		rxq->rxd_count++;
		rx = rxq->tail++;
		if (rxq->tail == MWL8K_RX_DESCS)
			rxq->tail = 0;
1158
		rxq->buf[rx].skb = skb;
1159
		dma_unmap_addr_set(&rxq->buf[rx], dma, addr);
1160 1161 1162

		rxd = rxq->rxd + (rx * priv->rxd_ops->rxd_size);
		priv->rxd_ops->rxd_refill(rxd, addr, MWL8K_RX_MAXSZ);
1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176

		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;

1177 1178 1179
	if (rxq->rxd == NULL)
		return;

1180
	for (i = 0; i < MWL8K_RX_DESCS; i++) {
1181 1182
		if (rxq->buf[i].skb != NULL) {
			pci_unmap_single(priv->pdev,
1183
					 dma_unmap_addr(&rxq->buf[i], dma),
1184
					 MWL8K_RX_MAXSZ, PCI_DMA_FROMDEVICE);
1185
			dma_unmap_addr_set(&rxq->buf[i], dma, 0);
1186 1187 1188

			kfree_skb(rxq->buf[i].skb);
			rxq->buf[i].skb = NULL;
1189 1190 1191
		}
	}

1192 1193
	kfree(rxq->buf);
	rxq->buf = NULL;
1194 1195

	pci_free_consistent(priv->pdev,
1196
			    MWL8K_RX_DESCS * priv->rxd_ops->rxd_size,
1197 1198
			    rxq->rxd, rxq->rxd_dma);
	rxq->rxd = NULL;
1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
}


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

1214 1215
static inline void mwl8k_save_beacon(struct ieee80211_hw *hw,
				     struct sk_buff *skb)
1216
{
1217 1218
	struct mwl8k_priv *priv = hw->priv;

1219
	priv->capture_beacon = false;
1220
	memset(priv->capture_bssid, 0, ETH_ALEN);
1221 1222 1223 1224 1225 1226 1227 1228

	/*
	 * 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)
1229
		ieee80211_queue_work(hw, &priv->finalize_join_worker);
1230 1231
}

1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246
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;
}

1247 1248 1249
static int rxq_process(struct ieee80211_hw *hw, int index, int limit)
{
	struct mwl8k_priv *priv = hw->priv;
1250
	struct mwl8k_vif *mwl8k_vif = NULL;
1251 1252 1253 1254
	struct mwl8k_rx_queue *rxq = priv->rxq + index;
	int processed;

	processed = 0;
1255
	while (rxq->rxd_count && limit--) {
1256
		struct sk_buff *skb;
1257 1258
		void *rxd;
		int pkt_len;
1259
		struct ieee80211_rx_status status;
1260
		struct ieee80211_hdr *wh;
1261
		__le16 qos;
1262

1263
		skb = rxq->buf[rxq->head].skb;
1264 1265
		if (skb == NULL)
			break;
1266 1267 1268

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

1269 1270
		pkt_len = priv->rxd_ops->rxd_process(rxd, &status, &qos,
							&priv->noise);
1271 1272 1273
		if (pkt_len < 0)
			break;

1274 1275 1276
		rxq->buf[rxq->head].skb = NULL;

		pci_unmap_single(priv->pdev,
1277
				 dma_unmap_addr(&rxq->buf[rxq->head], dma),
1278
				 MWL8K_RX_MAXSZ, PCI_DMA_FROMDEVICE);
1279
		dma_unmap_addr_set(&rxq->buf[rxq->head], dma, 0);
1280

1281 1282 1283 1284
		rxq->head++;
		if (rxq->head == MWL8K_RX_DESCS)
			rxq->head = 0;

1285
		rxq->rxd_count--;
1286

1287
		wh = &((struct mwl8k_dma_data *)skb->data)->wh;
1288 1289

		/*
L
Lennert Buytenhek 已提交
1290 1291 1292
		 * 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.
1293
		 */
1294
		if (mwl8k_capture_bssid(priv, (void *)skb->data))
1295
			mwl8k_save_beacon(hw, skb);
1296

1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336
		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);
1337 1338
		memcpy(IEEE80211_SKB_RXCB(skb), &status, sizeof(status));
		ieee80211_rx_irqsafe(hw, skb);
1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356

		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

1357 1358 1359 1360 1361 1362
#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

1363 1364 1365 1366 1367 1368 1369
struct mwl8k_tx_desc {
	__le32 status;
	__u8 data_rate;
	__u8 tx_priority;
	__le16 qos_control;
	__le32 pkt_phys_addr;
	__le16 pkt_len;
1370
	__u8 dest_MAC_addr[ETH_ALEN];
1371
	__le32 next_txd_phys_addr;
1372
	__le32 timestamp;
1373 1374
	__le16 rate_info;
	__u8 peer_id;
1375
	__u8 tx_frag_cnt;
1376
} __packed;
1377 1378 1379 1380 1381 1382 1383 1384 1385 1386

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

1387
	txq->len = 0;
1388 1389
	txq->head = 0;
	txq->tail = 0;
1390 1391 1392

	size = MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc);

1393 1394
	txq->txd = pci_alloc_consistent(priv->pdev, size, &txq->txd_dma);
	if (txq->txd == NULL) {
1395
		wiphy_err(hw->wiphy, "failed to alloc TX descriptors\n");
1396 1397
		return -ENOMEM;
	}
1398
	memset(txq->txd, 0, size);
1399

1400
	txq->skb = kcalloc(MWL8K_TX_DESCS, sizeof(*txq->skb), GFP_KERNEL);
1401
	if (txq->skb == NULL) {
1402
		wiphy_err(hw->wiphy, "failed to alloc TX skbuff list\n");
1403
		pci_free_consistent(priv->pdev, size, txq->txd, txq->txd_dma);
1404 1405 1406 1407 1408 1409 1410
		return -ENOMEM;
	}

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

1411
		tx_desc = txq->txd + i;
1412 1413 1414
		nexti = (i + 1) % MWL8K_TX_DESCS;

		tx_desc->status = 0;
1415 1416
		tx_desc->next_txd_phys_addr =
			cpu_to_le32(txq->txd_dma + nexti * sizeof(*tx_desc));
1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430
	}

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

1431
static void mwl8k_dump_tx_rings(struct ieee80211_hw *hw)
1432
{
1433 1434 1435
	struct mwl8k_priv *priv = hw->priv;
	int i;

1436
	for (i = 0; i < mwl8k_tx_queues(priv); i++) {
1437 1438 1439 1440 1441 1442
		struct mwl8k_tx_queue *txq = priv->txq + i;
		int fw_owned = 0;
		int drv_owned = 0;
		int unused = 0;
		int desc;

1443
		for (desc = 0; desc < MWL8K_TX_DESCS; desc++) {
1444 1445
			struct mwl8k_tx_desc *tx_desc = txq->txd + desc;
			u32 status;
1446

1447
			status = le32_to_cpu(tx_desc->status);
1448
			if (status & MWL8K_TXD_STATUS_FW_OWNED)
1449
				fw_owned++;
1450
			else
1451
				drv_owned++;
1452 1453

			if (tx_desc->pkt_len == 0)
1454
				unused++;
1455 1456
		}

1457 1458 1459 1460 1461 1462
		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);
1463
	}
1464 1465
}

1466
/*
1467
 * Must be called with priv->fw_mutex held and tx queues stopped.
1468
 */
1469
#define MWL8K_TX_WAIT_TIMEOUT_MS	5000
1470

1471
static int mwl8k_tx_wait_empty(struct ieee80211_hw *hw)
1472 1473
{
	struct mwl8k_priv *priv = hw->priv;
1474
	DECLARE_COMPLETION_ONSTACK(tx_wait);
1475 1476
	int retry;
	int rc;
1477 1478 1479

	might_sleep();

1480 1481 1482 1483 1484 1485 1486 1487 1488 1489
	/*
	 * 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;

1490
	spin_lock_bh(&priv->tx_lock);
1491 1492 1493 1494
	priv->tx_wait = &tx_wait;
	while (!rc) {
		int oldcount;
		unsigned long timeout;
1495

1496
		oldcount = priv->pending_tx_pkts;
1497

1498
		spin_unlock_bh(&priv->tx_lock);
1499
		timeout = wait_for_completion_timeout(&tx_wait,
1500
			    msecs_to_jiffies(MWL8K_TX_WAIT_TIMEOUT_MS));
1501
		spin_lock_bh(&priv->tx_lock);
1502 1503 1504

		if (timeout) {
			WARN_ON(priv->pending_tx_pkts);
1505
			if (retry)
1506
				wiphy_notice(hw->wiphy, "tx rings drained\n");
1507 1508 1509 1510
			break;
		}

		if (priv->pending_tx_pkts < oldcount) {
1511 1512 1513
			wiphy_notice(hw->wiphy,
				     "waiting for tx rings to drain (%d -> %d pkts)\n",
				     oldcount, priv->pending_tx_pkts);
1514 1515 1516 1517
			retry = 1;
			continue;
		}

1518 1519
		priv->tx_wait = NULL;

1520 1521
		wiphy_err(hw->wiphy, "tx rings stuck for %d ms\n",
			  MWL8K_TX_WAIT_TIMEOUT_MS);
1522 1523 1524
		mwl8k_dump_tx_rings(hw);

		rc = -ETIMEDOUT;
1525
	}
1526
	spin_unlock_bh(&priv->tx_lock);
1527

1528
	return rc;
1529 1530
}

1531 1532 1533 1534
#define MWL8K_TXD_SUCCESS(status)				\
	((status) & (MWL8K_TXD_STATUS_OK |			\
		     MWL8K_TXD_STATUS_OK_RETRY |		\
		     MWL8K_TXD_STATUS_OK_MORE_RETRY))
1535

1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562
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;
	}
}

1563 1564
/* The firmware will fill in the rate information
 * for each packet that gets queued in the hardware
1565
 * and these macros will interpret that info.
1566 1567
 */

1568 1569
#define RI_FORMAT(a)		  (a & 0x0001)
#define RI_RATE_ID_MCS(a)	 ((a & 0x01f8) >> 3)
1570

1571 1572
static int
mwl8k_txq_reclaim(struct ieee80211_hw *hw, int index, int limit, int force)
1573 1574 1575
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_tx_queue *txq = priv->txq + index;
1576
	int processed;
1577

1578
	processed = 0;
1579
	while (txq->len > 0 && limit--) {
1580 1581 1582
		int tx;
		struct mwl8k_tx_desc *tx_desc;
		unsigned long addr;
1583
		int size;
1584 1585 1586
		struct sk_buff *skb;
		struct ieee80211_tx_info *info;
		u32 status;
1587 1588 1589 1590
		struct ieee80211_sta *sta;
		struct mwl8k_sta *sta_info = NULL;
		u16 rate_info;
		struct ieee80211_hdr *wh;
1591

1592 1593
		tx = txq->head;
		tx_desc = txq->txd + tx;
1594 1595 1596 1597 1598 1599 1600 1601 1602 1603

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

1604
		txq->head = (tx + 1) % MWL8K_TX_DESCS;
1605 1606
		BUG_ON(txq->len == 0);
		txq->len--;
1607 1608 1609
		priv->pending_tx_pkts--;

		addr = le32_to_cpu(tx_desc->pkt_phys_addr);
1610
		size = le16_to_cpu(tx_desc->pkt_len);
1611 1612
		skb = txq->skb[tx];
		txq->skb[tx] = NULL;
1613 1614 1615 1616

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

1617
		mwl8k_remove_dma_header(skb, tx_desc->qos_control);
1618

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

1621 1622 1623 1624 1625
		/* Mark descriptor as unused */
		tx_desc->pkt_phys_addr = 0;
		tx_desc->pkt_len = 0;

		info = IEEE80211_SKB_CB(skb);
1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636
		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
				 */
1637 1638
				if (RI_RATE_ID_MCS(rate_info) < 1 ||
				    RI_FORMAT(rate_info) == 0) {
1639 1640 1641 1642 1643 1644 1645
					sta_info->is_ampdu_allowed = false;
				} else {
					sta_info->is_ampdu_allowed = true;
				}
			}
		}

1646
		ieee80211_tx_info_clear_status(info);
1647 1648 1649 1650

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

1654
		if (MWL8K_TXD_SUCCESS(status))
1655 1656 1657 1658
			info->flags |= IEEE80211_TX_STAT_ACK;

		ieee80211_tx_status_irqsafe(hw, skb);

1659
		processed++;
1660 1661
	}

1662
	return processed;
1663 1664 1665 1666 1667 1668 1669 1670
}

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

1671 1672 1673
	if (txq->txd == NULL)
		return;

1674
	mwl8k_txq_reclaim(hw, index, INT_MAX, 1);
1675

1676 1677
	kfree(txq->skb);
	txq->skb = NULL;
1678 1679 1680

	pci_free_consistent(priv->pdev,
			    MWL8K_TX_DESCS * sizeof(struct mwl8k_tx_desc),
1681 1682
			    txq->txd, txq->txd_dma);
	txq->txd = NULL;
1683 1684
}

1685
/* caller must hold priv->stream_lock when calling the stream functions */
1686
static struct mwl8k_ampdu_stream *
1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752
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;
}

1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787
#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++;
}

1788
static void
1789 1790 1791 1792
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;
1793
	struct mwl8k_vif *mwl8k_vif;
N
Nishant Sarmukadam 已提交
1794
	struct ieee80211_sta *sta;
1795 1796 1797 1798
	struct ieee80211_hdr *wh;
	struct mwl8k_tx_queue *txq;
	struct mwl8k_tx_desc *tx;
	dma_addr_t dma;
1799 1800 1801
	u32 txstatus;
	u8 txdatarate;
	u16 qos;
N
Nishant Sarmukadam 已提交
1802 1803 1804 1805
	int txpriority;
	u8 tid = 0;
	struct mwl8k_ampdu_stream *stream = NULL;
	bool start_ba_session = false;
1806
	bool mgmtframe = false;
1807
	struct ieee80211_mgmt *mgmt = (struct ieee80211_mgmt *)skb->data;
1808

1809 1810 1811 1812 1813
	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;
1814

1815 1816 1817
	if (ieee80211_is_mgmt(wh->frame_control))
		mgmtframe = true;

1818 1819 1820 1821 1822
	if (priv->ap_fw)
		mwl8k_encapsulate_tx_frame(skb);
	else
		mwl8k_add_dma_header(skb, 0);

1823
	wh = &((struct mwl8k_dma_data *)skb->data)->wh;
1824 1825

	tx_info = IEEE80211_SKB_CB(skb);
N
Nishant Sarmukadam 已提交
1826
	sta = tx_info->control.sta;
1827 1828 1829 1830
	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);
1831 1832
		wh->seq_ctrl |= cpu_to_le16(mwl8k_vif->seqno);
		mwl8k_vif->seqno += 0x10;
1833 1834
	}

1835 1836 1837 1838 1839 1840
	/* 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;
1841
		qos |= MWL8K_QOS_QLEN_UNSPEC | MWL8K_QOS_EOSP;
1842 1843 1844 1845 1846
	} else if (ieee80211_is_data(wh->frame_control)) {
		txdatarate = 1;
		if (is_multicast_ether_addr(wh->addr1))
			txstatus |= MWL8K_TXD_STATUS_MULTICAST_TX;

1847
		qos &= ~MWL8K_QOS_ACK_POLICY_MASK;
1848
		if (tx_info->flags & IEEE80211_TX_CTL_AMPDU)
1849
			qos |= MWL8K_QOS_ACK_POLICY_BLOCKACK;
1850
		else
1851
			qos |= MWL8K_QOS_ACK_POLICY_NORMAL;
1852
	}
1853

1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871
	/* 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 已提交
1872 1873 1874 1875 1876 1877
	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;
1878
		mwl8k_tx_count_packet(sta, tid);
N
Nishant Sarmukadam 已提交
1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
		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.
			 */
1919
			if (mwl8k_ampdu_allowed(sta, tid)) {
1920 1921 1922 1923
				stream = mwl8k_add_stream(hw, sta, tid);
				if (stream != NULL)
					start_ba_session = true;
			}
N
Nishant Sarmukadam 已提交
1924 1925 1926 1927
		}
		spin_unlock(&priv->stream_lock);
	}

1928 1929 1930 1931
	dma = pci_map_single(priv->pdev, skb->data,
				skb->len, PCI_DMA_TODEVICE);

	if (pci_dma_mapping_error(priv->pdev, dma)) {
1932 1933
		wiphy_debug(hw->wiphy,
			    "failed to dma map skb, dropping TX frame.\n");
N
Nishant Sarmukadam 已提交
1934 1935 1936 1937 1938
		if (start_ba_session) {
			spin_lock(&priv->stream_lock);
			mwl8k_remove_stream(hw, stream);
			spin_unlock(&priv->stream_lock);
		}
1939
		dev_kfree_skb(skb);
1940
		return;
1941 1942
	}

1943
	spin_lock_bh(&priv->tx_lock);
1944

1945
	txq = priv->txq + index;
1946

1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961 1962 1963 1964 1965
	/* 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 已提交
1966
		}
N
Nishant Sarmukadam 已提交
1967 1968
	}

1969 1970
	BUG_ON(txq->skb[txq->tail] != NULL);
	txq->skb[txq->tail] = skb;
1971

1972
	tx = txq->txd + txq->tail;
1973
	tx->data_rate = txdatarate;
N
Nishant Sarmukadam 已提交
1974
	tx->tx_priority = txpriority;
1975 1976 1977
	tx->qos_control = cpu_to_le16(qos);
	tx->pkt_phys_addr = cpu_to_le32(dma);
	tx->pkt_len = cpu_to_le16(skb->len);
1978
	tx->rate_info = 0;
1979 1980 1981 1982
	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;
1983 1984 1985 1986 1987

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

1988
	wmb();
1989 1990
	tx->status = cpu_to_le32(MWL8K_TXD_STATUS_FW_OWNED | txstatus);

1991
	txq->len++;
1992 1993
	priv->pending_tx_pkts++;

1994 1995 1996
	txq->tail++;
	if (txq->tail == MWL8K_TX_DESCS)
		txq->tail = 0;
1997 1998

	mwl8k_tx_start(priv);
1999 2000

	spin_unlock_bh(&priv->tx_lock);
N
Nishant Sarmukadam 已提交
2001 2002 2003 2004 2005 2006 2007 2008

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


2012 2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 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
/*
 * 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);
	}
}


2066 2067 2068 2069
/*
 * Command processing.
 */

2070 2071
/* Timeout firmware commands after 10s */
#define MWL8K_CMD_TIMEOUT_MS	10000
2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083

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

2084
	cmd->result = (__force __le16) 0xffff;
2085 2086 2087 2088 2089 2090
	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;

2091
	rc = mwl8k_fw_lock(hw);
2092 2093 2094
	if (rc) {
		pci_unmap_single(priv->pdev, dma_addr, dma_size,
						PCI_DMA_BIDIRECTIONAL);
2095
		return rc;
2096
	}
2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107

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

2108 2109 2110 2111
	priv->hostcmd_wait = NULL;

	mwl8k_fw_unlock(hw);

2112 2113 2114
	pci_unmap_single(priv->pdev, dma_addr, dma_size,
					PCI_DMA_BIDIRECTIONAL);

2115
	if (!timeout) {
2116
		wiphy_err(hw->wiphy, "Command %s timeout after %u ms\n",
2117 2118
			  mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
			  MWL8K_CMD_TIMEOUT_MS);
2119 2120
		rc = -ETIMEDOUT;
	} else {
2121 2122 2123 2124
		int ms;

		ms = MWL8K_CMD_TIMEOUT_MS - jiffies_to_msecs(timeout);

2125
		rc = cmd->result ? -EINVAL : 0;
2126
		if (rc)
2127
			wiphy_err(hw->wiphy, "Command %s error 0x%x\n",
2128 2129
				  mwl8k_cmd_name(cmd->code, buf, sizeof(buf)),
				  le16_to_cpu(cmd->result));
2130
		else if (ms > 2000)
2131
			wiphy_notice(hw->wiphy, "Command %s took %d ms\n",
2132 2133 2134
				     mwl8k_cmd_name(cmd->code,
						    buf, sizeof(buf)),
				     ms);
2135 2136 2137 2138 2139
	}

	return rc;
}

2140 2141 2142 2143 2144 2145 2146 2147 2148
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);
}

2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167 2168 2169 2170
/*
 * 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;
}

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

2190
/*
2191
 * CMD_GET_HW_SPEC (STA version).
2192
 */
2193
struct mwl8k_cmd_get_hw_spec_sta {
2194 2195 2196 2197
	struct mwl8k_cmd_pkt header;
	__u8 hw_rev;
	__u8 host_interface;
	__le16 num_mcaddrs;
2198
	__u8 perm_addr[ETH_ALEN];
2199 2200 2201 2202 2203 2204 2205
	__le16 region_code;
	__le32 fw_rev;
	__le32 ps_cookie;
	__le32 caps;
	__u8 mcs_bitmap[16];
	__le32 rx_queue_ptr;
	__le32 num_tx_queues;
2206
	__le32 tx_queue_ptrs[MWL8K_TX_WMM_QUEUES];
2207 2208
	__le32 caps2;
	__le32 num_tx_desc_per_queue;
2209
	__le32 total_rxd;
2210
} __packed;
2211

2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223
#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
2224 2225 2226
#define MWL8K_CAP_BAND_MASK		0x00000007
#define MWL8K_CAP_5GHZ			0x00000004
#define MWL8K_CAP_2GHZ4			0x00000001
2227

2228 2229 2230
static void
mwl8k_set_ht_caps(struct ieee80211_hw *hw,
		  struct ieee80211_supported_band *band, u32 cap)
2231 2232 2233 2234
{
	int rx_streams;
	int tx_streams;

2235
	band->ht_cap.ht_supported = 1;
2236 2237

	if (cap & MWL8K_CAP_MAX_AMSDU)
2238
		band->ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
2239
	if (cap & MWL8K_CAP_GREENFIELD)
2240
		band->ht_cap.cap |= IEEE80211_HT_CAP_GRN_FLD;
2241 2242
	if (cap & MWL8K_CAP_AMPDU) {
		hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
2243 2244
		band->ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
		band->ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_NONE;
2245 2246
	}
	if (cap & MWL8K_CAP_RX_STBC)
2247
		band->ht_cap.cap |= IEEE80211_HT_CAP_RX_STBC;
2248
	if (cap & MWL8K_CAP_TX_STBC)
2249
		band->ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
2250
	if (cap & MWL8K_CAP_SHORTGI_40MHZ)
2251
		band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
2252
	if (cap & MWL8K_CAP_SHORTGI_20MHZ)
2253
		band->ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
2254
	if (cap & MWL8K_CAP_DELAY_BA)
2255
		band->ht_cap.cap |= IEEE80211_HT_CAP_DELAY_BA;
2256
	if (cap & MWL8K_CAP_40MHZ)
2257
		band->ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
2258 2259 2260 2261

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

2262
	band->ht_cap.mcs.rx_mask[0] = 0xff;
2263
	if (rx_streams >= 2)
2264
		band->ht_cap.mcs.rx_mask[1] = 0xff;
2265
	if (rx_streams >= 3)
2266 2267 2268
		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;
2269 2270

	if (rx_streams != tx_streams) {
2271 2272
		band->ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_RX_DIFF;
		band->ht_cap.mcs.tx_params |= (tx_streams - 1) <<
2273 2274 2275 2276
				IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
	}
}

2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294
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);
	}
}

2295
static int mwl8k_cmd_get_hw_spec_sta(struct ieee80211_hw *hw)
2296 2297
{
	struct mwl8k_priv *priv = hw->priv;
2298
	struct mwl8k_cmd_get_hw_spec_sta *cmd;
2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310
	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);
2311
	cmd->rx_queue_ptr = cpu_to_le32(priv->rxq[0].rxd_dma);
2312 2313
	cmd->num_tx_queues = cpu_to_le32(mwl8k_tx_queues(priv));
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
2314
		cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[i].txd_dma);
2315
	cmd->num_tx_desc_per_queue = cpu_to_le32(MWL8K_TX_DESCS);
2316
	cmd->total_rxd = cpu_to_le32(MWL8K_RX_DESCS);
2317 2318 2319 2320 2321 2322

	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);
2323
		priv->fw_rev = le32_to_cpu(cmd->fw_rev);
2324
		priv->hw_rev = cmd->hw_rev;
2325
		mwl8k_set_caps(hw, le32_to_cpu(cmd->caps));
2326 2327
		priv->ap_macids_supported = 0x00000000;
		priv->sta_macids_supported = 0x00000001;
2328 2329 2330 2331 2332 2333
	}

	kfree(cmd);
	return rc;
}

2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353
/*
 * 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;
2354
	__le32 fw_api_version;
2355 2356 2357
	__le32 caps;
	__le32 num_of_ampdu_queues;
	__le32 wcbbase_ampdu[MWL8K_MAX_AMPDU_QUEUES];
2358
} __packed;
2359 2360 2361 2362 2363

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;
2364
	int rc, i;
2365
	u32 api_version;
2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381

	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;

2382 2383 2384 2385 2386 2387 2388 2389 2390 2391
		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;
		}
2392 2393 2394 2395
		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;
2396
		mwl8k_set_caps(hw, le32_to_cpu(cmd->caps));
2397 2398
		priv->ap_macids_supported = 0x000000ff;
		priv->sta_macids_supported = 0x00000000;
2399 2400 2401 2402 2403 2404 2405 2406
		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;
		}
2407
		off = le32_to_cpu(cmd->rxwrptr) & 0xffff;
2408
		iowrite32(priv->rxq[0].rxd_dma, priv->sram + off);
2409 2410

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

2413 2414 2415 2416
		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;
2417 2418

		for (i = 0; i < priv->num_ampdu_queues; i++)
2419
			priv->txq_offset[i + MWL8K_TX_WMM_QUEUES] =
2420
				le32_to_cpu(cmd->wcbbase_ampdu[i]) & 0xffff;
2421 2422
	}

2423
done:
2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442
	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;
2443
	__le32 tx_queue_ptrs[MWL8K_MAX_TX_QUEUES];
2444 2445 2446
	__le32 flags;
	__le32 num_tx_desc_per_queue;
	__le32 total_rxd;
2447
} __packed;
2448

2449 2450 2451 2452 2453 2454 2455 2456
/* 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
2457 2458 2459
#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
2460 2461 2462 2463 2464 2465 2466 2467 2468 2469 2470 2471 2472 2473 2474 2475 2476

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);
2477
	cmd->num_tx_queues = cpu_to_le32(mwl8k_tx_queues(priv));
2478 2479 2480 2481 2482 2483 2484

	/*
	 * 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.
	 */
2485 2486
	for (i = 0; i < mwl8k_tx_queues(priv); i++) {
		int j = mwl8k_tx_queues(priv) - 1 - i;
2487 2488 2489
		cmd->tx_queue_ptrs[i] = cpu_to_le32(priv->txq[j].txd_dma);
	}

2490 2491
	cmd->flags = cpu_to_le32(MWL8K_SET_HW_SPEC_FLAG_HOST_DECR_MGMT |
				 MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_PROBERESP |
2492 2493
				 MWL8K_SET_HW_SPEC_FLAG_HOSTFORM_BEACON |
				 MWL8K_SET_HW_SPEC_FLAG_ENABLE_LIFE_TIME_EXPIRY);
2494 2495 2496 2497 2498 2499 2500 2501 2502
	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;
}

2503 2504 2505 2506 2507 2508 2509
/*
 * CMD_MAC_MULTICAST_ADR.
 */
struct mwl8k_cmd_mac_multicast_adr {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 numaddr;
2510
	__u8 addr[0][ETH_ALEN];
2511 2512
};

2513 2514 2515 2516
#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
2517

2518
static struct mwl8k_cmd_pkt *
L
Lennert Buytenhek 已提交
2519
__mwl8k_cmd_mac_multicast_adr(struct ieee80211_hw *hw, int allmulti,
2520
			      struct netdev_hw_addr_list *mc_list)
2521
{
2522
	struct mwl8k_priv *priv = hw->priv;
2523
	struct mwl8k_cmd_mac_multicast_adr *cmd;
2524
	int size;
2525 2526 2527 2528
	int mc_count = 0;

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

L
Lennert Buytenhek 已提交
2530
	if (allmulti || mc_count > priv->num_mcaddrs) {
2531 2532 2533
		allmulti = 1;
		mc_count = 0;
	}
2534 2535

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

2537
	cmd = kzalloc(size, GFP_ATOMIC);
2538
	if (cmd == NULL)
2539
		return NULL;
2540 2541 2542

	cmd->header.code = cpu_to_le16(MWL8K_CMD_MAC_MULTICAST_ADR);
	cmd->header.length = cpu_to_le16(size);
2543 2544 2545 2546 2547 2548
	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) {
2549 2550
		struct netdev_hw_addr *ha;
		int i = 0;
2551 2552 2553

		cmd->action |= cpu_to_le16(MWL8K_ENABLE_RX_MULTICAST);
		cmd->numaddr = cpu_to_le16(mc_count);
2554 2555
		netdev_hw_addr_list_for_each(ha, mc_list) {
			memcpy(cmd->addr[i], ha->addr, ETH_ALEN);
2556 2557 2558
		}
	}

2559
	return &cmd->header;
2560 2561 2562
}

/*
2563
 * CMD_GET_STAT.
2564
 */
2565
struct mwl8k_cmd_get_stat {
2566 2567
	struct mwl8k_cmd_pkt header;
	__le32 stats[64];
2568
} __packed;
2569 2570 2571 2572 2573 2574

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

2575 2576
static int mwl8k_cmd_get_stat(struct ieee80211_hw *hw,
			      struct ieee80211_low_level_stats *stats)
2577
{
2578
	struct mwl8k_cmd_get_stat *cmd;
2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604
	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;
}

/*
2605
 * CMD_RADIO_CONTROL.
2606
 */
2607
struct mwl8k_cmd_radio_control {
2608 2609 2610 2611
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 control;
	__le16 radio_on;
2612
} __packed;
2613

2614
static int
2615
mwl8k_cmd_radio_control(struct ieee80211_hw *hw, bool enable, bool force)
2616 2617
{
	struct mwl8k_priv *priv = hw->priv;
2618
	struct mwl8k_cmd_radio_control *cmd;
2619 2620
	int rc;

2621
	if (enable == priv->radio_on && !force)
2622 2623 2624 2625 2626 2627 2628 2629 2630
		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);
2631
	cmd->control = cpu_to_le16(priv->radio_short_preamble ? 3 : 1);
2632 2633 2634 2635 2636 2637
	cmd->radio_on = cpu_to_le16(enable ? 0x0001 : 0x0000);

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

	if (!rc)
2638
		priv->radio_on = enable;
2639 2640 2641 2642

	return rc;
}

2643
static int mwl8k_cmd_radio_disable(struct ieee80211_hw *hw)
2644
{
2645
	return mwl8k_cmd_radio_control(hw, 0, 0);
2646 2647
}

2648
static int mwl8k_cmd_radio_enable(struct ieee80211_hw *hw)
2649
{
2650
	return mwl8k_cmd_radio_control(hw, 1, 0);
2651 2652
}

2653 2654 2655
static int
mwl8k_set_radio_preamble(struct ieee80211_hw *hw, bool short_preamble)
{
2656
	struct mwl8k_priv *priv = hw->priv;
2657

2658
	priv->radio_short_preamble = short_preamble;
2659

2660
	return mwl8k_cmd_radio_control(hw, 1, 1);
2661 2662 2663
}

/*
2664
 * CMD_RF_TX_POWER.
2665
 */
2666
#define MWL8K_RF_TX_POWER_LEVEL_TOTAL	8
2667

2668
struct mwl8k_cmd_rf_tx_power {
2669 2670 2671 2672 2673
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 support_level;
	__le16 current_level;
	__le16 reserved;
2674
	__le16 power_level_list[MWL8K_RF_TX_POWER_LEVEL_TOTAL];
2675
} __packed;
2676

2677
static int mwl8k_cmd_rf_tx_power(struct ieee80211_hw *hw, int dBm)
2678
{
2679
	struct mwl8k_cmd_rf_tx_power *cmd;
2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694 2695 2696
	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;
}

2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707 2708 2709
/*
 * 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];
2710
} __packed;
2711 2712 2713 2714 2715 2716 2717 2718 2719 2720 2721 2722 2723 2724 2725 2726 2727 2728 2729 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

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

2756 2757 2758 2759 2760 2761 2762
/*
 * CMD_RF_ANTENNA.
 */
struct mwl8k_cmd_rf_antenna {
	struct mwl8k_cmd_pkt header;
	__le16 antenna;
	__le16 mode;
2763
} __packed;
2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788

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

2789 2790 2791 2792 2793 2794 2795 2796 2797
/*
 * CMD_SET_BEACON.
 */
struct mwl8k_cmd_set_beacon {
	struct mwl8k_cmd_pkt header;
	__le16 beacon_len;
	__u8 beacon[0];
};

2798 2799
static int mwl8k_cmd_set_beacon(struct ieee80211_hw *hw,
				struct ieee80211_vif *vif, u8 *beacon, int len)
2800 2801 2802 2803 2804 2805 2806 2807 2808 2809 2810 2811 2812
{
	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);

2813
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
2814 2815 2816 2817 2818
	kfree(cmd);

	return rc;
}

2819 2820 2821 2822 2823
/*
 * CMD_SET_PRE_SCAN.
 */
struct mwl8k_cmd_set_pre_scan {
	struct mwl8k_cmd_pkt header;
2824
} __packed;
2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849

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;
2850
	__u8 bssid[ETH_ALEN];
2851
} __packed;
2852 2853

static int
2854
mwl8k_cmd_set_post_scan(struct ieee80211_hw *hw, const __u8 *mac)
2855 2856 2857 2858 2859 2860 2861 2862 2863 2864 2865
{
	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;
2866
	memcpy(cmd->bssid, mac, ETH_ALEN);
2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881

	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;
2882
} __packed;
2883 2884

static int mwl8k_cmd_set_rf_channel(struct ieee80211_hw *hw,
2885
				    struct ieee80211_conf *conf)
2886
{
2887
	struct ieee80211_channel *channel = conf->channel;
2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898
	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;
2899

2900
	if (channel->band == IEEE80211_BAND_2GHZ)
2901
		cmd->channel_flags |= cpu_to_le32(0x00000001);
2902 2903
	else if (channel->band == IEEE80211_BAND_5GHZ)
		cmd->channel_flags |= cpu_to_le32(0x00000004);
2904 2905 2906 2907 2908 2909 2910 2911

	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);
2912 2913 2914 2915 2916 2917 2918 2919

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

	return rc;
}

/*
2920
 * CMD_SET_AID.
2921
 */
2922 2923 2924 2925
#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
2926

2927 2928 2929
struct mwl8k_cmd_update_set_aid {
	struct	mwl8k_cmd_pkt header;
	__le16	aid;
2930

2931 2932 2933 2934
	 /* AP's MAC address (BSSID) */
	__u8	bssid[ETH_ALEN];
	__le16	protection_mode;
	__u8	supp_rates[14];
2935
} __packed;
2936

L
Lennert Buytenhek 已提交
2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948
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))
2949
			rates[j++] = mwl8k_rates_24[i].hw_value;
L
Lennert Buytenhek 已提交
2950 2951 2952
	}
}

2953
static int
L
Lennert Buytenhek 已提交
2954 2955
mwl8k_cmd_set_aid(struct ieee80211_hw *hw,
		  struct ieee80211_vif *vif, u32 legacy_rate_mask)
2956
{
2957 2958
	struct mwl8k_cmd_update_set_aid *cmd;
	u16 prot_mode;
2959 2960 2961 2962 2963 2964
	int rc;

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

2965
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_AID);
2966
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
2967
	cmd->aid = cpu_to_le16(vif->bss_conf.aid);
2968
	memcpy(cmd->bssid, vif->bss_conf.bssid, ETH_ALEN);
2969

2970
	if (vif->bss_conf.use_cts_prot) {
2971 2972
		prot_mode = MWL8K_FRAME_PROT_11G;
	} else {
2973
		switch (vif->bss_conf.ht_operation_mode &
2974 2975 2976 2977 2978 2979 2980 2981 2982 2983 2984 2985 2986
			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);
2987

L
Lennert Buytenhek 已提交
2988
	legacy_rate_mask_to_array(cmd->supp_rates, legacy_rate_mask);
2989 2990 2991 2992 2993 2994 2995

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

	return rc;
}

2996
/*
2997
 * CMD_SET_RATE.
2998
 */
2999 3000 3001 3002 3003 3004 3005
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];
3006
} __packed;
3007

3008
static int
L
Lennert Buytenhek 已提交
3009
mwl8k_cmd_set_rate(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
3010
		   u32 legacy_rate_mask, u8 *mcs_rates)
3011
{
3012
	struct mwl8k_cmd_set_rate *cmd;
3013 3014 3015 3016 3017 3018
	int rc;

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

3019
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_RATE);
3020
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
3021
	legacy_rate_mask_to_array(cmd->legacy_rates, legacy_rate_mask);
3022
	memcpy(cmd->mcs_set, mcs_rates, 16);
3023 3024 3025 3026 3027 3028 3029

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

	return rc;
}

3030
/*
3031
 * CMD_FINALIZE_JOIN.
3032
 */
3033 3034 3035
#define MWL8K_FJ_BEACON_MAXLEN	128

struct mwl8k_cmd_finalize_join {
3036
	struct mwl8k_cmd_pkt header;
3037 3038
	__le32 sleep_interval;	/* Number of beacon periods to sleep */
	__u8 beacon_data[MWL8K_FJ_BEACON_MAXLEN];
3039
} __packed;
3040

3041 3042
static int mwl8k_cmd_finalize_join(struct ieee80211_hw *hw, void *frame,
				   int framelen, int dtim)
3043
{
3044 3045 3046
	struct mwl8k_cmd_finalize_join *cmd;
	struct ieee80211_mgmt *payload = frame;
	int payload_len;
3047 3048 3049 3050 3051 3052
	int rc;

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

3053
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_FINALIZE_JOIN);
3054
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
3055 3056 3057 3058 3059 3060 3061 3062 3063
	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);
3064 3065 3066 3067 3068 3069 3070 3071

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

	return rc;
}

/*
3072
 * CMD_SET_RTS_THRESHOLD.
3073
 */
3074
struct mwl8k_cmd_set_rts_threshold {
3075 3076
	struct mwl8k_cmd_pkt header;
	__le16 action;
3077
	__le16 threshold;
3078
} __packed;
3079

L
Lennert Buytenhek 已提交
3080 3081
static int
mwl8k_cmd_set_rts_threshold(struct ieee80211_hw *hw, int rts_thresh)
3082
{
3083
	struct mwl8k_cmd_set_rts_threshold *cmd;
3084 3085 3086 3087 3088 3089
	int rc;

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

3090
	cmd->header.code = cpu_to_le16(MWL8K_CMD_RTS_THRESHOLD);
3091
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
L
Lennert Buytenhek 已提交
3092 3093
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->threshold = cpu_to_le16(rts_thresh);
3094 3095 3096 3097 3098 3099 3100 3101

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

	return rc;
}

/*
3102
 * CMD_SET_SLOT.
3103
 */
3104
struct mwl8k_cmd_set_slot {
3105 3106
	struct mwl8k_cmd_pkt header;
	__le16 action;
3107
	__u8 short_slot;
3108
} __packed;
3109

3110
static int mwl8k_cmd_set_slot(struct ieee80211_hw *hw, bool short_slot_time)
3111
{
3112
	struct mwl8k_cmd_set_slot *cmd;
3113 3114 3115 3116 3117 3118
	int rc;

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

3119
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_SLOT);
3120
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
3121 3122
	cmd->action = cpu_to_le16(MWL8K_CMD_SET);
	cmd->short_slot = short_slot_time;
3123 3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136 3137 3138 3139 3140 3141

	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;

3142 3143 3144 3145 3146 3147 3148 3149 3150 3151 3152 3153 3154 3155 3156 3157 3158
	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;
3159

3160 3161
			/* Log exponent of min contention period: 0...15 */
			__u8 log_cw_min;
3162

3163 3164
			/* Adaptive interframe spacing in units of 32us */
			__u8 aifs;
3165

3166 3167 3168 3169
			/* TX queue to configure */
			__u8 txq;
		} sta;
	};
3170
} __packed;
3171 3172 3173 3174 3175 3176 3177 3178 3179 3180

#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
3181 3182 3183
mwl8k_cmd_set_edca_params(struct ieee80211_hw *hw, __u8 qnum,
			  __u16 cw_min, __u16 cw_max,
			  __u8 aifs, __u16 txop)
3184
{
3185
	struct mwl8k_priv *priv = hw->priv;
3186 3187 3188 3189 3190 3191 3192 3193 3194 3195 3196
	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);
3197 3198 3199 3200 3201 3202 3203 3204 3205 3206 3207
	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;
	}
3208 3209 3210 3211 3212 3213 3214 3215

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

	return rc;
}

/*
3216
 * CMD_SET_WMM_MODE.
3217
 */
3218
struct mwl8k_cmd_set_wmm_mode {
3219
	struct mwl8k_cmd_pkt header;
3220
	__le16 action;
3221
} __packed;
3222

3223
static int mwl8k_cmd_set_wmm_mode(struct ieee80211_hw *hw, bool enable)
3224
{
3225 3226
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_cmd_set_wmm_mode *cmd;
3227 3228 3229 3230 3231 3232
	int rc;

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

3233
	cmd->header.code = cpu_to_le16(MWL8K_CMD_SET_WMM_MODE);
3234
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
3235
	cmd->action = cpu_to_le16(!!enable);
3236 3237 3238

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

3240 3241
	if (!rc)
		priv->wmm_enabled = enable;
3242 3243 3244 3245 3246

	return rc;
}

/*
3247
 * CMD_MIMO_CONFIG.
3248
 */
3249 3250 3251 3252 3253
struct mwl8k_cmd_mimo_config {
	struct mwl8k_cmd_pkt header;
	__le32 action;
	__u8 rx_antenna_map;
	__u8 tx_antenna_map;
3254
} __packed;
3255

3256
static int mwl8k_cmd_mimo_config(struct ieee80211_hw *hw, __u8 rx, __u8 tx)
3257
{
3258
	struct mwl8k_cmd_mimo_config *cmd;
3259 3260 3261 3262 3263 3264
	int rc;

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

3265
	cmd->header.code = cpu_to_le16(MWL8K_CMD_MIMO_CONFIG);
3266
	cmd->header.length = cpu_to_le16(sizeof(*cmd));
3267 3268 3269
	cmd->action = cpu_to_le32((u32)MWL8K_CMD_SET);
	cmd->rx_antenna_map = rx;
	cmd->tx_antenna_map = tx;
3270 3271 3272 3273 3274 3275 3276 3277

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

	return rc;
}

/*
3278
 * CMD_USE_FIXED_RATE (STA version).
3279
 */
3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293
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;
3294
} __packed;
3295

3296 3297
#define MWL8K_USE_AUTO_RATE	0x0002
#define MWL8K_UCAST_RATE	0
3298

3299
static int mwl8k_cmd_use_fixed_rate_sta(struct ieee80211_hw *hw)
3300
{
3301
	struct mwl8k_cmd_use_fixed_rate_sta *cmd;
3302 3303 3304 3305 3306 3307 3308 3309
	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));
3310 3311
	cmd->action = cpu_to_le32(MWL8K_USE_AUTO_RATE);
	cmd->rate_type = cpu_to_le32(MWL8K_UCAST_RATE);
3312 3313 3314 3315 3316 3317 3318

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

	return rc;
}

3319 3320 3321 3322 3323 3324 3325 3326 3327 3328 3329 3330 3331 3332 3333 3334 3335
/*
 * 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;
3336
} __packed;
3337 3338 3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359

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

3360 3361 3362 3363 3364 3365
/*
 * CMD_ENABLE_SNIFFER.
 */
struct mwl8k_cmd_enable_sniffer {
	struct mwl8k_cmd_pkt header;
	__le32 action;
3366
} __packed;
3367 3368 3369 3370 3371 3372 3373 3374 3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387 3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398

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];
	};
3399
} __packed;
3400

3401 3402 3403 3404
#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
3405

3406 3407
static int mwl8k_cmd_set_mac_addr(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif, u8 *mac)
3408 3409
{
	struct mwl8k_priv *priv = hw->priv;
3410
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
3411
	struct mwl8k_cmd_set_mac_addr *cmd;
3412
	int mac_type;
3413 3414
	int rc;

3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425 3426 3427
	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;
	}

3428 3429 3430 3431 3432 3433 3434
	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) {
3435
		cmd->mbss.mac_type = cpu_to_le16(mac_type);
3436 3437 3438 3439 3440
		memcpy(cmd->mbss.mac_addr, mac, ETH_ALEN);
	} else {
		memcpy(cmd->mac_addr, mac, ETH_ALEN);
	}

3441
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453
	kfree(cmd);

	return rc;
}

/*
 * CMD_SET_RATEADAPT_MODE.
 */
struct mwl8k_cmd_set_rate_adapt_mode {
	struct mwl8k_cmd_pkt header;
	__le16 action;
	__le16 mode;
3454
} __packed;
3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473 3474 3475

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

3476 3477 3478 3479 3480 3481 3482 3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534
/*
 * 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;
}


3535 3536 3537 3538 3539 3540
/*
 * CMD_BSS_START.
 */
struct mwl8k_cmd_bss_start {
	struct mwl8k_cmd_pkt header;
	__le32 enable;
3541
} __packed;
3542

3543 3544
static int mwl8k_cmd_bss_start(struct ieee80211_hw *hw,
			       struct ieee80211_vif *vif, int enable)
3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556
{
	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);

3557
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3558 3559 3560 3561 3562
	kfree(cmd);

	return rc;
}

3563 3564 3565 3566 3567 3568 3569 3570 3571 3572
/*
 * CMD_BASTREAM.
 */

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

3573
enum ba_stream_action_type {
3574 3575 3576 3577 3578
	MWL8K_BA_CREATE,
	MWL8K_BA_UPDATE,
	MWL8K_BA_DESTROY,
	MWL8K_BA_FLUSH,
	MWL8K_BA_CHECK,
3579
};
3580 3581 3582 3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637 3638 3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708


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

3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731
/*
 * 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;
3732
} __packed;
3733 3734 3735 3736 3737 3738 3739 3740 3741

#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;
3742
	u32 rates;
3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754
	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);
3755 3756 3757 3758 3759
	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);
3760 3761 3762 3763 3764 3765 3766 3767 3768 3769 3770
	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;
	}

3771
	rc = mwl8k_post_pervif_cmd(hw, vif, &cmd->header);
3772 3773 3774 3775 3776
	kfree(cmd);

	return rc;
}

3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787 3788 3789 3790
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);

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

	return rc;
}

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

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

	return rc;
}

3818 3819 3820 3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832
/*
 * 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;

3833
} __packed;
3834 3835 3836 3837 3838 3839 3840 3841 3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852

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];
3853
} __packed;
3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868 3869 3870 3871 3872 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 4000 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

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

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

enum {
	MWL8K_ALG_WEP,
	MWL8K_ALG_TKIP,
	MWL8K_ALG_CCMP,
};

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

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

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

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

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

	return rc;
}

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

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

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

	return 0;
}

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

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

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

	idx = key->keyidx;

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

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

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

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

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

	return rc;
}

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

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

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

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

	cmd->action = cpu_to_le32(MWL8K_ENCR_REMOVE_KEY);

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

	return rc;
}

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

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

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

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

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

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

		mwl8k_vif->is_hw_crypto_enabled = true;

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

		if (rc)
			goto out;

		mwl8k_vif->is_hw_crypto_enabled = false;

	}
out:
	return rc;
}

4086 4087 4088
/*
 * CMD_UPDATE_STADB.
 */
4089 4090 4091 4092
struct ewc_ht_info {
	__le16	control1;
	__le16	control2;
	__le16	control3;
4093
} __packed;
4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121

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;
4122
} __packed;
4123

4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135 4136
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;
4137
} __packed;
4138

4139 4140 4141 4142 4143 4144 4145
#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 已提交
4146
				      struct ieee80211_vif *vif,
4147
				      struct ieee80211_sta *sta)
4148 4149
{
	struct mwl8k_cmd_update_stadb *cmd;
4150
	struct peer_capability_info *p;
4151
	u32 rates;
4152 4153 4154 4155 4156 4157 4158 4159
	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));
4160
	cmd->action = cpu_to_le32(MWL8K_STA_DB_MODIFY_ENTRY);
4161
	memcpy(cmd->peer_addr, sta->addr, ETH_ALEN);
4162

4163 4164 4165
	p = &cmd->peer_info;
	p->peer_type = MWL8K_PEER_TYPE_ACCESSPOINT;
	p->basic_caps = cpu_to_le16(vif->bss_conf.assoc_capability);
4166
	p->ht_support = sta->ht_cap.ht_supported;
4167
	p->ht_caps = cpu_to_le16(sta->ht_cap.cap);
4168 4169
	p->extended_ht_caps = (sta->ht_cap.ampdu_factor & 3) |
		((sta->ht_cap.ampdu_density & 7) << 2);
4170 4171 4172 4173 4174
	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);
4175
	memcpy(p->ht_rates, sta->ht_cap.mcs.rx_mask, 16);
4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197
	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);
4198
	memcpy(cmd->peer_addr, addr, ETH_ALEN);
4199

4200
	rc = mwl8k_post_cmd(hw, &cmd->header);
4201 4202 4203 4204 4205
	kfree(cmd);

	return rc;
}

4206 4207 4208 4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219

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

4220 4221 4222 4223 4224
	if (status & MWL8K_A2H_INT_TX_DONE) {
		status &= ~MWL8K_A2H_INT_TX_DONE;
		tasklet_schedule(&priv->poll_tx_task);
	}

4225
	if (status & MWL8K_A2H_INT_RX_READY) {
4226 4227
		status &= ~MWL8K_A2H_INT_RX_READY;
		tasklet_schedule(&priv->poll_rx_task);
4228 4229
	}

4230 4231 4232 4233 4234
	if (status & MWL8K_A2H_INT_BA_WATCHDOG) {
		status &= ~MWL8K_A2H_INT_BA_WATCHDOG;
		ieee80211_queue_work(hw, &priv->watchdog_ba_handle);
	}

4235 4236 4237
	if (status)
		iowrite32(~status, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);

4238
	if (status & MWL8K_A2H_INT_OPC_DONE) {
4239
		if (priv->hostcmd_wait != NULL)
4240 4241 4242 4243
			complete(priv->hostcmd_wait);
	}

	if (status & MWL8K_A2H_INT_QUEUE_EMPTY) {
4244
		if (!mutex_is_locked(&priv->fw_mutex) &&
4245
		    priv->radio_on && priv->pending_tx_pkts)
4246
			mwl8k_tx_start(priv);
4247 4248 4249 4250 4251
	}

	return IRQ_HANDLED;
}

4252 4253 4254 4255 4256 4257 4258 4259 4260 4261 4262
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);

4263
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280
		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);
	}
}

4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295 4296 4297 4298
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);
	}
}

4299 4300 4301 4302

/*
 * Core driver operations.
 */
4303
static void mwl8k_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
4304 4305 4306 4307
{
	struct mwl8k_priv *priv = hw->priv;
	int index = skb_get_queue_mapping(skb);

4308
	if (!priv->radio_on) {
4309 4310
		wiphy_debug(hw->wiphy,
			    "dropped TX frame since radio disabled\n");
4311
		dev_kfree_skb(skb);
4312
		return;
4313 4314
	}

4315
	mwl8k_txq_xmit(hw, index, skb);
4316 4317 4318 4319 4320 4321 4322
}

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

4323
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
4324 4325
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
4326
		priv->irq = -1;
4327
		wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
4328
		return -EIO;
4329
	}
4330
	priv->irq = priv->pdev->irq;
4331

4332
	/* Enable TX reclaim and RX tasklets.  */
4333
	tasklet_enable(&priv->poll_tx_task);
4334
	tasklet_enable(&priv->poll_rx_task);
4335

4336
	/* Enable interrupts */
4337
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4338 4339
	iowrite32(MWL8K_A2H_EVENTS,
		  priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);
4340

4341 4342
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
4343
		rc = mwl8k_cmd_radio_enable(hw);
4344

4345 4346
		if (!priv->ap_fw) {
			if (!rc)
4347
				rc = mwl8k_cmd_enable_sniffer(hw, 0);
4348

4349 4350 4351 4352 4353 4354 4355
			if (!rc)
				rc = mwl8k_cmd_set_pre_scan(hw);

			if (!rc)
				rc = mwl8k_cmd_set_post_scan(hw,
						"\x00\x00\x00\x00\x00\x00");
		}
4356 4357

		if (!rc)
4358
			rc = mwl8k_cmd_set_rateadapt_mode(hw, 0);
4359

4360
		if (!rc)
4361
			rc = mwl8k_cmd_set_wmm_mode(hw, 0);
4362

4363 4364 4365 4366 4367 4368
		mwl8k_fw_unlock(hw);
	}

	if (rc) {
		iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
		free_irq(priv->pdev->irq, hw);
4369
		priv->irq = -1;
4370
		tasklet_disable(&priv->poll_tx_task);
4371
		tasklet_disable(&priv->poll_rx_task);
4372
	}
4373 4374 4375 4376 4377 4378 4379 4380 4381

	return rc;
}

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

4382
	mwl8k_cmd_radio_disable(hw);
4383 4384 4385 4386 4387

	ieee80211_stop_queues(hw);

	/* Disable interrupts */
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
4388 4389 4390 4391
	if (priv->irq != -1) {
		free_irq(priv->pdev->irq, hw);
		priv->irq = -1;
	}
4392 4393 4394

	/* Stop finalize join worker */
	cancel_work_sync(&priv->finalize_join_worker);
4395
	cancel_work_sync(&priv->watchdog_ba_handle);
4396 4397 4398
	if (priv->beacon_skb != NULL)
		dev_kfree_skb(priv->beacon_skb);

4399
	/* Stop TX reclaim and RX tasklets.  */
4400
	tasklet_disable(&priv->poll_tx_task);
4401
	tasklet_disable(&priv->poll_rx_task);
4402 4403

	/* Return all skbs to mac80211 */
4404
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
4405
		mwl8k_txq_reclaim(hw, i, INT_MAX, 1);
4406 4407
}

4408 4409
static int mwl8k_reload_firmware(struct ieee80211_hw *hw, char *fw_image);

4410
static int mwl8k_add_interface(struct ieee80211_hw *hw,
4411
			       struct ieee80211_vif *vif)
4412 4413 4414
{
	struct mwl8k_priv *priv = hw->priv;
	struct mwl8k_vif *mwl8k_vif;
4415
	u32 macids_supported;
4416 4417
	int macid, rc;
	struct mwl8k_device_info *di;
4418

4419 4420 4421
	/*
	 * Reject interface creation if sniffer mode is active, as
	 * STA operation is mutually exclusive with hardware sniffer
4422
	 * mode.  (Sniffer mode is only used on STA firmware.)
4423 4424
	 */
	if (priv->sniffer_enabled) {
4425 4426
		wiphy_info(hw->wiphy,
			   "unable to create STA interface because sniffer mode is enabled\n");
4427 4428 4429
		return -EINVAL;
	}

4430
	di = priv->device_info;
4431 4432
	switch (vif->type) {
	case NL80211_IFTYPE_AP:
4433 4434 4435 4436 4437 4438 4439 4440
		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;
		}
4441 4442 4443
		macids_supported = priv->ap_macids_supported;
		break;
	case NL80211_IFTYPE_STATION:
4444 4445 4446 4447 4448 4449 4450 4451
		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;
		}
4452 4453 4454 4455 4456 4457 4458 4459 4460 4461
		macids_supported = priv->sta_macids_supported;
		break;
	default:
		return -EINVAL;
	}

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

4462
	/* Setup driver private area. */
4463
	mwl8k_vif = MWL8K_VIF(vif);
4464
	memset(mwl8k_vif, 0, sizeof(*mwl8k_vif));
4465
	mwl8k_vif->vif = vif;
4466
	mwl8k_vif->macid = macid;
4467
	mwl8k_vif->seqno = 0;
4468 4469
	memcpy(mwl8k_vif->bssid, vif->addr, ETH_ALEN);
	mwl8k_vif->is_hw_crypto_enabled = false;
4470

4471 4472 4473 4474 4475 4476
	/* 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);

4477
	priv->macids_used |= 1 << mwl8k_vif->macid;
4478
	list_add_tail(&mwl8k_vif->list, &priv->vif_list);
4479 4480 4481 4482 4483

	return 0;
}

static void mwl8k_remove_interface(struct ieee80211_hw *hw,
4484
				   struct ieee80211_vif *vif)
4485 4486
{
	struct mwl8k_priv *priv = hw->priv;
4487
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
4488

4489 4490 4491
	if (priv->ap_fw)
		mwl8k_cmd_set_new_stn_del(hw, vif, vif->addr);

4492
	mwl8k_cmd_set_mac_addr(hw, vif, "\x00\x00\x00\x00\x00\x00");
4493

4494
	priv->macids_used &= ~(1 << mwl8k_vif->macid);
4495
	list_del(&mwl8k_vif->list);
4496 4497
}

4498
static int mwl8k_config(struct ieee80211_hw *hw, u32 changed)
4499 4500 4501
{
	struct ieee80211_conf *conf = &hw->conf;
	struct mwl8k_priv *priv = hw->priv;
4502
	int rc;
4503

L
Lennert Buytenhek 已提交
4504
	if (conf->flags & IEEE80211_CONF_IDLE) {
4505
		mwl8k_cmd_radio_disable(hw);
4506
		return 0;
L
Lennert Buytenhek 已提交
4507 4508
	}

4509 4510 4511
	rc = mwl8k_fw_lock(hw);
	if (rc)
		return rc;
4512

4513
	rc = mwl8k_cmd_radio_enable(hw);
4514 4515
	if (rc)
		goto out;
4516

4517
	rc = mwl8k_cmd_set_rf_channel(hw, conf);
4518 4519 4520
	if (rc)
		goto out;

4521 4522 4523
	if (conf->power_level > 18)
		conf->power_level = 18;

4524
	if (priv->ap_fw) {
4525 4526 4527 4528 4529 4530

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

4532 4533 4534 4535 4536 4537 4538
		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");

4539
	} else {
4540 4541 4542
		rc = mwl8k_cmd_rf_tx_power(hw, conf->power_level);
		if (rc)
			goto out;
4543 4544
		rc = mwl8k_cmd_mimo_config(hw, 0x7, 0x7);
	}
4545

4546 4547
out:
	mwl8k_fw_unlock(hw);
4548

4549
	return rc;
4550 4551
}

4552 4553 4554
static void
mwl8k_bss_info_changed_sta(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			   struct ieee80211_bss_conf *info, u32 changed)
4555 4556
{
	struct mwl8k_priv *priv = hw->priv;
4557
	u32 ap_legacy_rates = 0;
4558
	u8 ap_mcs_rates[16];
4559 4560
	int rc;

4561
	if (mwl8k_fw_lock(hw))
4562
		return;
4563

4564 4565 4566 4567 4568
	/*
	 * 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;
4569

4570
	/*
4571
	 * Get the AP's legacy and MCS rates.
4572
	 */
4573
	if (vif->bss_conf.assoc) {
L
Lennert Buytenhek 已提交
4574
		struct ieee80211_sta *ap;
4575

L
Lennert Buytenhek 已提交
4576 4577
		rcu_read_lock();

4578 4579 4580
		ap = ieee80211_find_sta(vif, vif->bss_conf.bssid);
		if (ap == NULL) {
			rcu_read_unlock();
L
Lennert Buytenhek 已提交
4581
			goto out;
4582 4583
		}

4584 4585 4586 4587 4588 4589
		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;
		}
4590
		memcpy(ap_mcs_rates, ap->ht_cap.mcs.rx_mask, 16);
4591 4592 4593

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

4595
	if ((changed & BSS_CHANGED_ASSOC) && vif->bss_conf.assoc) {
4596
		rc = mwl8k_cmd_set_rate(hw, vif, ap_legacy_rates, ap_mcs_rates);
4597 4598
		if (rc)
			goto out;
4599

4600
		rc = mwl8k_cmd_use_fixed_rate_sta(hw);
4601 4602
		if (rc)
			goto out;
4603
	}
4604

4605
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4606 4607
		rc = mwl8k_set_radio_preamble(hw,
				vif->bss_conf.use_short_preamble);
4608 4609
		if (rc)
			goto out;
4610
	}
4611

4612
	if (changed & BSS_CHANGED_ERP_SLOT) {
4613
		rc = mwl8k_cmd_set_slot(hw, vif->bss_conf.use_short_slot);
4614 4615
		if (rc)
			goto out;
4616
	}
4617

4618 4619 4620
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_ERP_CTS_PROT |
			BSS_CHANGED_HT))) {
4621
		rc = mwl8k_cmd_set_aid(hw, vif, ap_legacy_rates);
4622 4623
		if (rc)
			goto out;
4624
	}
4625

4626 4627
	if (vif->bss_conf.assoc &&
	    (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_BEACON_INT))) {
4628 4629 4630 4631
		/*
		 * Finalize the join.  Tell rx handler to process
		 * next beacon from our BSSID.
		 */
4632
		memcpy(priv->capture_bssid, vif->bss_conf.bssid, ETH_ALEN);
4633 4634 4635
		priv->capture_beacon = true;
	}

4636 4637
out:
	mwl8k_fw_unlock(hw);
4638 4639
}

4640 4641 4642 4643 4644 4645 4646 4647 4648 4649 4650 4651 4652 4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663 4664 4665
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);
4666 4667 4668 4669 4670 4671 4672
		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;
4673 4674 4675 4676 4677 4678 4679 4680 4681

		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) {
4682
			mwl8k_cmd_set_beacon(hw, vif, skb->data, skb->len);
4683 4684 4685 4686 4687
			kfree_skb(skb);
		}
	}

	if (changed & BSS_CHANGED_BEACON_ENABLED)
4688
		mwl8k_cmd_bss_start(hw, vif, info->enable_beacon);
4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704 4705

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

4706
static u64 mwl8k_prepare_multicast(struct ieee80211_hw *hw,
4707
				   struct netdev_hw_addr_list *mc_list)
4708 4709 4710
{
	struct mwl8k_cmd_pkt *cmd;

L
Lennert Buytenhek 已提交
4711 4712 4713 4714 4715 4716 4717
	/*
	 * 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().
	 */
4718
	cmd = __mwl8k_cmd_mac_multicast_adr(hw, 0, mc_list);
4719 4720 4721 4722

	return (unsigned long)cmd;
}

4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734
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.
	 */
4735
	if (!list_empty(&priv->vif_list)) {
4736
		if (net_ratelimit())
4737 4738
			wiphy_info(hw->wiphy,
				   "not enabling sniffer mode because STA interface is active\n");
4739 4740 4741 4742
		return 0;
	}

	if (!priv->sniffer_enabled) {
4743
		if (mwl8k_cmd_enable_sniffer(hw, 1))
4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754
			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;
}

4755 4756 4757 4758 4759 4760 4761 4762
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;
}

4763 4764 4765 4766 4767 4768
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;
4769 4770
	struct mwl8k_cmd_pkt *cmd = (void *)(unsigned long)multicast;

4771 4772 4773 4774 4775 4776 4777 4778 4779 4780
	/*
	 * 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;
	}

4781 4782 4783 4784 4785 4786 4787 4788 4789
	/*
	 * 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;
	}
4790

4791
	/* Clear unsupported feature flags */
L
Lennert Buytenhek 已提交
4792
	*total_flags &= FIF_ALLMULTI | FIF_BCN_PRBRESP_PROMISC;
4793

4794 4795
	if (mwl8k_fw_lock(hw)) {
		kfree(cmd);
4796
		return;
4797
	}
4798

4799
	if (priv->sniffer_enabled) {
4800
		mwl8k_cmd_enable_sniffer(hw, 0);
4801 4802 4803
		priv->sniffer_enabled = false;
	}

4804
	if (changed_flags & FIF_BCN_PRBRESP_PROMISC) {
4805 4806 4807 4808
		if (*total_flags & FIF_BCN_PRBRESP_PROMISC) {
			/*
			 * Disable the BSS filter.
			 */
4809
			mwl8k_cmd_set_pre_scan(hw);
4810
		} else {
4811
			struct mwl8k_vif *mwl8k_vif;
4812
			const u8 *bssid;
4813

4814 4815 4816 4817 4818 4819 4820 4821
			/*
			 * 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).
			 */
4822 4823 4824 4825 4826
			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";
4827

4828
			mwl8k_cmd_set_post_scan(hw, bssid);
4829 4830 4831
		}
	}

L
Lennert Buytenhek 已提交
4832 4833 4834 4835 4836 4837 4838 4839
	/*
	 * 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);
4840
		cmd = __mwl8k_cmd_mac_multicast_adr(hw, 1, NULL);
L
Lennert Buytenhek 已提交
4841 4842 4843 4844 4845
	}

	if (cmd != NULL) {
		mwl8k_post_cmd(hw, cmd);
		kfree(cmd);
4846
	}
4847

4848
	mwl8k_fw_unlock(hw);
4849 4850 4851 4852
}

static int mwl8k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
{
L
Lennert Buytenhek 已提交
4853
	return mwl8k_cmd_set_rts_threshold(hw, value);
4854 4855
}

4856 4857 4858
static int mwl8k_sta_remove(struct ieee80211_hw *hw,
			    struct ieee80211_vif *vif,
			    struct ieee80211_sta *sta)
4859 4860 4861
{
	struct mwl8k_priv *priv = hw->priv;

4862 4863 4864 4865
	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);
4866 4867
}

4868 4869 4870
static int mwl8k_sta_add(struct ieee80211_hw *hw,
			 struct ieee80211_vif *vif,
			 struct ieee80211_sta *sta)
4871 4872
{
	struct mwl8k_priv *priv = hw->priv;
4873
	int ret;
4874 4875 4876
	int i;
	struct mwl8k_vif *mwl8k_vif = MWL8K_VIF(vif);
	struct ieee80211_key_conf *key;
4877

4878 4879 4880 4881
	if (!priv->ap_fw) {
		ret = mwl8k_cmd_update_stadb_add(hw, vif, sta);
		if (ret >= 0) {
			MWL8K_STA(sta)->peer_id = ret;
4882 4883
			if (sta->ht_cap.ht_supported)
				MWL8K_STA(sta)->is_ampdu_allowed = true;
4884
			ret = 0;
4885
		}
4886

4887 4888
	} else {
		ret = mwl8k_cmd_set_new_stn_add(hw, vif, sta);
4889
	}
4890

4891 4892 4893 4894 4895
	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);
	}
4896
	return ret;
4897 4898
}

4899 4900 4901
static int mwl8k_conf_tx(struct ieee80211_hw *hw, u16 queue,
			 const struct ieee80211_tx_queue_params *params)
{
4902
	struct mwl8k_priv *priv = hw->priv;
4903 4904
	int rc;

4905 4906
	rc = mwl8k_fw_lock(hw);
	if (!rc) {
4907
		BUG_ON(queue > MWL8K_TX_WMM_QUEUES - 1);
4908 4909
		memcpy(&priv->wmm_params[queue], params, sizeof(*params));

4910
		if (!priv->wmm_enabled)
4911
			rc = mwl8k_cmd_set_wmm_mode(hw, 1);
4912

4913
		if (!rc) {
4914
			int q = MWL8K_TX_WMM_QUEUES - 1 - queue;
4915
			rc = mwl8k_cmd_set_edca_params(hw, q,
4916 4917 4918 4919
						       params->cw_min,
						       params->cw_max,
						       params->aifs,
						       params->txop);
4920
		}
4921 4922

		mwl8k_fw_unlock(hw);
4923
	}
4924

4925 4926 4927 4928 4929 4930
	return rc;
}

static int mwl8k_get_stats(struct ieee80211_hw *hw,
			   struct ieee80211_low_level_stats *stats)
{
4931
	return mwl8k_cmd_get_stat(hw, stats);
4932 4933
}

4934 4935 4936 4937 4938 4939 4940 4941 4942 4943 4944 4945 4946 4947 4948 4949
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 已提交
4950 4951
#define MAX_AMPDU_ATTEMPTS 5

4952 4953 4954
static int
mwl8k_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		   enum ieee80211_ampdu_mlme_action action,
4955 4956
		   struct ieee80211_sta *sta, u16 tid, u16 *ssn,
		   u8 buf_size)
4957
{
N
Nishant Sarmukadam 已提交
4958 4959 4960 4961 4962 4963 4964 4965 4966 4967 4968 4969

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

4970 4971 4972
	switch (action) {
	case IEEE80211_AMPDU_RX_START:
	case IEEE80211_AMPDU_RX_STOP:
N
Nishant Sarmukadam 已提交
4973 4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 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
		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;

5056
	default:
N
Nishant Sarmukadam 已提交
5057
		rc = -ENOTSUPP;
5058
	}
N
Nishant Sarmukadam 已提交
5059 5060 5061

	spin_unlock(&priv->stream_lock);
	return rc;
5062 5063
}

5064 5065 5066 5067 5068 5069 5070 5071
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,
5072
	.prepare_multicast	= mwl8k_prepare_multicast,
5073
	.configure_filter	= mwl8k_configure_filter,
5074
	.set_key                = mwl8k_set_key,
5075
	.set_rts_threshold	= mwl8k_set_rts_threshold,
5076 5077
	.sta_add		= mwl8k_sta_add,
	.sta_remove		= mwl8k_sta_remove,
5078 5079
	.conf_tx		= mwl8k_conf_tx,
	.get_stats		= mwl8k_get_stats,
5080
	.get_survey		= mwl8k_get_survey,
5081
	.ampdu_action		= mwl8k_ampdu_action,
5082 5083 5084 5085 5086 5087 5088
};

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;
5089 5090 5091 5092 5093 5094 5095 5096
	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];
5097

5098
	mwl8k_cmd_finalize_join(priv->hw, skb->data, skb->len, dtim_period);
5099

5100
	dev_kfree_skb(skb);
5101 5102 5103
	priv->beacon_skb = NULL;
}

5104
enum {
5105 5106
	MWL8363 = 0,
	MWL8687,
5107
	MWL8366,
5108 5109
};

5110
#define MWL8K_8366_AP_FW_API 2
5111 5112 5113
#define _MWL8K_8366_AP_FW(api) "mwl8k/fmimage_8366_ap-" #api ".fw"
#define MWL8K_8366_AP_FW(api) _MWL8K_8366_AP_FW(api)

5114
static struct mwl8k_device_info mwl8k_info_tbl[] __devinitdata = {
5115 5116 5117
	[MWL8363] = {
		.part_name	= "88w8363",
		.helper_image	= "mwl8k/helper_8363.fw",
5118
		.fw_image_sta	= "mwl8k/fmimage_8363.fw",
5119
	},
5120
	[MWL8687] = {
5121 5122
		.part_name	= "88w8687",
		.helper_image	= "mwl8k/helper_8687.fw",
5123
		.fw_image_sta	= "mwl8k/fmimage_8687.fw",
5124
	},
5125
	[MWL8366] = {
5126 5127
		.part_name	= "88w8366",
		.helper_image	= "mwl8k/helper_8366.fw",
5128
		.fw_image_sta	= "mwl8k/fmimage_8366.fw",
5129 5130
		.fw_image_ap	= MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API),
		.fw_api_ap	= MWL8K_8366_AP_FW_API,
5131
		.ap_rxd_ops	= &rxd_8366_ap_ops,
5132
	},
5133 5134
};

5135 5136 5137 5138 5139 5140
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");
5141
MODULE_FIRMWARE(MWL8K_8366_AP_FW(MWL8K_8366_AP_FW_API));
5142

5143
static DEFINE_PCI_DEVICE_TABLE(mwl8k_pci_id_table) = {
5144
	{ PCI_VDEVICE(MARVELL, 0x2a0a), .driver_data = MWL8363, },
5145 5146
	{ PCI_VDEVICE(MARVELL, 0x2a0c), .driver_data = MWL8363, },
	{ PCI_VDEVICE(MARVELL, 0x2a24), .driver_data = MWL8363, },
5147 5148 5149
	{ PCI_VDEVICE(MARVELL, 0x2a2b), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a30), .driver_data = MWL8687, },
	{ PCI_VDEVICE(MARVELL, 0x2a40), .driver_data = MWL8366, },
5150
	{ PCI_VDEVICE(MARVELL, 0x2a43), .driver_data = MWL8366, },
5151
	{ },
5152 5153 5154
};
MODULE_DEVICE_TABLE(pci, mwl8k_pci_id_table);

5155 5156 5157 5158 5159 5160 5161 5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 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
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)
5248
{
5249
	struct mwl8k_priv *priv = hw->priv;
5250
	int rc;
5251 5252 5253 5254 5255

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

	/* Ask userland hotplug daemon for the device firmware */
5256
	rc = mwl8k_request_firmware(priv, fw_image, nowait);
5257
	if (rc) {
5258
		wiphy_err(hw->wiphy, "Firmware files not found\n");
5259
		return rc;
5260 5261
	}

5262 5263 5264
	if (nowait)
		return rc;

5265 5266
	/* Load firmware into hardware */
	rc = mwl8k_load_firmware(hw);
5267
	if (rc)
5268
		wiphy_err(hw->wiphy, "Cannot start firmware\n");
5269 5270 5271 5272

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

5273 5274 5275
	return rc;
}

5276 5277 5278 5279 5280 5281
static int mwl8k_init_txqs(struct ieee80211_hw *hw)
{
	struct mwl8k_priv *priv = hw->priv;
	int rc = 0;
	int i;

5282
	for (i = 0; i < mwl8k_tx_queues(priv); i++) {
5283 5284 5285 5286 5287 5288 5289 5290 5291 5292
		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;
}

5293 5294 5295 5296 5297 5298
/* 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;
5299

5300
	if (priv->ap_fw) {
5301
		priv->rxd_ops = priv->device_info->ap_rxd_ops;
5302
		if (priv->rxd_ops == NULL) {
5303 5304
			wiphy_err(hw->wiphy,
				  "Driver does not have AP firmware image support for this hardware\n");
5305 5306 5307
			goto err_stop_firmware;
		}
	} else {
5308
		priv->rxd_ops = &rxd_sta_ops;
5309
	}
5310 5311 5312 5313 5314

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

5315 5316
	rc = mwl8k_rxq_init(hw, 0);
	if (rc)
5317
		goto err_stop_firmware;
5318 5319
	rxq_refill(hw, 0, INT_MAX);

5320 5321 5322 5323 5324 5325
	/* 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.
	 */
5326
	priv->num_ampdu_queues = 0;
5327 5328
	if (!priv->ap_fw) {
		rc = mwl8k_init_txqs(hw);
5329 5330 5331 5332 5333
		if (rc)
			goto err_free_queues;
	}

	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS);
5334
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
5335 5336
	iowrite32(MWL8K_A2H_INT_TX_DONE|MWL8K_A2H_INT_RX_READY|
		  MWL8K_A2H_INT_BA_WATCHDOG,
5337
		  priv->regs + MWL8K_HIU_A2H_INTERRUPT_CLEAR_SEL);
5338 5339
	iowrite32(MWL8K_A2H_INT_OPC_DONE,
		  priv->regs + MWL8K_HIU_A2H_INTERRUPT_STATUS_MASK);
5340

5341
	rc = request_irq(priv->pdev->irq, mwl8k_interrupt,
5342 5343
			 IRQF_SHARED, MWL8K_NAME, hw);
	if (rc) {
5344
		wiphy_err(hw->wiphy, "failed to register IRQ handler\n");
5345 5346 5347
		goto err_free_queues;
	}

5348 5349
	memset(priv->ampdu, 0, sizeof(priv->ampdu));

5350 5351
	/*
	 * Temporarily enable interrupts.  Initial firmware host
L
Lennert Buytenhek 已提交
5352
	 * commands use interrupts and avoid polling.  Disable
5353 5354
	 * interrupts when done.
	 */
5355
	iowrite32(MWL8K_A2H_EVENTS, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
5356 5357

	/* Get config data, mac addrs etc */
5358 5359
	if (priv->ap_fw) {
		rc = mwl8k_cmd_get_hw_spec_ap(hw);
5360 5361
		if (!rc)
			rc = mwl8k_init_txqs(hw);
5362 5363 5364 5365 5366
		if (!rc)
			rc = mwl8k_cmd_set_hw_spec(hw);
	} else {
		rc = mwl8k_cmd_get_hw_spec_sta(hw);
	}
5367
	if (rc) {
5368
		wiphy_err(hw->wiphy, "Cannot initialise firmware\n");
5369
		goto err_free_irq;
5370 5371 5372
	}

	/* Turn radio off */
5373
	rc = mwl8k_cmd_radio_disable(hw);
5374
	if (rc) {
5375
		wiphy_err(hw->wiphy, "Cannot disable\n");
5376
		goto err_free_irq;
5377 5378
	}

5379
	/* Clear MAC address */
5380
	rc = mwl8k_cmd_set_mac_addr(hw, NULL, "\x00\x00\x00\x00\x00\x00");
5381
	if (rc) {
5382
		wiphy_err(hw->wiphy, "Cannot clear MAC address\n");
5383
		goto err_free_irq;
5384 5385
	}

5386 5387 5388 5389
	/* Disable interrupts */
	iowrite32(0, priv->regs + MWL8K_HIU_A2H_INTERRUPT_MASK);
	free_irq(priv->pdev->irq, hw);

5390 5391 5392 5393 5394 5395
	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);
5396 5397 5398 5399 5400 5401 5402 5403

	return 0;

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

err_free_queues:
5404
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5405 5406 5407
		mwl8k_txq_deinit(hw, i);
	mwl8k_rxq_deinit(hw, 0);

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

5426
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5427 5428
		mwl8k_txq_deinit(hw, i);

5429
	rc = mwl8k_init_firmware(hw, fw_image, false);
5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444
	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;

5445
	for (i = 0; i < MWL8K_TX_WMM_QUEUES; i++) {
5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462
		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;

5463 5464 5465 5466 5467 5468 5469
	rc = mwl8k_load_firmware(hw);
	mwl8k_release_firmware(priv);
	if (rc) {
		wiphy_err(hw->wiphy, "Cannot start firmware\n");
		return rc;
	}

5470 5471 5472 5473 5474 5475 5476 5477 5478
	/*
	 * Extra headroom is the size of the required DMA header
	 * minus the size of the smallest 802.11 frame (CTS frame).
	 */
	hw->extra_tx_headroom =
		sizeof(struct mwl8k_dma_data) - sizeof(struct ieee80211_cts);

	hw->channel_change_time = 10;

5479
	hw->queues = MWL8K_TX_WMM_QUEUES;
5480 5481

	/* Set rssi values to dBm */
5482
	hw->flags |= IEEE80211_HW_SIGNAL_DBM | IEEE80211_HW_HAS_RATE_CONTROL;
5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494
	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);
5495 5496
	/* Handle watchdog ba events */
	INIT_WORK(&priv->watchdog_ba_handle, mwl8k_watchdog_ba_events);
5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515

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

5516 5517
	spin_lock_init(&priv->stream_lock);

5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538
	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:
5539
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5540 5541 5542
		mwl8k_txq_deinit(hw, i);
	mwl8k_rxq_deinit(hw, 0);

5543
err_free_cookie:
5544 5545 5546 5547
	if (priv->cookie != NULL)
		pci_free_consistent(priv->pdev, 4,
				priv->cookie, priv->cookie_dma);

5548 5549 5550 5551 5552 5553 5554 5555
	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;
5556
	struct mwl8k_device_info *di;
5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 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
	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;
		}
	}

5617
	/*
5618 5619 5620
	 * 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.
5621
	 */
5622
	init_completion(&priv->firmware_loading_complete);
5623
	di = priv->device_info;
5624 5625 5626 5627 5628 5629 5630
	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) {
5631
		printk(KERN_WARNING "AP fw is unavailable.  Using STA fw.");
5632
		priv->fw_pref = di->fw_image_sta;
5633 5634
	} else if (!ap_mode_default && !di->fw_image_sta && di->fw_image_ap) {
		printk(KERN_WARNING "STA fw is unavailable.  Using AP fw.");
5635 5636 5637
		priv->fw_pref = di->fw_image_ap;
	}
	rc = mwl8k_init_firmware(hw, priv->fw_pref, true);
5638 5639
	if (rc)
		goto err_stop_firmware;
5640
	return rc;
5641

5642 5643 5644 5645
err_stop_firmware:
	mwl8k_hw_reset(priv);

err_iounmap:
5646 5647 5648
	if (priv->regs != NULL)
		pci_iounmap(pdev, priv->regs);

L
Lennert Buytenhek 已提交
5649 5650 5651
	if (priv->sram != NULL)
		pci_iounmap(pdev, priv->sram);

5652 5653 5654 5655 5656
	pci_set_drvdata(pdev, NULL);
	ieee80211_free_hw(hw);

err_free_reg:
	pci_release_regions(pdev);
5657 5658

err_disable_device:
5659 5660 5661 5662 5663
	pci_disable_device(pdev);

	return rc;
}

5664
static void __devexit mwl8k_shutdown(struct pci_dev *pdev)
5665 5666 5667 5668
{
	printk(KERN_ERR "===>%s(%u)\n", __func__, __LINE__);
}

5669
static void __devexit mwl8k_remove(struct pci_dev *pdev)
5670 5671 5672 5673 5674 5675 5676 5677 5678
{
	struct ieee80211_hw *hw = pci_get_drvdata(pdev);
	struct mwl8k_priv *priv;
	int i;

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

5679 5680 5681 5682 5683 5684 5685
	wait_for_completion(&priv->firmware_loading_complete);

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

5686 5687
	ieee80211_stop_queues(hw);

5688 5689
	ieee80211_unregister_hw(hw);

5690
	/* Remove TX reclaim and RX tasklets.  */
5691
	tasklet_kill(&priv->poll_tx_task);
5692
	tasklet_kill(&priv->poll_rx_task);
5693 5694 5695 5696 5697

	/* Stop hardware */
	mwl8k_hw_reset(priv);

	/* Return all skbs to mac80211 */
5698
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5699
		mwl8k_txq_reclaim(hw, i, INT_MAX, 1);
5700

5701
	for (i = 0; i < mwl8k_tx_queues(priv); i++)
5702 5703 5704 5705
		mwl8k_txq_deinit(hw, i);

	mwl8k_rxq_deinit(hw, 0);

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

5708
unmap:
5709
	pci_iounmap(pdev, priv->regs);
L
Lennert Buytenhek 已提交
5710
	pci_iounmap(pdev, priv->sram);
5711 5712 5713 5714 5715 5716 5717 5718
	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,
5719
	.id_table	= mwl8k_pci_id_table,
5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736
	.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 已提交
5737 5738 5739 5740 5741

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