main.c 132.5 KB
Newer Older
1

L
Luciano Coelho 已提交
2 3 4
/*
 * This file is part of wl1271
 *
J
Juuso Oikarinen 已提交
5
 * Copyright (C) 2008-2010 Nokia Corporation
L
Luciano Coelho 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
 *
 * Contact: Luciano Coelho <luciano.coelho@nokia.com>
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * version 2 as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA
 *
 */

#include <linux/module.h>
#include <linux/firmware.h>
#include <linux/delay.h>
#include <linux/spi/spi.h>
#include <linux/crc32.h>
#include <linux/etherdevice.h>
31
#include <linux/vmalloc.h>
32
#include <linux/platform_device.h>
33
#include <linux/slab.h>
34
#include <linux/wl12xx.h>
35
#include <linux/sched.h>
36
#include <linux/interrupt.h>
L
Luciano Coelho 已提交
37

38
#include "wlcore.h"
39
#include "debug.h"
L
Luciano Coelho 已提交
40
#include "wl12xx_80211.h"
S
Shahar Levi 已提交
41 42 43 44 45 46 47 48 49 50 51
#include "io.h"
#include "event.h"
#include "tx.h"
#include "rx.h"
#include "ps.h"
#include "init.h"
#include "debugfs.h"
#include "cmd.h"
#include "boot.h"
#include "testmode.h"
#include "scan.h"
52
#include "hw_ops.h"
L
Luciano Coelho 已提交
53

54 55
#define WL1271_BOOT_RETRIES 3

56
#define WL1271_BOOT_RETRIES 3
57

58
static char *fwlog_param;
59
static bool bug_on_recovery;
60
static bool no_recovery;
61

62
static void __wl1271_op_remove_interface(struct wl1271 *wl,
E
Eliad Peller 已提交
63
					 struct ieee80211_vif *vif,
64
					 bool reset_tx_queues);
E
Eliad Peller 已提交
65
static void wl1271_op_stop(struct ieee80211_hw *hw);
66
static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif);
67

68 69
static int wl12xx_set_authorized(struct wl1271 *wl,
				 struct wl12xx_vif *wlvif)
70 71
{
	int ret;
E
Eliad Peller 已提交
72

73 74 75 76
	if (WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS))
		return -EINVAL;

	if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
77 78
		return 0;

79
	if (test_and_set_bit(WLVIF_FLAG_STA_STATE_SENT, &wlvif->flags))
80 81
		return 0;

E
Eliad Peller 已提交
82
	ret = wl12xx_cmd_set_peer_state(wl, wlvif->sta.hlid);
83 84 85
	if (ret < 0)
		return ret;

E
Eliad Peller 已提交
86
	wl12xx_croc(wl, wlvif->role_id);
87

88 89 90
	wl1271_info("Association completed.");
	return 0;
}
91

92
static int wl1271_reg_notify(struct wiphy *wiphy,
93 94
			     struct regulatory_request *request)
{
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113
	struct ieee80211_supported_band *band;
	struct ieee80211_channel *ch;
	int i;

	band = wiphy->bands[IEEE80211_BAND_5GHZ];
	for (i = 0; i < band->n_channels; i++) {
		ch = &band->channels[i];
		if (ch->flags & IEEE80211_CHAN_DISABLED)
			continue;

		if (ch->flags & IEEE80211_CHAN_RADAR)
			ch->flags |= IEEE80211_CHAN_NO_IBSS |
				     IEEE80211_CHAN_PASSIVE_SCAN;

	}

	return 0;
}

E
Eliad Peller 已提交
114 115
static int wl1271_set_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif,
				   bool enable)
116 117 118 119
{
	int ret = 0;

	/* we should hold wl->mutex */
E
Eliad Peller 已提交
120
	ret = wl1271_acx_ps_rx_streaming(wl, wlvif, enable);
121 122 123 124
	if (ret < 0)
		goto out;

	if (enable)
125
		set_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
126
	else
127
		clear_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
128 129 130 131 132 133 134 135
out:
	return ret;
}

/*
 * this function is being called when the rx_streaming interval
 * has beed changed or rx_streaming should be disabled
 */
E
Eliad Peller 已提交
136
int wl1271_recalc_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif)
137 138 139 140 141
{
	int ret = 0;
	int period = wl->conf.rx_streaming.interval;

	/* don't reconfigure if rx_streaming is disabled */
142
	if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
143 144 145 146
		goto out;

	/* reconfigure/disable according to new streaming_period */
	if (period &&
147
	    test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
148 149
	    (wl->conf.rx_streaming.always ||
	     test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
E
Eliad Peller 已提交
150
		ret = wl1271_set_rx_streaming(wl, wlvif, true);
151
	else {
E
Eliad Peller 已提交
152
		ret = wl1271_set_rx_streaming(wl, wlvif, false);
153
		/* don't cancel_work_sync since we might deadlock */
E
Eliad Peller 已提交
154
		del_timer_sync(&wlvif->rx_streaming_timer);
155 156 157 158 159 160 161 162
	}
out:
	return ret;
}

static void wl1271_rx_streaming_enable_work(struct work_struct *work)
{
	int ret;
E
Eliad Peller 已提交
163 164 165
	struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
						rx_streaming_enable_work);
	struct wl1271 *wl = wlvif->wl;
166 167 168

	mutex_lock(&wl->mutex);

169
	if (test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags) ||
170
	    !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
171 172 173 174 175 176 177 178 179 180 181
	    (!wl->conf.rx_streaming.always &&
	     !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
		goto out;

	if (!wl->conf.rx_streaming.interval)
		goto out;

	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

E
Eliad Peller 已提交
182
	ret = wl1271_set_rx_streaming(wl, wlvif, true);
183 184 185 186
	if (ret < 0)
		goto out_sleep;

	/* stop it after some time of inactivity */
E
Eliad Peller 已提交
187
	mod_timer(&wlvif->rx_streaming_timer,
188 189 190 191 192 193 194 195 196 197 198
		  jiffies + msecs_to_jiffies(wl->conf.rx_streaming.duration));

out_sleep:
	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
}

static void wl1271_rx_streaming_disable_work(struct work_struct *work)
{
	int ret;
E
Eliad Peller 已提交
199 200 201
	struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
						rx_streaming_disable_work);
	struct wl1271 *wl = wlvif->wl;
202 203 204

	mutex_lock(&wl->mutex);

205
	if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
206 207 208 209 210 211
		goto out;

	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

E
Eliad Peller 已提交
212
	ret = wl1271_set_rx_streaming(wl, wlvif, false);
213 214 215 216 217 218 219 220 221 222 223
	if (ret)
		goto out_sleep;

out_sleep:
	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
}

static void wl1271_rx_streaming_timer(unsigned long data)
{
E
Eliad Peller 已提交
224 225 226
	struct wl12xx_vif *wlvif = (struct wl12xx_vif *)data;
	struct wl1271 *wl = wlvif->wl;
	ieee80211_queue_work(wl->hw, &wlvif->rx_streaming_disable_work);
227 228
}

A
Arik Nemtsov 已提交
229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302
/* wl->mutex must be taken */
void wl12xx_rearm_tx_watchdog_locked(struct wl1271 *wl)
{
	/* if the watchdog is not armed, don't do anything */
	if (wl->tx_allocated_blocks == 0)
		return;

	cancel_delayed_work(&wl->tx_watchdog_work);
	ieee80211_queue_delayed_work(wl->hw, &wl->tx_watchdog_work,
		msecs_to_jiffies(wl->conf.tx.tx_watchdog_timeout));
}

static void wl12xx_tx_watchdog_work(struct work_struct *work)
{
	struct delayed_work *dwork;
	struct wl1271 *wl;

	dwork = container_of(work, struct delayed_work, work);
	wl = container_of(dwork, struct wl1271, tx_watchdog_work);

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF))
		goto out;

	/* Tx went out in the meantime - everything is ok */
	if (unlikely(wl->tx_allocated_blocks == 0))
		goto out;

	/*
	 * if a ROC is in progress, we might not have any Tx for a long
	 * time (e.g. pending Tx on the non-ROC channels)
	 */
	if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
		wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to ROC",
			     wl->conf.tx.tx_watchdog_timeout);
		wl12xx_rearm_tx_watchdog_locked(wl);
		goto out;
	}

	/*
	 * if a scan is in progress, we might not have any Tx for a long
	 * time
	 */
	if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
		wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to scan",
			     wl->conf.tx.tx_watchdog_timeout);
		wl12xx_rearm_tx_watchdog_locked(wl);
		goto out;
	}

	/*
	* AP might cache a frame for a long time for a sleeping station,
	* so rearm the timer if there's an AP interface with stations. If
	* Tx is genuinely stuck we will most hopefully discover it when all
	* stations are removed due to inactivity.
	*/
	if (wl->active_sta_count) {
		wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms. AP has "
			     " %d stations",
			      wl->conf.tx.tx_watchdog_timeout,
			      wl->active_sta_count);
		wl12xx_rearm_tx_watchdog_locked(wl);
		goto out;
	}

	wl1271_error("Tx stuck (in FW) for %d ms. Starting recovery",
		     wl->conf.tx.tx_watchdog_timeout);
	wl12xx_queue_recovery_work(wl);

out:
	mutex_unlock(&wl->mutex);
}

303
static void wlcore_adjust_conf(struct wl1271 *wl)
304
{
305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
	/* Adjust settings according to optional module parameters */
	if (fwlog_param) {
		if (!strcmp(fwlog_param, "continuous")) {
			wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
		} else if (!strcmp(fwlog_param, "ondemand")) {
			wl->conf.fwlog.mode = WL12XX_FWLOG_ON_DEMAND;
		} else if (!strcmp(fwlog_param, "dbgpins")) {
			wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
			wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_DBG_PINS;
		} else if (!strcmp(fwlog_param, "disable")) {
			wl->conf.fwlog.mem_blocks = 0;
			wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE;
		} else {
			wl1271_error("Unknown fwlog parameter %s", fwlog_param);
		}
	}
}
322

L
Luciano Coelho 已提交
323 324
static int wl1271_plt_init(struct wl1271 *wl)
{
325
	int ret;
L
Luciano Coelho 已提交
326

327
	ret = wl->ops->hw_init(wl);
328 329 330
	if (ret < 0)
		return ret;

L
Luciano Coelho 已提交
331 332 333 334
	ret = wl1271_acx_init_mem_config(wl);
	if (ret < 0)
		return ret;

E
Eliad Peller 已提交
335
	ret = wl12xx_acx_mem_cfg(wl);
336 337 338
	if (ret < 0)
		goto out_free_memmap;

339
	/* Enable data path */
340
	ret = wl1271_cmd_data_path(wl, 1);
L
Luciano Coelho 已提交
341
	if (ret < 0)
342 343 344 345 346 347 348 349 350 351 352
		goto out_free_memmap;

	/* Configure for CAM power saving (ie. always active) */
	ret = wl1271_acx_sleep_auth(wl, WL1271_PSM_CAM);
	if (ret < 0)
		goto out_free_memmap;

	/* configure PM */
	ret = wl1271_acx_pm_config(wl);
	if (ret < 0)
		goto out_free_memmap;
L
Luciano Coelho 已提交
353 354

	return 0;
355 356 357 358 359 360

 out_free_memmap:
	kfree(wl->target_mem_map);
	wl->target_mem_map = NULL;

	return ret;
L
Luciano Coelho 已提交
361 362
}

363 364 365
static void wl12xx_irq_ps_regulate_link(struct wl1271 *wl,
					struct wl12xx_vif *wlvif,
					u8 hlid, u8 tx_pkts)
366
{
367
	bool fw_ps, single_sta;
368 369

	fw_ps = test_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
370
	single_sta = (wl->active_sta_count == 1);
371 372 373

	/*
	 * Wake up from high level PS if the STA is asleep with too little
374
	 * packets in FW or if the STA is awake.
375
	 */
376
	if (!fw_ps || tx_pkts < WL1271_PS_STA_MAX_PACKETS)
377
		wl12xx_ps_link_end(wl, wlvif, hlid);
378

379 380 381 382 383 384
	/*
	 * Start high-level PS if the STA is asleep with enough blocks in FW.
	 * Make an exception if this is the only connected station. In this
	 * case FW-memory congestion is not a problem.
	 */
	else if (!single_sta && fw_ps && tx_pkts >= WL1271_PS_STA_MAX_PACKETS)
385
		wl12xx_ps_link_start(wl, wlvif, hlid, true);
386 387
}

388
static void wl12xx_irq_update_links_status(struct wl1271 *wl,
389
					   struct wl12xx_vif *wlvif,
390
					   struct wl_fw_status *status)
391
{
392
	struct wl1271_link *lnk;
393
	u32 cur_fw_ps_map;
394 395 396
	u8 hlid, cnt;

	/* TODO: also use link_fast_bitmap here */
397 398 399 400 401 402 403 404 405 406 407

	cur_fw_ps_map = le32_to_cpu(status->link_ps_bitmap);
	if (wl->ap_fw_ps_map != cur_fw_ps_map) {
		wl1271_debug(DEBUG_PSM,
			     "link ps prev 0x%x cur 0x%x changed 0x%x",
			     wl->ap_fw_ps_map, cur_fw_ps_map,
			     wl->ap_fw_ps_map ^ cur_fw_ps_map);

		wl->ap_fw_ps_map = cur_fw_ps_map;
	}

408 409
	for_each_set_bit(hlid, wlvif->ap.sta_hlid_map, WL12XX_MAX_LINKS) {
		lnk = &wl->links[hlid];
410 411
		cnt = status->counters.tx_lnk_free_pkts[hlid] -
			lnk->prev_freed_pkts;
412

413
		lnk->prev_freed_pkts = status->counters.tx_lnk_free_pkts[hlid];
414
		lnk->allocated_pkts -= cnt;
415

416 417
		wl12xx_irq_ps_regulate_link(wl, wlvif, hlid,
					    lnk->allocated_pkts);
418 419 420
	}
}

E
Eliad Peller 已提交
421
static void wl12xx_fw_status(struct wl1271 *wl,
422
			     struct wl_fw_status *status)
L
Luciano Coelho 已提交
423
{
424
	struct wl12xx_vif *wlvif;
425
	struct timespec ts;
426
	u32 old_tx_blk_count = wl->tx_blocks_available;
E
Eliad Peller 已提交
427
	int avail, freed_blocks;
428
	int i;
429 430 431
	size_t status_len;

	status_len = sizeof(*status) + wl->fw_status_priv_len;
L
Luciano Coelho 已提交
432

433
	wlcore_raw_read_data(wl, REG_RAW_FW_STATUS_ADDR, status,
434
			     status_len, false);
435

L
Luciano Coelho 已提交
436 437 438 439 440 441 442
	wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
		     "drv_rx_counter = %d, tx_results_counter = %d)",
		     status->intr,
		     status->fw_rx_counter,
		     status->drv_rx_counter,
		     status->tx_results_counter);

443 444
	for (i = 0; i < NUM_TX_QUEUES; i++) {
		/* prevent wrap-around in freed-packets counter */
445
		wl->tx_allocated_pkts[i] -=
446
				(status->counters.tx_released_pkts[i] -
447 448
				wl->tx_pkts_freed[i]) & 0xff;

449
		wl->tx_pkts_freed[i] = status->counters.tx_released_pkts[i];
450 451
	}

452 453 454 455 456 457 458 459 460
	/* prevent wrap-around in total blocks counter */
	if (likely(wl->tx_blocks_freed <=
		   le32_to_cpu(status->total_released_blks)))
		freed_blocks = le32_to_cpu(status->total_released_blks) -
			       wl->tx_blocks_freed;
	else
		freed_blocks = 0x100000000LL - wl->tx_blocks_freed +
			       le32_to_cpu(status->total_released_blks);

E
Eliad Peller 已提交
461
	wl->tx_blocks_freed = le32_to_cpu(status->total_released_blks);
462

463 464
	wl->tx_allocated_blocks -= freed_blocks;

A
Arik Nemtsov 已提交
465 466 467 468 469 470 471 472 473 474 475 476
	/*
	 * If the FW freed some blocks:
	 * If we still have allocated blocks - re-arm the timer, Tx is
	 * not stuck. Otherwise, cancel the timer (no Tx currently).
	 */
	if (freed_blocks) {
		if (wl->tx_allocated_blocks)
			wl12xx_rearm_tx_watchdog_locked(wl);
		else
			cancel_delayed_work(&wl->tx_watchdog_work);
	}

E
Eliad Peller 已提交
477
	avail = le32_to_cpu(status->tx_total) - wl->tx_allocated_blocks;
478

E
Eliad Peller 已提交
479 480 481 482 483 484 485 486 487 488
	/*
	 * The FW might change the total number of TX memblocks before
	 * we get a notification about blocks being released. Thus, the
	 * available blocks calculation might yield a temporary result
	 * which is lower than the actual available blocks. Keeping in
	 * mind that only blocks that were allocated can be moved from
	 * TX to RX, tx_blocks_available should never decrease here.
	 */
	wl->tx_blocks_available = max((int)wl->tx_blocks_available,
				      avail);
L
Luciano Coelho 已提交
489

I
Ido Yariv 已提交
490
	/* if more blocks are available now, tx work can be scheduled */
491
	if (wl->tx_blocks_available > old_tx_blk_count)
I
Ido Yariv 已提交
492
		clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
L
Luciano Coelho 已提交
493

E
Eliad Peller 已提交
494
	/* for AP update num of allocated TX blocks per link and ps status */
495
	wl12xx_for_each_wlvif_ap(wl, wlvif) {
496
		wl12xx_irq_update_links_status(wl, wlvif, status);
497
	}
E
Eliad Peller 已提交
498

L
Luciano Coelho 已提交
499
	/* update the host-chipset time offset */
500 501 502
	getnstimeofday(&ts);
	wl->time_offset = (timespec_to_ns(&ts) >> 10) -
		(s64)le32_to_cpu(status->fw_localtime);
L
Luciano Coelho 已提交
503 504
}

505 506 507 508 509 510 511 512 513 514
static void wl1271_flush_deferred_work(struct wl1271 *wl)
{
	struct sk_buff *skb;

	/* Pass all received frames to the network stack */
	while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
		ieee80211_rx_ni(wl->hw, skb);

	/* Return sent skbs to the network stack */
	while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
515
		ieee80211_tx_status_ni(wl->hw, skb);
516 517 518 519 520 521 522 523 524 525 526
}

static void wl1271_netstack_work(struct work_struct *work)
{
	struct wl1271 *wl =
		container_of(work, struct wl1271, netstack_work);

	do {
		wl1271_flush_deferred_work(wl);
	} while (skb_queue_len(&wl->deferred_rx_queue));
}
527

528 529
#define WL1271_IRQ_MAX_LOOPS 256

F
Felipe Balbi 已提交
530
static irqreturn_t wl1271_irq(int irq, void *cookie)
L
Luciano Coelho 已提交
531 532
{
	int ret;
533
	u32 intr;
534
	int loopcount = WL1271_IRQ_MAX_LOOPS;
535 536 537
	struct wl1271 *wl = (struct wl1271 *)cookie;
	bool done = false;
	unsigned int defer_count;
I
Ido Yariv 已提交
538 539 540 541 542
	unsigned long flags;

	/* TX might be handled here, avoid redundant work */
	set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
	cancel_work_sync(&wl->tx_work);
L
Luciano Coelho 已提交
543

544 545 546 547 548 549 550
	/*
	 * In case edge triggered interrupt must be used, we cannot iterate
	 * more than once without introducing race conditions with the hardirq.
	 */
	if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
		loopcount = 1;

L
Luciano Coelho 已提交
551 552 553 554
	mutex_lock(&wl->mutex);

	wl1271_debug(DEBUG_IRQ, "IRQ work");

555
	if (unlikely(wl->state == WL1271_STATE_OFF))
L
Luciano Coelho 已提交
556 557
		goto out;

558
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
559 560 561
	if (ret < 0)
		goto out;

562 563 564 565 566 567 568 569
	while (!done && loopcount--) {
		/*
		 * In order to avoid a race with the hardirq, clear the flag
		 * before acknowledging the chip. Since the mutex is held,
		 * wl1271_ps_elp_wakeup cannot be called concurrently.
		 */
		clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
		smp_mb__after_clear_bit();
570

E
Eliad Peller 已提交
571
		wl12xx_fw_status(wl, wl->fw_status);
572 573 574

		wlcore_hw_tx_immediate_compl(wl);

E
Eliad Peller 已提交
575
		intr = le32_to_cpu(wl->fw_status->intr);
576
		intr &= WL1271_INTR_MASK;
577
		if (!intr) {
578
			done = true;
579 580
			continue;
		}
L
Luciano Coelho 已提交
581

582 583 584
		if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
			wl1271_error("watchdog interrupt received! "
				     "starting recovery.");
585
			wl12xx_queue_recovery_work(wl);
586 587 588 589 590

			/* restarting the chip. ignore any other interrupt. */
			goto out;
		}

591
		if (likely(intr & WL1271_ACX_INTR_DATA)) {
592
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
593

E
Eliad Peller 已提交
594
			wl12xx_rx(wl, wl->fw_status);
L
Luciano Coelho 已提交
595

I
Ido Yariv 已提交
596
			/* Check if any tx blocks were freed */
I
Ido Yariv 已提交
597
			spin_lock_irqsave(&wl->wl_lock, flags);
I
Ido Yariv 已提交
598
			if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
599
			    wl1271_tx_total_queue_count(wl) > 0) {
I
Ido Yariv 已提交
600
				spin_unlock_irqrestore(&wl->wl_lock, flags);
I
Ido Yariv 已提交
601 602 603 604
				/*
				 * In order to avoid starvation of the TX path,
				 * call the work function directly.
				 */
605
				wl1271_tx_work_locked(wl);
I
Ido Yariv 已提交
606 607
			} else {
				spin_unlock_irqrestore(&wl->wl_lock, flags);
I
Ido Yariv 已提交
608 609
			}

610
			/* check for tx results */
611
			wlcore_hw_tx_delayed_compl(wl);
612 613 614 615 616 617

			/* Make sure the deferred queues don't get too long */
			defer_count = skb_queue_len(&wl->deferred_tx_queue) +
				      skb_queue_len(&wl->deferred_rx_queue);
			if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
				wl1271_flush_deferred_work(wl);
618
		}
L
Luciano Coelho 已提交
619

620 621 622 623
		if (intr & WL1271_ACX_INTR_EVENT_A) {
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
			wl1271_event_handle(wl, 0);
		}
L
Luciano Coelho 已提交
624

625 626 627 628
		if (intr & WL1271_ACX_INTR_EVENT_B) {
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
			wl1271_event_handle(wl, 1);
		}
L
Luciano Coelho 已提交
629

630 631 632
		if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
			wl1271_debug(DEBUG_IRQ,
				     "WL1271_ACX_INTR_INIT_COMPLETE");
L
Luciano Coelho 已提交
633

634 635
		if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
636
	}
L
Luciano Coelho 已提交
637 638 639 640

	wl1271_ps_elp_sleep(wl);

out:
I
Ido Yariv 已提交
641 642 643 644
	spin_lock_irqsave(&wl->wl_lock, flags);
	/* In case TX was not handled here, queue TX work */
	clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
	if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
645
	    wl1271_tx_total_queue_count(wl) > 0)
I
Ido Yariv 已提交
646 647 648
		ieee80211_queue_work(wl->hw, &wl->tx_work);
	spin_unlock_irqrestore(&wl->wl_lock, flags);

L
Luciano Coelho 已提交
649
	mutex_unlock(&wl->mutex);
650 651

	return IRQ_HANDLED;
L
Luciano Coelho 已提交
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
struct vif_counter_data {
	u8 counter;

	struct ieee80211_vif *cur_vif;
	bool cur_vif_running;
};

static void wl12xx_vif_count_iter(void *data, u8 *mac,
				  struct ieee80211_vif *vif)
{
	struct vif_counter_data *counter = data;

	counter->counter++;
	if (counter->cur_vif == vif)
		counter->cur_vif_running = true;
}

/* caller must not hold wl->mutex, as it might deadlock */
static void wl12xx_get_vif_count(struct ieee80211_hw *hw,
			       struct ieee80211_vif *cur_vif,
			       struct vif_counter_data *data)
{
	memset(data, 0, sizeof(*data));
	data->cur_vif = cur_vif;

	ieee80211_iterate_active_interfaces(hw,
					    wl12xx_vif_count_iter, data);
}

683
static int wl12xx_fetch_firmware(struct wl1271 *wl, bool plt)
L
Luciano Coelho 已提交
684 685
{
	const struct firmware *fw;
686
	const char *fw_name;
687
	enum wl12xx_fw_type fw_type;
L
Luciano Coelho 已提交
688 689
	int ret;

690 691
	if (plt) {
		fw_type = WL12XX_FW_TYPE_PLT;
692
		fw_name = wl->plt_fw_name;
693
	} else {
694 695 696 697 698 699
		/*
		 * we can't call wl12xx_get_vif_count() here because
		 * wl->mutex is taken, so use the cached last_vif_count value
		 */
		if (wl->last_vif_count > 1) {
			fw_type = WL12XX_FW_TYPE_MULTI;
700
			fw_name = wl->mr_fw_name;
701 702
		} else {
			fw_type = WL12XX_FW_TYPE_NORMAL;
703
			fw_name = wl->sr_fw_name;
704
		}
705 706 707 708
	}

	if (wl->fw_type == fw_type)
		return 0;
709 710 711

	wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);

712
	ret = request_firmware(&fw, fw_name, wl->dev);
L
Luciano Coelho 已提交
713 714

	if (ret < 0) {
715
		wl1271_error("could not get firmware %s: %d", fw_name, ret);
L
Luciano Coelho 已提交
716 717 718 719 720 721 722 723 724 725
		return ret;
	}

	if (fw->size % 4) {
		wl1271_error("firmware size is not multiple of 32 bits: %zu",
			     fw->size);
		ret = -EILSEQ;
		goto out;
	}

726
	vfree(wl->fw);
727
	wl->fw_type = WL12XX_FW_TYPE_NONE;
L
Luciano Coelho 已提交
728
	wl->fw_len = fw->size;
729
	wl->fw = vmalloc(wl->fw_len);
L
Luciano Coelho 已提交
730 731 732 733 734 735 736 737 738

	if (!wl->fw) {
		wl1271_error("could not allocate memory for the firmware");
		ret = -ENOMEM;
		goto out;
	}

	memcpy(wl->fw, fw->data, wl->fw_len);
	ret = 0;
739
	wl->fw_type = fw_type;
L
Luciano Coelho 已提交
740 741 742 743 744 745 746 747 748 749 750
out:
	release_firmware(fw);

	return ret;
}

static int wl1271_fetch_nvs(struct wl1271 *wl)
{
	const struct firmware *fw;
	int ret;

751
	ret = request_firmware(&fw, WL12XX_NVS_NAME, wl->dev);
L
Luciano Coelho 已提交
752 753

	if (ret < 0) {
754 755
		wl1271_error("could not get nvs file %s: %d", WL12XX_NVS_NAME,
			     ret);
L
Luciano Coelho 已提交
756 757 758
		return ret;
	}

759
	wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
L
Luciano Coelho 已提交
760 761 762 763 764 765 766

	if (!wl->nvs) {
		wl1271_error("could not allocate memory for the nvs file");
		ret = -ENOMEM;
		goto out;
	}

767 768
	wl->nvs_len = fw->size;

L
Luciano Coelho 已提交
769 770 771 772 773 774
out:
	release_firmware(fw);

	return ret;
}

775 776 777 778 779 780
void wl12xx_queue_recovery_work(struct wl1271 *wl)
{
	if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
		ieee80211_queue_work(wl->hw, &wl->recovery_work);
}

781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809
size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen)
{
	size_t len = 0;

	/* The FW log is a length-value list, find where the log end */
	while (len < maxlen) {
		if (memblock[len] == 0)
			break;
		if (len + memblock[len] + 1 > maxlen)
			break;
		len += memblock[len] + 1;
	}

	/* Make sure we have enough room */
	len = min(len, (size_t)(PAGE_SIZE - wl->fwlog_size));

	/* Fill the FW log file, consumed by the sysfs fwlog entry */
	memcpy(wl->fwlog + wl->fwlog_size, memblock, len);
	wl->fwlog_size += len;

	return len;
}

static void wl12xx_read_fwlog_panic(struct wl1271 *wl)
{
	u32 addr;
	u32 first_addr;
	u8 *block;

810
	if ((wl->quirks & WLCORE_QUIRK_FWLOG_NOT_IMPLEMENTED) ||
811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828
	    (wl->conf.fwlog.mode != WL12XX_FWLOG_ON_DEMAND) ||
	    (wl->conf.fwlog.mem_blocks == 0))
		return;

	wl1271_info("Reading FW panic log");

	block = kmalloc(WL12XX_HW_BLOCK_SIZE, GFP_KERNEL);
	if (!block)
		return;

	/*
	 * Make sure the chip is awake and the logger isn't active.
	 * This might fail if the firmware hanged.
	 */
	if (!wl1271_ps_elp_wakeup(wl))
		wl12xx_cmd_stop_fwlog(wl);

	/* Read the first memory block address */
E
Eliad Peller 已提交
829 830
	wl12xx_fw_status(wl, wl->fw_status);
	first_addr = le32_to_cpu(wl->fw_status->log_start_addr);
831 832 833 834 835 836 837 838 839 840 841 842 843 844 845
	if (!first_addr)
		goto out;

	/* Traverse the memory blocks linked list */
	addr = first_addr;
	do {
		memset(block, 0, WL12XX_HW_BLOCK_SIZE);
		wl1271_read_hwaddr(wl, addr, block, WL12XX_HW_BLOCK_SIZE,
				   false);

		/*
		 * Memory blocks are linked to one another. The first 4 bytes
		 * of each memory block hold the hardware address of the next
		 * one. The last memory block points to the first one.
		 */
E
Eliad Peller 已提交
846
		addr = le32_to_cpup((__le32 *)block);
847 848 849 850 851 852 853 854 855 856 857
		if (!wl12xx_copy_fwlog(wl, block + sizeof(addr),
				       WL12XX_HW_BLOCK_SIZE - sizeof(addr)))
			break;
	} while (addr && (addr != first_addr));

	wake_up_interruptible(&wl->fwlog_waitq);

out:
	kfree(block);
}

858 859 860 861
static void wl1271_recovery_work(struct work_struct *work)
{
	struct wl1271 *wl =
		container_of(work, struct wl1271, recovery_work);
862
	struct wl12xx_vif *wlvif;
863
	struct ieee80211_vif *vif;
864 865 866

	mutex_lock(&wl->mutex);

867
	if (wl->state != WL1271_STATE_ON || wl->plt)
E
Eliad Peller 已提交
868
		goto out_unlock;
869

870 871 872
	/* Avoid a recursive recovery */
	set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);

873 874
	wl12xx_read_fwlog_panic(wl);

875
	wl1271_info("Hardware recovery in progress. FW ver: %s pc: 0x%x",
876 877
		    wl->chip.fw_ver_str,
		    wlcore_read_reg(wl, REG_PC_ON_RECOVERY));
878

879 880
	BUG_ON(bug_on_recovery &&
	       !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags));
881

882 883 884 885 886 887 888 889
	if (no_recovery) {
		wl1271_info("No recovery (chosen on module load). Fw will remain stuck.");
		clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
		goto out_unlock;
	}

	BUG_ON(bug_on_recovery);

890 891 892 893 894
	/*
	 * Advance security sequence number to overcome potential progress
	 * in the firmware during recovery. This doens't hurt if the network is
	 * not encrypted.
	 */
895
	wl12xx_for_each_wlvif(wl, wlvif) {
896
		if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
897
		    test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
898 899 900
			wlvif->tx_security_seq +=
				WL1271_TX_SQN_POST_RECOVERY_PADDING;
	}
901

902 903 904
	/* Prevent spurious TX during FW restart */
	ieee80211_stop_queues(wl->hw);

905 906 907 908 909
	if (wl->sched_scanning) {
		ieee80211_sched_scan_stopped(wl->hw);
		wl->sched_scanning = false;
	}

910
	/* reboot the chipset */
911 912 913 914 915 916
	while (!list_empty(&wl->wlvif_list)) {
		wlvif = list_first_entry(&wl->wlvif_list,
				       struct wl12xx_vif, list);
		vif = wl12xx_wlvif_to_vif(wlvif);
		__wl1271_op_remove_interface(wl, vif, false);
	}
E
Eliad Peller 已提交
917 918
	mutex_unlock(&wl->mutex);
	wl1271_op_stop(wl->hw);
919 920 921

	clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);

922 923
	ieee80211_restart_hw(wl->hw);

924 925 926 927 928
	/*
	 * Its safe to enable TX now - the queues are stopped after a request
	 * to restart the HW.
	 */
	ieee80211_wake_queues(wl->hw);
E
Eliad Peller 已提交
929 930
	return;
out_unlock:
931 932 933
	mutex_unlock(&wl->mutex);
}

L
Luciano Coelho 已提交
934 935
static void wl1271_fw_wakeup(struct wl1271 *wl)
{
936
	wl1271_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG, ELPCTRL_WAKE_UP);
L
Luciano Coelho 已提交
937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
}

static int wl1271_setup(struct wl1271 *wl)
{
	wl->fw_status = kmalloc(sizeof(*wl->fw_status), GFP_KERNEL);
	if (!wl->fw_status)
		return -ENOMEM;

	wl->tx_res_if = kmalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
	if (!wl->tx_res_if) {
		kfree(wl->fw_status);
		return -ENOMEM;
	}

	return 0;
}

954
static int wl12xx_set_power_on(struct wl1271 *wl)
L
Luciano Coelho 已提交
955
{
956
	int ret;
L
Luciano Coelho 已提交
957

J
Juuso Oikarinen 已提交
958
	msleep(WL1271_PRE_POWER_ON_SLEEP);
959 960 961
	ret = wl1271_power_on(wl);
	if (ret < 0)
		goto out;
L
Luciano Coelho 已提交
962
	msleep(WL1271_POWER_ON_SLEEP);
963 964
	wl1271_io_reset(wl);
	wl1271_io_init(wl);
L
Luciano Coelho 已提交
965

966
	wlcore_set_partition(wl, &wl->ptable[PART_BOOT]);
L
Luciano Coelho 已提交
967 968 969 970

	/* ELP module wake up */
	wl1271_fw_wakeup(wl);

971 972 973
out:
	return ret;
}
L
Luciano Coelho 已提交
974

975
static int wl12xx_chip_wakeup(struct wl1271 *wl, bool plt)
976 977 978 979 980 981
{
	int ret = 0;

	ret = wl12xx_set_power_on(wl);
	if (ret < 0)
		goto out;
L
Luciano Coelho 已提交
982

983 984 985 986 987 988 989 990
	/*
	 * For wl127x based devices we could use the default block
	 * size (512 bytes), but due to a bug in the sdio driver, we
	 * need to set it explicitly after the chip is powered on.  To
	 * simplify the code and since the performance impact is
	 * negligible, we use the same block size for all different
	 * chip types.
	 */
991 992
	if (wl1271_set_block_size(wl))
		wl->quirks |= WLCORE_QUIRK_TX_BLOCKSIZE_ALIGN;
L
Luciano Coelho 已提交
993

994 995 996
	ret = wl->ops->identify_chip(wl);
	if (ret < 0)
		goto out;
997

998
	/* TODO: make sure the lower driver has set things up correctly */
999

1000 1001
	ret = wl1271_setup(wl);
	if (ret < 0)
1002
		goto out;
L
Luciano Coelho 已提交
1003

1004 1005 1006
	ret = wl12xx_fetch_firmware(wl, plt);
	if (ret < 0)
		goto out;
L
Luciano Coelho 已提交
1007 1008 1009 1010 1011

	/* No NVS from netlink, try to get it from the filesystem */
	if (wl->nvs == NULL) {
		ret = wl1271_fetch_nvs(wl);
		if (ret < 0)
1012
			goto out;
L
Luciano Coelho 已提交
1013 1014 1015 1016 1017 1018 1019 1020
	}

out:
	return ret;
}

int wl1271_plt_start(struct wl1271 *wl)
{
1021
	int retries = WL1271_BOOT_RETRIES;
1022
	struct wiphy *wiphy = wl->hw->wiphy;
L
Luciano Coelho 已提交
1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035
	int ret;

	mutex_lock(&wl->mutex);

	wl1271_notice("power up");

	if (wl->state != WL1271_STATE_OFF) {
		wl1271_error("cannot go into PLT state because not "
			     "in off state: %d", wl->state);
		ret = -EBUSY;
		goto out;
	}

1036 1037
	while (retries) {
		retries--;
1038
		ret = wl12xx_chip_wakeup(wl, true);
1039 1040
		if (ret < 0)
			goto power_off;
L
Luciano Coelho 已提交
1041

1042
		ret = wl->ops->boot(wl);
1043 1044
		if (ret < 0)
			goto power_off;
1045

1046 1047 1048
		ret = wl1271_plt_init(wl);
		if (ret < 0)
			goto irq_disable;
1049

1050 1051
		wl->plt = true;
		wl->state = WL1271_STATE_ON;
1052
		wl1271_notice("firmware booted in PLT mode (%s)",
L
Levi, Shahar 已提交
1053
			      wl->chip.fw_ver_str);
1054

1055 1056 1057 1058 1059
		/* update hw/fw version info in wiphy struct */
		wiphy->hw_version = wl->chip.id;
		strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
			sizeof(wiphy->fw_version));

1060
		goto out;
1061

1062 1063 1064 1065 1066 1067 1068 1069 1070
irq_disable:
		mutex_unlock(&wl->mutex);
		/* Unlocking the mutex in the middle of handling is
		   inherently unsafe. In this case we deem it safe to do,
		   because we need to let any possibly pending IRQ out of
		   the system (and while we are WL1271_STATE_OFF the IRQ
		   work function will not do anything.) Also, any other
		   possible concurrent operations will fail due to the
		   current state, hence the wl1271 struct should be safe. */
1071
		wlcore_disable_interrupts(wl);
1072 1073
		wl1271_flush_deferred_work(wl);
		cancel_work_sync(&wl->netstack_work);
1074 1075 1076 1077
		mutex_lock(&wl->mutex);
power_off:
		wl1271_power_off(wl);
	}
L
Luciano Coelho 已提交
1078

1079 1080
	wl1271_error("firmware boot in PLT mode failed despite %d retries",
		     WL1271_BOOT_RETRIES);
L
Luciano Coelho 已提交
1081 1082 1083 1084 1085 1086
out:
	mutex_unlock(&wl->mutex);

	return ret;
}

1087
int wl1271_plt_stop(struct wl1271 *wl)
L
Luciano Coelho 已提交
1088 1089 1090 1091 1092
{
	int ret = 0;

	wl1271_notice("power down");

1093 1094 1095 1096 1097
	/*
	 * Interrupts must be disabled before setting the state to OFF.
	 * Otherwise, the interrupt handler might be called and exit without
	 * reading the interrupt status.
	 */
1098
	wlcore_disable_interrupts(wl);
1099
	mutex_lock(&wl->mutex);
1100
	if (!wl->plt) {
1101
		mutex_unlock(&wl->mutex);
1102 1103 1104 1105 1106 1107

		/*
		 * This will not necessarily enable interrupts as interrupts
		 * may have been disabled when op_stop was called. It will,
		 * however, balance the above call to disable_interrupts().
		 */
1108
		wlcore_enable_interrupts(wl);
1109

L
Luciano Coelho 已提交
1110 1111 1112 1113 1114 1115 1116
		wl1271_error("cannot power down because not in PLT "
			     "state: %d", wl->state);
		ret = -EBUSY;
		goto out;
	}

	mutex_unlock(&wl->mutex);
1117

1118 1119
	wl1271_flush_deferred_work(wl);
	cancel_work_sync(&wl->netstack_work);
1120
	cancel_work_sync(&wl->recovery_work);
1121
	cancel_delayed_work_sync(&wl->elp_work);
A
Arik Nemtsov 已提交
1122
	cancel_delayed_work_sync(&wl->tx_watchdog_work);
1123
	cancel_delayed_work_sync(&wl->connection_loss_work);
1124 1125 1126

	mutex_lock(&wl->mutex);
	wl1271_power_off(wl);
1127 1128
	wl->flags = 0;
	wl->state = WL1271_STATE_OFF;
1129
	wl->plt = false;
1130
	wl->rx_counter = 0;
1131 1132
	mutex_unlock(&wl->mutex);

1133 1134 1135 1136
out:
	return ret;
}

1137
static void wl1271_op_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
L
Luciano Coelho 已提交
1138 1139
{
	struct wl1271 *wl = hw->priv;
1140 1141
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
	struct ieee80211_vif *vif = info->control.vif;
E
Eliad Peller 已提交
1142
	struct wl12xx_vif *wlvif = NULL;
1143
	unsigned long flags;
1144
	int q, mapping;
1145
	u8 hlid;
L
Luciano Coelho 已提交
1146

E
Eliad Peller 已提交
1147 1148 1149
	if (vif)
		wlvif = wl12xx_vif_to_data(vif);

1150 1151
	mapping = skb_get_queue_mapping(skb);
	q = wl1271_tx_get_queue(mapping);
I
Ido Yariv 已提交
1152

1153
	hlid = wl12xx_tx_get_hlid(wl, wlvif, skb);
I
Ido Yariv 已提交
1154

1155
	spin_lock_irqsave(&wl->wl_lock, flags);
I
Ido Yariv 已提交
1156

1157
	/* queue the packet */
1158
	if (hlid == WL12XX_INVALID_LINK_ID ||
E
Eliad Peller 已提交
1159
	    (wlvif && !test_bit(hlid, wlvif->links_map))) {
1160
		wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d", hlid, q);
E
Eliad Peller 已提交
1161
		ieee80211_free_txskb(hw, skb);
1162
		goto out;
1163
	}
L
Luciano Coelho 已提交
1164

E
Eliad Peller 已提交
1165 1166
	wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d len %d",
		     hlid, q, skb->len);
1167 1168
	skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);

1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180
	wl->tx_queue_count[q]++;

	/*
	 * The workqueue is slow to process the tx_queue and we need stop
	 * the queue here, otherwise the queue will get too long.
	 */
	if (wl->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK) {
		wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
		ieee80211_stop_queue(wl->hw, mapping);
		set_bit(q, &wl->stopped_queues_map);
	}

L
Luciano Coelho 已提交
1181 1182 1183 1184 1185
	/*
	 * The chip specific setup must run before the first TX packet -
	 * before that, the tx_work will not be initialized!
	 */

I
Ido Yariv 已提交
1186 1187
	if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
	    !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
I
Ido Yariv 已提交
1188
		ieee80211_queue_work(wl->hw, &wl->tx_work);
I
Ido Yariv 已提交
1189

1190
out:
I
Ido Yariv 已提交
1191
	spin_unlock_irqrestore(&wl->wl_lock, flags);
L
Luciano Coelho 已提交
1192 1193
}

1194 1195
int wl1271_tx_dummy_packet(struct wl1271 *wl)
{
1196
	unsigned long flags;
1197 1198 1199 1200 1201 1202 1203
	int q;

	/* no need to queue a new dummy packet if one is already pending */
	if (test_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags))
		return 0;

	q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet));
1204 1205 1206

	spin_lock_irqsave(&wl->wl_lock, flags);
	set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1207
	wl->tx_queue_count[q]++;
1208 1209 1210 1211
	spin_unlock_irqrestore(&wl->wl_lock, flags);

	/* The FW is low on RX memory blocks, so send the dummy packet asap */
	if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1212
		wl1271_tx_work_locked(wl);
1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227

	/*
	 * If the FW TX is busy, TX work will be scheduled by the threaded
	 * interrupt handler function
	 */
	return 0;
}

/*
 * The size of the dummy packet should be at least 1400 bytes. However, in
 * order to minimize the number of bus transactions, aligning it to 512 bytes
 * boundaries could be beneficial, performance wise
 */
#define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))

1228
static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1229 1230
{
	struct sk_buff *skb;
1231
	struct ieee80211_hdr_3addr *hdr;
1232 1233 1234 1235
	unsigned int dummy_packet_size;

	dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
			    sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1236

1237
	skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1238
	if (!skb) {
1239 1240
		wl1271_warning("Failed to allocate a dummy packet skb");
		return NULL;
1241 1242 1243 1244 1245 1246 1247
	}

	skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));

	hdr = (struct ieee80211_hdr_3addr *) skb_put(skb, sizeof(*hdr));
	memset(hdr, 0, sizeof(*hdr));
	hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1248 1249
					 IEEE80211_STYPE_NULLFUNC |
					 IEEE80211_FCTL_TODS);
1250

1251
	memset(skb_put(skb, dummy_packet_size), 0, dummy_packet_size);
1252

1253 1254
	/* Dummy packets require the TID to be management */
	skb->priority = WL1271_TID_MGMT;
1255

1256
	/* Initialize all fields that might be used */
1257
	skb_set_queue_mapping(skb, 0);
1258
	memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1259

1260
	return skb;
1261 1262
}

1263

1264
#ifdef CONFIG_PM
1265 1266
static int
wl1271_validate_wowlan_pattern(struct cfg80211_wowlan_trig_pkt_pattern *p)
1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326
{
	int num_fields = 0, in_field = 0, fields_size = 0;
	int i, pattern_len = 0;

	if (!p->mask) {
		wl1271_warning("No mask in WoWLAN pattern");
		return -EINVAL;
	}

	/*
	 * The pattern is broken up into segments of bytes at different offsets
	 * that need to be checked by the FW filter. Each segment is called
	 * a field in the FW API. We verify that the total number of fields
	 * required for this pattern won't exceed FW limits (8)
	 * as well as the total fields buffer won't exceed the FW limit.
	 * Note that if there's a pattern which crosses Ethernet/IP header
	 * boundary a new field is required.
	 */
	for (i = 0; i < p->pattern_len; i++) {
		if (test_bit(i, (unsigned long *)p->mask)) {
			if (!in_field) {
				in_field = 1;
				pattern_len = 1;
			} else {
				if (i == WL1271_RX_FILTER_ETH_HEADER_SIZE) {
					num_fields++;
					fields_size += pattern_len +
						RX_FILTER_FIELD_OVERHEAD;
					pattern_len = 1;
				} else
					pattern_len++;
			}
		} else {
			if (in_field) {
				in_field = 0;
				fields_size += pattern_len +
					RX_FILTER_FIELD_OVERHEAD;
				num_fields++;
			}
		}
	}

	if (in_field) {
		fields_size += pattern_len + RX_FILTER_FIELD_OVERHEAD;
		num_fields++;
	}

	if (num_fields > WL1271_RX_FILTER_MAX_FIELDS) {
		wl1271_warning("RX Filter too complex. Too many segments");
		return -EINVAL;
	}

	if (fields_size > WL1271_RX_FILTER_MAX_FIELDS_SIZE) {
		wl1271_warning("RX filter pattern is too big");
		return -E2BIG;
	}

	return 0;
}

1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
struct wl12xx_rx_filter *wl1271_rx_filter_alloc(void)
{
	return kzalloc(sizeof(struct wl12xx_rx_filter), GFP_KERNEL);
}

void wl1271_rx_filter_free(struct wl12xx_rx_filter *filter)
{
	int i;

	if (filter == NULL)
		return;

	for (i = 0; i < filter->num_fields; i++)
		kfree(filter->fields[i].pattern);

	kfree(filter);
}

int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter *filter,
				 u16 offset, u8 flags,
				 u8 *pattern, u8 len)
{
	struct wl12xx_rx_filter_field *field;

	if (filter->num_fields == WL1271_RX_FILTER_MAX_FIELDS) {
		wl1271_warning("Max fields per RX filter. can't alloc another");
		return -EINVAL;
	}

	field = &filter->fields[filter->num_fields];

	field->pattern = kzalloc(len, GFP_KERNEL);
	if (!field->pattern) {
		wl1271_warning("Failed to allocate RX filter pattern");
		return -ENOMEM;
	}

	filter->num_fields++;

	field->offset = cpu_to_le16(offset);
	field->flags = flags;
	field->len = len;
	memcpy(field->pattern, pattern, len);

	return 0;
}

int wl1271_rx_filter_get_fields_size(struct wl12xx_rx_filter *filter)
{
	int i, fields_size = 0;

	for (i = 0; i < filter->num_fields; i++)
		fields_size += filter->fields[i].len +
			sizeof(struct wl12xx_rx_filter_field) -
			sizeof(u8 *);

	return fields_size;
}

void wl1271_rx_filter_flatten_fields(struct wl12xx_rx_filter *filter,
				    u8 *buf)
{
	int i;
	struct wl12xx_rx_filter_field *field;

	for (i = 0; i < filter->num_fields; i++) {
		field = (struct wl12xx_rx_filter_field *)buf;

		field->offset = filter->fields[i].offset;
		field->flags = filter->fields[i].flags;
		field->len = filter->fields[i].len;

		memcpy(&field->pattern, filter->fields[i].pattern, field->len);
		buf += sizeof(struct wl12xx_rx_filter_field) -
			sizeof(u8 *) + field->len;
	}
}

1405 1406 1407 1408
/*
 * Allocates an RX filter returned through f
 * which needs to be freed using rx_filter_free()
 */
1409
static int wl1271_convert_wowlan_pattern_to_rx_filter(
1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
	struct cfg80211_wowlan_trig_pkt_pattern *p,
	struct wl12xx_rx_filter **f)
{
	int i, j, ret = 0;
	struct wl12xx_rx_filter *filter;
	u16 offset;
	u8 flags, len;

	filter = wl1271_rx_filter_alloc();
	if (!filter) {
		wl1271_warning("Failed to alloc rx filter");
		ret = -ENOMEM;
		goto err;
	}

	i = 0;
	while (i < p->pattern_len) {
		if (!test_bit(i, (unsigned long *)p->mask)) {
			i++;
			continue;
		}

		for (j = i; j < p->pattern_len; j++) {
			if (!test_bit(j, (unsigned long *)p->mask))
				break;

			if (i < WL1271_RX_FILTER_ETH_HEADER_SIZE &&
			    j >= WL1271_RX_FILTER_ETH_HEADER_SIZE)
				break;
		}

		if (i < WL1271_RX_FILTER_ETH_HEADER_SIZE) {
			offset = i;
			flags = WL1271_RX_FILTER_FLAG_ETHERNET_HEADER;
		} else {
			offset = i - WL1271_RX_FILTER_ETH_HEADER_SIZE;
			flags = WL1271_RX_FILTER_FLAG_IP_HEADER;
		}

		len = j - i;

		ret = wl1271_rx_filter_alloc_field(filter,
						   offset,
						   flags,
						   &p->pattern[i], len);
		if (ret)
			goto err;

		i = j;
	}

	filter->action = FILTER_SIGNAL;

	*f = filter;
	return 0;

err:
	wl1271_rx_filter_free(filter);
	*f = NULL;

	return ret;
}

static int wl1271_configure_wowlan(struct wl1271 *wl,
				   struct cfg80211_wowlan *wow)
{
	int i, ret;

	if (!wow || wow->any || !wow->n_patterns) {
		wl1271_acx_default_rx_filter_enable(wl, 0, FILTER_SIGNAL);
		wl1271_rx_filter_clear_all(wl);
		return 0;
	}

	if (WARN_ON(wow->n_patterns > WL1271_MAX_RX_FILTERS))
		return -EINVAL;

	/* Validate all incoming patterns before clearing current FW state */
	for (i = 0; i < wow->n_patterns; i++) {
		ret = wl1271_validate_wowlan_pattern(&wow->patterns[i]);
		if (ret) {
			wl1271_warning("Bad wowlan pattern %d", i);
			return ret;
		}
	}

	wl1271_acx_default_rx_filter_enable(wl, 0, FILTER_SIGNAL);
	wl1271_rx_filter_clear_all(wl);

	/* Translate WoWLAN patterns into filters */
	for (i = 0; i < wow->n_patterns; i++) {
		struct cfg80211_wowlan_trig_pkt_pattern *p;
		struct wl12xx_rx_filter *filter = NULL;

		p = &wow->patterns[i];

		ret = wl1271_convert_wowlan_pattern_to_rx_filter(p, &filter);
		if (ret) {
			wl1271_warning("Failed to create an RX filter from "
				       "wowlan pattern %d", i);
			goto out;
		}

		ret = wl1271_rx_filter_enable(wl, i, 1, filter);

		wl1271_rx_filter_free(filter);
		if (ret)
			goto out;
	}

	ret = wl1271_acx_default_rx_filter_enable(wl, 1, FILTER_DROP);

out:
	return ret;
}

1526
static int wl1271_configure_suspend_sta(struct wl1271 *wl,
1527 1528
					struct wl12xx_vif *wlvif,
					struct cfg80211_wowlan *wow)
1529 1530 1531 1532
{
	int ret = 0;

	if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
1533
		goto out;
1534 1535 1536

	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
1537
		goto out;
1538

1539
	wl1271_configure_wowlan(wl, wow);
1540 1541 1542 1543 1544 1545 1546 1547 1548
	ret = wl1271_acx_wake_up_conditions(wl, wlvif,
				    wl->conf.conn.suspend_wake_up_event,
				    wl->conf.conn.suspend_listen_interval);

	if (ret < 0)
		wl1271_error("suspend: set wake up conditions failed: %d", ret);

	wl1271_ps_elp_sleep(wl);

1549
out:
1550 1551 1552
	return ret;

}
1553

E
Eliad Peller 已提交
1554 1555
static int wl1271_configure_suspend_ap(struct wl1271 *wl,
				       struct wl12xx_vif *wlvif)
1556
{
1557
	int ret = 0;
1558

1559
	if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
1560
		goto out;
1561

1562 1563
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
1564
		goto out;
1565

E
Eliad Peller 已提交
1566
	ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true);
1567 1568

	wl1271_ps_elp_sleep(wl);
1569
out:
1570 1571 1572 1573
	return ret;

}

E
Eliad Peller 已提交
1574
static int wl1271_configure_suspend(struct wl1271 *wl,
1575 1576
				    struct wl12xx_vif *wlvif,
				    struct cfg80211_wowlan *wow)
1577
{
1578
	if (wlvif->bss_type == BSS_TYPE_STA_BSS)
1579
		return wl1271_configure_suspend_sta(wl, wlvif, wow);
E
Eliad Peller 已提交
1580
	if (wlvif->bss_type == BSS_TYPE_AP_BSS)
E
Eliad Peller 已提交
1581
		return wl1271_configure_suspend_ap(wl, wlvif);
1582 1583 1584
	return 0;
}

E
Eliad Peller 已提交
1585 1586
static void wl1271_configure_resume(struct wl1271 *wl,
				    struct wl12xx_vif *wlvif)
1587
{
1588
	int ret = 0;
E
Eliad Peller 已提交
1589
	bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
1590
	bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
1591

1592
	if ((!is_ap) && (!is_sta))
1593 1594 1595 1596
		return;

	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
1597
		return;
1598

1599
	if (is_sta) {
1600 1601
		wl1271_configure_wowlan(wl, NULL);

1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612
		ret = wl1271_acx_wake_up_conditions(wl, wlvif,
				    wl->conf.conn.wake_up_event,
				    wl->conf.conn.listen_interval);

		if (ret < 0)
			wl1271_error("resume: wake up conditions failed: %d",
				     ret);

	} else if (is_ap) {
		ret = wl1271_acx_beacon_filter_opt(wl, wlvif, false);
	}
1613 1614 1615 1616

	wl1271_ps_elp_sleep(wl);
}

1617 1618 1619 1620
static int wl1271_op_suspend(struct ieee80211_hw *hw,
			    struct cfg80211_wowlan *wow)
{
	struct wl1271 *wl = hw->priv;
1621
	struct wl12xx_vif *wlvif;
1622 1623
	int ret;

1624
	wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1625
	WARN_ON(!wow);
1626

1627 1628
	wl1271_tx_flush(wl);

1629
	mutex_lock(&wl->mutex);
1630
	wl->wow_enabled = true;
1631
	wl12xx_for_each_wlvif(wl, wlvif) {
1632
		ret = wl1271_configure_suspend(wl, wlvif, wow);
1633
		if (ret < 0) {
1634
			mutex_unlock(&wl->mutex);
1635 1636 1637
			wl1271_warning("couldn't prepare device to suspend");
			return ret;
		}
1638
	}
1639
	mutex_unlock(&wl->mutex);
1640 1641
	/* flush any remaining work */
	wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1642

1643 1644 1645 1646
	/*
	 * disable and re-enable interrupts in order to flush
	 * the threaded_irq
	 */
1647
	wlcore_disable_interrupts(wl);
1648 1649 1650 1651 1652 1653 1654

	/*
	 * set suspended flag to avoid triggering a new threaded_irq
	 * work. no need for spinlock as interrupts are disabled.
	 */
	set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);

1655
	wlcore_enable_interrupts(wl);
1656 1657
	flush_work(&wl->tx_work);
	flush_delayed_work(&wl->elp_work);
1658

1659 1660 1661 1662 1663 1664
	return 0;
}

static int wl1271_op_resume(struct ieee80211_hw *hw)
{
	struct wl1271 *wl = hw->priv;
1665
	struct wl12xx_vif *wlvif;
1666 1667 1668
	unsigned long flags;
	bool run_irq_work = false;

1669 1670
	wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
		     wl->wow_enabled);
1671
	WARN_ON(!wl->wow_enabled);
1672 1673 1674 1675 1676

	/*
	 * re-enable irq_work enqueuing, and call irq_work directly if
	 * there is a pending work.
	 */
1677 1678 1679 1680 1681
	spin_lock_irqsave(&wl->wl_lock, flags);
	clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
	if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
		run_irq_work = true;
	spin_unlock_irqrestore(&wl->wl_lock, flags);
1682

1683 1684 1685 1686
	if (run_irq_work) {
		wl1271_debug(DEBUG_MAC80211,
			     "run postponed irq_work directly");
		wl1271_irq(0, wl);
1687
		wlcore_enable_interrupts(wl);
1688
	}
1689 1690

	mutex_lock(&wl->mutex);
1691 1692 1693
	wl12xx_for_each_wlvif(wl, wlvif) {
		wl1271_configure_resume(wl, wlvif);
	}
1694
	wl->wow_enabled = false;
1695
	mutex_unlock(&wl->mutex);
1696

1697 1698
	return 0;
}
1699
#endif
1700

L
Luciano Coelho 已提交
1701
static int wl1271_op_start(struct ieee80211_hw *hw)
1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
{
	wl1271_debug(DEBUG_MAC80211, "mac80211 start");

	/*
	 * We have to delay the booting of the hardware because
	 * we need to know the local MAC address before downloading and
	 * initializing the firmware. The MAC address cannot be changed
	 * after boot, and without the proper MAC address, the firmware
	 * will not function properly.
	 *
	 * The MAC address is first known when the corresponding interface
	 * is added. That is where we will initialize the hardware.
	 */

1716
	return 0;
1717 1718 1719 1720
}

static void wl1271_op_stop(struct ieee80211_hw *hw)
{
1721 1722 1723
	struct wl1271 *wl = hw->priv;
	int i;

1724
	wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
1725

1726 1727 1728 1729 1730
	/*
	 * Interrupts must be disabled before setting the state to OFF.
	 * Otherwise, the interrupt handler might be called and exit without
	 * reading the interrupt status.
	 */
1731
	wlcore_disable_interrupts(wl);
1732 1733 1734
	mutex_lock(&wl->mutex);
	if (wl->state == WL1271_STATE_OFF) {
		mutex_unlock(&wl->mutex);
1735 1736 1737 1738 1739 1740

		/*
		 * This will not necessarily enable interrupts as interrupts
		 * may have been disabled when op_stop was called. It will,
		 * however, balance the above call to disable_interrupts().
		 */
1741
		wlcore_enable_interrupts(wl);
1742 1743
		return;
	}
1744

1745 1746 1747 1748 1749
	/*
	 * this must be before the cancel_work calls below, so that the work
	 * functions don't perform further work.
	 */
	wl->state = WL1271_STATE_OFF;
1750 1751
	mutex_unlock(&wl->mutex);

1752 1753 1754 1755 1756
	wl1271_flush_deferred_work(wl);
	cancel_delayed_work_sync(&wl->scan_complete_work);
	cancel_work_sync(&wl->netstack_work);
	cancel_work_sync(&wl->tx_work);
	cancel_delayed_work_sync(&wl->elp_work);
A
Arik Nemtsov 已提交
1757
	cancel_delayed_work_sync(&wl->tx_watchdog_work);
1758
	cancel_delayed_work_sync(&wl->connection_loss_work);
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 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800 1801 1802 1803 1804 1805 1806 1807 1808 1809

	/* let's notify MAC80211 about the remaining pending TX frames */
	wl12xx_tx_reset(wl, true);
	mutex_lock(&wl->mutex);

	wl1271_power_off(wl);

	wl->band = IEEE80211_BAND_2GHZ;

	wl->rx_counter = 0;
	wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
	wl->tx_blocks_available = 0;
	wl->tx_allocated_blocks = 0;
	wl->tx_results_count = 0;
	wl->tx_packets_count = 0;
	wl->time_offset = 0;
	wl->ap_fw_ps_map = 0;
	wl->ap_ps_map = 0;
	wl->sched_scanning = false;
	memset(wl->roles_map, 0, sizeof(wl->roles_map));
	memset(wl->links_map, 0, sizeof(wl->links_map));
	memset(wl->roc_map, 0, sizeof(wl->roc_map));
	wl->active_sta_count = 0;

	/* The system link is always allocated */
	__set_bit(WL12XX_SYSTEM_HLID, wl->links_map);

	/*
	 * this is performed after the cancel_work calls and the associated
	 * mutex_lock, so that wl1271_op_add_interface does not accidentally
	 * get executed before all these vars have been reset.
	 */
	wl->flags = 0;

	wl->tx_blocks_freed = 0;

	for (i = 0; i < NUM_TX_QUEUES; i++) {
		wl->tx_pkts_freed[i] = 0;
		wl->tx_allocated_pkts[i] = 0;
	}

	wl1271_debugfs_reset(wl);

	kfree(wl->fw_status);
	wl->fw_status = NULL;
	kfree(wl->tx_res_if);
	wl->tx_res_if = NULL;
	kfree(wl->target_mem_map);
	wl->target_mem_map = NULL;

	mutex_unlock(&wl->mutex);
1810 1811
}

E
Eliad Peller 已提交
1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832
static int wl12xx_allocate_rate_policy(struct wl1271 *wl, u8 *idx)
{
	u8 policy = find_first_zero_bit(wl->rate_policies_map,
					WL12XX_MAX_RATE_POLICIES);
	if (policy >= WL12XX_MAX_RATE_POLICIES)
		return -EBUSY;

	__set_bit(policy, wl->rate_policies_map);
	*idx = policy;
	return 0;
}

static void wl12xx_free_rate_policy(struct wl1271 *wl, u8 *idx)
{
	if (WARN_ON(*idx >= WL12XX_MAX_RATE_POLICIES))
		return;

	__clear_bit(*idx, wl->rate_policies_map);
	*idx = WL12XX_MAX_RATE_POLICIES;
}

E
Eliad Peller 已提交
1833
static u8 wl12xx_get_role_type(struct wl1271 *wl, struct wl12xx_vif *wlvif)
1834
{
E
Eliad Peller 已提交
1835
	switch (wlvif->bss_type) {
1836
	case BSS_TYPE_AP_BSS:
E
Eliad Peller 已提交
1837
		if (wlvif->p2p)
E
Eliad Peller 已提交
1838 1839 1840
			return WL1271_ROLE_P2P_GO;
		else
			return WL1271_ROLE_AP;
1841 1842

	case BSS_TYPE_STA_BSS:
E
Eliad Peller 已提交
1843
		if (wlvif->p2p)
E
Eliad Peller 已提交
1844 1845 1846
			return WL1271_ROLE_P2P_CL;
		else
			return WL1271_ROLE_STA;
1847

E
Eliad Peller 已提交
1848 1849 1850
	case BSS_TYPE_IBSS:
		return WL1271_ROLE_IBSS;

1851
	default:
E
Eliad Peller 已提交
1852
		wl1271_error("invalid bss_type: %d", wlvif->bss_type);
1853 1854 1855 1856
	}
	return WL12XX_INVALID_ROLE_TYPE;
}

1857
static int wl12xx_init_vif_data(struct wl1271 *wl, struct ieee80211_vif *vif)
E
Eliad Peller 已提交
1858
{
1859
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
E
Eliad Peller 已提交
1860
	int i;
1861

1862 1863
	/* clear everything but the persistent data */
	memset(wlvif, 0, offsetof(struct wl12xx_vif, persistent));
1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885

	switch (ieee80211_vif_type_p2p(vif)) {
	case NL80211_IFTYPE_P2P_CLIENT:
		wlvif->p2p = 1;
		/* fall-through */
	case NL80211_IFTYPE_STATION:
		wlvif->bss_type = BSS_TYPE_STA_BSS;
		break;
	case NL80211_IFTYPE_ADHOC:
		wlvif->bss_type = BSS_TYPE_IBSS;
		break;
	case NL80211_IFTYPE_P2P_GO:
		wlvif->p2p = 1;
		/* fall-through */
	case NL80211_IFTYPE_AP:
		wlvif->bss_type = BSS_TYPE_AP_BSS;
		break;
	default:
		wlvif->bss_type = MAX_BSS_TYPE;
		return -EOPNOTSUPP;
	}

E
Eliad Peller 已提交
1886
	wlvif->role_id = WL12XX_INVALID_ROLE_ID;
E
Eliad Peller 已提交
1887
	wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
E
Eliad Peller 已提交
1888
	wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
1889

1890 1891 1892 1893
	if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
	    wlvif->bss_type == BSS_TYPE_IBSS) {
		/* init sta/ibss data */
		wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
E
Eliad Peller 已提交
1894 1895 1896
		wl12xx_allocate_rate_policy(wl, &wlvif->sta.basic_rate_idx);
		wl12xx_allocate_rate_policy(wl, &wlvif->sta.ap_rate_idx);
		wl12xx_allocate_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
1897 1898 1899 1900
	} else {
		/* init ap data */
		wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
		wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
E
Eliad Peller 已提交
1901 1902 1903 1904 1905
		wl12xx_allocate_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
		wl12xx_allocate_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
		for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
			wl12xx_allocate_rate_policy(wl,
						&wlvif->ap.ucast_rate_idx[i]);
1906
	}
1907

1908 1909
	wlvif->bitrate_masks[IEEE80211_BAND_2GHZ] = wl->conf.tx.basic_rate;
	wlvif->bitrate_masks[IEEE80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5;
E
Eliad Peller 已提交
1910
	wlvif->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
E
Eliad Peller 已提交
1911
	wlvif->basic_rate = CONF_TX_RATE_MASK_BASIC;
E
Eliad Peller 已提交
1912
	wlvif->rate_set = CONF_TX_RATE_MASK_BASIC;
E
Eliad Peller 已提交
1913 1914
	wlvif->beacon_int = WL1271_DEFAULT_BEACON_INT;

E
Eliad Peller 已提交
1915 1916 1917 1918 1919
	/*
	 * mac80211 configures some values globally, while we treat them
	 * per-interface. thus, on init, we have to copy them from wl
	 */
	wlvif->band = wl->band;
E
Eliad Peller 已提交
1920
	wlvif->channel = wl->channel;
1921
	wlvif->power_level = wl->power_level;
E
Eliad Peller 已提交
1922

E
Eliad Peller 已提交
1923 1924 1925 1926
	INIT_WORK(&wlvif->rx_streaming_enable_work,
		  wl1271_rx_streaming_enable_work);
	INIT_WORK(&wlvif->rx_streaming_disable_work,
		  wl1271_rx_streaming_disable_work);
E
Eliad Peller 已提交
1927
	INIT_LIST_HEAD(&wlvif->list);
E
Eliad Peller 已提交
1928

E
Eliad Peller 已提交
1929 1930
	setup_timer(&wlvif->rx_streaming_timer, wl1271_rx_streaming_timer,
		    (unsigned long) wlvif);
1931
	return 0;
E
Eliad Peller 已提交
1932 1933
}

1934
static bool wl12xx_init_fw(struct wl1271 *wl)
L
Luciano Coelho 已提交
1935
{
1936
	int retries = WL1271_BOOT_RETRIES;
1937
	bool booted = false;
1938 1939
	struct wiphy *wiphy = wl->hw->wiphy;
	int ret;
L
Luciano Coelho 已提交
1940

1941 1942
	while (retries) {
		retries--;
1943
		ret = wl12xx_chip_wakeup(wl, false);
1944 1945
		if (ret < 0)
			goto power_off;
L
Luciano Coelho 已提交
1946

1947
		ret = wl->ops->boot(wl);
1948 1949
		if (ret < 0)
			goto power_off;
L
Luciano Coelho 已提交
1950

1951 1952 1953 1954
		ret = wl1271_hw_init(wl);
		if (ret < 0)
			goto irq_disable;

1955 1956
		booted = true;
		break;
1957

1958 1959 1960 1961 1962 1963 1964 1965 1966
irq_disable:
		mutex_unlock(&wl->mutex);
		/* Unlocking the mutex in the middle of handling is
		   inherently unsafe. In this case we deem it safe to do,
		   because we need to let any possibly pending IRQ out of
		   the system (and while we are WL1271_STATE_OFF the IRQ
		   work function will not do anything.) Also, any other
		   possible concurrent operations will fail due to the
		   current state, hence the wl1271 struct should be safe. */
1967
		wlcore_disable_interrupts(wl);
1968 1969
		wl1271_flush_deferred_work(wl);
		cancel_work_sync(&wl->netstack_work);
1970 1971 1972 1973
		mutex_lock(&wl->mutex);
power_off:
		wl1271_power_off(wl);
	}
1974

1975 1976 1977 1978 1979 1980
	if (!booted) {
		wl1271_error("firmware boot failed despite %d retries",
			     WL1271_BOOT_RETRIES);
		goto out;
	}

L
Levi, Shahar 已提交
1981
	wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
1982 1983 1984

	/* update hw/fw version info in wiphy struct */
	wiphy->hw_version = wl->chip.id;
L
Levi, Shahar 已提交
1985
	strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1986 1987
		sizeof(wiphy->fw_version));

1988 1989 1990 1991 1992 1993 1994 1995 1996 1997
	/*
	 * Now we know if 11a is supported (info from the NVS), so disable
	 * 11a channels if not supported
	 */
	if (!wl->enable_11a)
		wiphy->bands[IEEE80211_BAND_5GHZ]->n_channels = 0;

	wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
		     wl->enable_11a ? "" : "not ");

1998 1999 2000 2001 2002
	wl->state = WL1271_STATE_ON;
out:
	return booted;
}

2003 2004 2005 2006 2007
static bool wl12xx_dev_role_started(struct wl12xx_vif *wlvif)
{
	return wlvif->dev_hlid != WL12XX_INVALID_LINK_ID;
}

2008 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
/*
 * Check whether a fw switch (i.e. moving from one loaded
 * fw to another) is needed. This function is also responsible
 * for updating wl->last_vif_count, so it must be called before
 * loading a non-plt fw (so the correct fw (single-role/multi-role)
 * will be used).
 */
static bool wl12xx_need_fw_change(struct wl1271 *wl,
				  struct vif_counter_data vif_counter_data,
				  bool add)
{
	enum wl12xx_fw_type current_fw = wl->fw_type;
	u8 vif_count = vif_counter_data.counter;

	if (test_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags))
		return false;

	/* increase the vif count if this is a new vif */
	if (add && !vif_counter_data.cur_vif_running)
		vif_count++;

	wl->last_vif_count = vif_count;

	/* no need for fw change if the device is OFF */
	if (wl->state == WL1271_STATE_OFF)
		return false;

	if (vif_count > 1 && current_fw == WL12XX_FW_TYPE_NORMAL)
		return true;
	if (vif_count <= 1 && current_fw == WL12XX_FW_TYPE_MULTI)
		return true;

	return false;
}

2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055
/*
 * Enter "forced psm". Make sure the sta is in psm against the ap,
 * to make the fw switch a bit more disconnection-persistent.
 */
static void wl12xx_force_active_psm(struct wl1271 *wl)
{
	struct wl12xx_vif *wlvif;

	wl12xx_for_each_wlvif_sta(wl, wlvif) {
		wl1271_ps_set_mode(wl, wlvif, STATION_POWER_SAVE_MODE);
	}
}

2056 2057 2058 2059 2060
static int wl1271_op_add_interface(struct ieee80211_hw *hw,
				   struct ieee80211_vif *vif)
{
	struct wl1271 *wl = hw->priv;
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2061
	struct vif_counter_data vif_count;
2062 2063 2064 2065
	int ret = 0;
	u8 role_type;
	bool booted = false;

2066 2067
	vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER |
			     IEEE80211_VIF_SUPPORTS_CQM_RSSI;
2068

2069 2070 2071
	wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
		     ieee80211_vif_type_p2p(vif), vif->addr);

2072 2073
	wl12xx_get_vif_count(hw, vif, &vif_count);

2074
	mutex_lock(&wl->mutex);
2075 2076 2077 2078
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out_unlock;

2079 2080 2081 2082 2083
	/*
	 * in some very corner case HW recovery scenarios its possible to
	 * get here before __wl1271_op_remove_interface is complete, so
	 * opt out if that is the case.
	 */
2084 2085
	if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) ||
	    test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) {
2086 2087 2088 2089
		ret = -EBUSY;
		goto out;
	}

2090

2091
	ret = wl12xx_init_vif_data(wl, vif);
2092 2093 2094 2095 2096 2097 2098 2099 2100 2101
	if (ret < 0)
		goto out;

	wlvif->wl = wl;
	role_type = wl12xx_get_role_type(wl, wlvif);
	if (role_type == WL12XX_INVALID_ROLE_TYPE) {
		ret = -EINVAL;
		goto out;
	}

2102
	if (wl12xx_need_fw_change(wl, vif_count, true)) {
2103
		wl12xx_force_active_psm(wl);
2104
		set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
2105 2106 2107 2108 2109
		mutex_unlock(&wl->mutex);
		wl1271_recovery_work(&wl->recovery_work);
		return 0;
	}

2110 2111 2112 2113 2114 2115 2116 2117 2118
	/*
	 * TODO: after the nvs issue will be solved, move this block
	 * to start(), and make sure here the driver is ON.
	 */
	if (wl->state == WL1271_STATE_OFF) {
		/*
		 * we still need this in order to configure the fw
		 * while uploading the nvs
		 */
2119
		memcpy(wl->addresses[0].addr, vif->addr, ETH_ALEN);
2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151

		booted = wl12xx_init_fw(wl);
		if (!booted) {
			ret = -EINVAL;
			goto out;
		}
	}

	if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
	    wlvif->bss_type == BSS_TYPE_IBSS) {
		/*
		 * The device role is a special role used for
		 * rx and tx frames prior to association (as
		 * the STA role can get packets only from
		 * its associated bssid)
		 */
		ret = wl12xx_cmd_role_enable(wl, vif->addr,
						 WL1271_ROLE_DEVICE,
						 &wlvif->dev_role_id);
		if (ret < 0)
			goto out;
	}

	ret = wl12xx_cmd_role_enable(wl, vif->addr,
				     role_type, &wlvif->role_id);
	if (ret < 0)
		goto out;

	ret = wl1271_init_vif_specific(wl, vif);
	if (ret < 0)
		goto out;

E
Eliad Peller 已提交
2152
	list_add(&wlvif->list, &wl->wlvif_list);
2153
	set_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags);
2154 2155 2156 2157 2158

	if (wlvif->bss_type == BSS_TYPE_AP_BSS)
		wl->ap_count++;
	else
		wl->sta_count++;
2159
out:
2160 2161
	wl1271_ps_elp_sleep(wl);
out_unlock:
L
Luciano Coelho 已提交
2162 2163 2164 2165 2166
	mutex_unlock(&wl->mutex);

	return ret;
}

2167
static void __wl1271_op_remove_interface(struct wl1271 *wl,
E
Eliad Peller 已提交
2168
					 struct ieee80211_vif *vif,
2169
					 bool reset_tx_queues)
L
Luciano Coelho 已提交
2170
{
E
Eliad Peller 已提交
2171
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
E
Eliad Peller 已提交
2172
	int i, ret;
L
Luciano Coelho 已提交
2173

2174
	wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
L
Luciano Coelho 已提交
2175

2176 2177 2178
	if (!test_and_clear_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
		return;

2179 2180 2181 2182
	/* because of hardware recovery, we may get here twice */
	if (wl->state != WL1271_STATE_ON)
		return;

2183
	wl1271_info("down");
L
Luciano Coelho 已提交
2184

2185 2186
	if (wl->scan.state != WL1271_SCAN_STATE_IDLE &&
	    wl->scan_vif == vif) {
A
Arik Nemtsov 已提交
2187 2188 2189 2190 2191 2192
		/*
		 * Rearm the tx watchdog just before idling scan. This
		 * prevents just-finished scans from triggering the watchdog
		 */
		wl12xx_rearm_tx_watchdog_locked(wl);

L
Luciano Coelho 已提交
2193
		wl->scan.state = WL1271_SCAN_STATE_IDLE;
2194
		memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2195
		wl->scan_vif = NULL;
2196
		wl->scan.req = NULL;
2197
		ieee80211_scan_completed(wl->hw, true);
L
Luciano Coelho 已提交
2198 2199
	}

2200 2201 2202 2203 2204 2205
	if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
		/* disable active roles */
		ret = wl1271_ps_elp_wakeup(wl);
		if (ret < 0)
			goto deinit;

2206 2207 2208 2209 2210
		if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
		    wlvif->bss_type == BSS_TYPE_IBSS) {
			if (wl12xx_dev_role_started(wlvif))
				wl12xx_stop_dev(wl, wlvif);

E
Eliad Peller 已提交
2211
			ret = wl12xx_cmd_role_disable(wl, &wlvif->dev_role_id);
E
Eliad Peller 已提交
2212 2213 2214 2215
			if (ret < 0)
				goto deinit;
		}

E
Eliad Peller 已提交
2216
		ret = wl12xx_cmd_role_disable(wl, &wlvif->role_id);
2217 2218 2219 2220 2221 2222
		if (ret < 0)
			goto deinit;

		wl1271_ps_elp_sleep(wl);
	}
deinit:
2223
	/* clear all hlids (except system_hlid) */
E
Eliad Peller 已提交
2224
	wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
E
Eliad Peller 已提交
2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239

	if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
	    wlvif->bss_type == BSS_TYPE_IBSS) {
		wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
		wl12xx_free_rate_policy(wl, &wlvif->sta.basic_rate_idx);
		wl12xx_free_rate_policy(wl, &wlvif->sta.ap_rate_idx);
		wl12xx_free_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
	} else {
		wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
		wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
		wl12xx_free_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
		wl12xx_free_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
		for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
			wl12xx_free_rate_policy(wl,
						&wlvif->ap.ucast_rate_idx[i]);
2240
		wl1271_free_ap_keys(wl, wlvif);
E
Eliad Peller 已提交
2241
	}
2242

2243 2244
	dev_kfree_skb(wlvif->probereq);
	wlvif->probereq = NULL;
2245
	wl12xx_tx_reset_wlvif(wl, wlvif);
2246 2247
	if (wl->last_wlvif == wlvif)
		wl->last_wlvif = NULL;
E
Eliad Peller 已提交
2248
	list_del(&wlvif->list);
2249
	memset(wlvif->ap.sta_hlid_map, 0, sizeof(wlvif->ap.sta_hlid_map));
E
Eliad Peller 已提交
2250
	wlvif->role_id = WL12XX_INVALID_ROLE_ID;
E
Eliad Peller 已提交
2251
	wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
2252

2253 2254 2255 2256 2257
	if (wlvif->bss_type == BSS_TYPE_AP_BSS)
		wl->ap_count--;
	else
		wl->sta_count--;

2258
	mutex_unlock(&wl->mutex);
E
Eyal Shapira 已提交
2259

E
Eliad Peller 已提交
2260 2261 2262
	del_timer_sync(&wlvif->rx_streaming_timer);
	cancel_work_sync(&wlvif->rx_streaming_enable_work);
	cancel_work_sync(&wlvif->rx_streaming_disable_work);
2263

2264
	mutex_lock(&wl->mutex);
2265
}
2266

2267 2268 2269 2270
static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
				       struct ieee80211_vif *vif)
{
	struct wl1271 *wl = hw->priv;
2271
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2272
	struct wl12xx_vif *iter;
2273 2274
	struct vif_counter_data vif_count;
	bool cancel_recovery = true;
2275

2276
	wl12xx_get_vif_count(hw, vif, &vif_count);
2277
	mutex_lock(&wl->mutex);
2278 2279 2280 2281 2282

	if (wl->state == WL1271_STATE_OFF ||
	    !test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
		goto out;

2283 2284 2285 2286
	/*
	 * wl->vif can be null here if someone shuts down the interface
	 * just when hardware recovery has been started.
	 */
2287 2288 2289 2290
	wl12xx_for_each_wlvif(wl, iter) {
		if (iter != wlvif)
			continue;

E
Eliad Peller 已提交
2291
		__wl1271_op_remove_interface(wl, vif, true);
2292
		break;
2293
	}
2294
	WARN_ON(iter != wlvif);
2295
	if (wl12xx_need_fw_change(wl, vif_count, false)) {
2296
		wl12xx_force_active_psm(wl);
2297
		set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
2298 2299 2300
		wl12xx_queue_recovery_work(wl);
		cancel_recovery = false;
	}
2301
out:
2302
	mutex_unlock(&wl->mutex);
2303 2304
	if (cancel_recovery)
		cancel_work_sync(&wl->recovery_work);
L
Luciano Coelho 已提交
2305 2306
}

E
Eliad Peller 已提交
2307 2308 2309 2310
static int wl12xx_op_change_interface(struct ieee80211_hw *hw,
				      struct ieee80211_vif *vif,
				      enum nl80211_iftype new_type, bool p2p)
{
2311 2312 2313 2314
	struct wl1271 *wl = hw->priv;
	int ret;

	set_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags);
E
Eliad Peller 已提交
2315 2316
	wl1271_op_remove_interface(hw, vif);

2317
	vif->type = new_type;
E
Eliad Peller 已提交
2318
	vif->p2p = p2p;
2319 2320 2321 2322
	ret = wl1271_op_add_interface(hw, vif);

	clear_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags);
	return ret;
E
Eliad Peller 已提交
2323 2324
}

E
Eliad Peller 已提交
2325 2326
static int wl1271_join(struct wl1271 *wl, struct wl12xx_vif *wlvif,
			  bool set_assoc)
2327 2328
{
	int ret;
E
Eliad Peller 已提交
2329
	bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
2330

2331 2332 2333 2334
	/*
	 * One of the side effects of the JOIN command is that is clears
	 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
	 * to a WPA/WPA2 access point will therefore kill the data-path.
2335 2336 2337 2338
	 * Currently the only valid scenario for JOIN during association
	 * is on roaming, in which case we will also be given new keys.
	 * Keep the below message for now, unless it starts bothering
	 * users who really like to roam a lot :)
2339
	 */
2340
	if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2341 2342
		wl1271_info("JOIN while associated.");

2343 2344 2345
	/* clear encryption type */
	wlvif->encryption_type = KEY_NONE;

2346
	if (set_assoc)
2347
		set_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags);
2348

E
Eliad Peller 已提交
2349
	if (is_ibss)
E
Eliad Peller 已提交
2350
		ret = wl12xx_cmd_role_start_ibss(wl, wlvif);
E
Eliad Peller 已提交
2351
	else
E
Eliad Peller 已提交
2352
		ret = wl12xx_cmd_role_start_sta(wl, wlvif);
2353 2354 2355
	if (ret < 0)
		goto out;

2356
	if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2357 2358 2359 2360 2361 2362 2363 2364
		goto out;

	/*
	 * The join command disable the keep-alive mode, shut down its process,
	 * and also clear the template config, so we need to reset it all after
	 * the join. The acx_aid starts the keep-alive process, and the order
	 * of the commands below is relevant.
	 */
E
Eliad Peller 已提交
2365
	ret = wl1271_acx_keep_alive_mode(wl, wlvif, true);
2366 2367 2368
	if (ret < 0)
		goto out;

E
Eliad Peller 已提交
2369
	ret = wl1271_acx_aid(wl, wlvif, wlvif->aid);
2370 2371 2372
	if (ret < 0)
		goto out;

E
Eliad Peller 已提交
2373
	ret = wl12xx_cmd_build_klv_null_data(wl, wlvif);
2374 2375 2376
	if (ret < 0)
		goto out;

E
Eliad Peller 已提交
2377 2378
	ret = wl1271_acx_keep_alive_config(wl, wlvif,
					   CMD_TEMPL_KLV_IDX_NULL_DATA,
2379 2380 2381 2382 2383 2384 2385 2386
					   ACX_KEEP_ALIVE_TPL_VALID);
	if (ret < 0)
		goto out;

out:
	return ret;
}

E
Eliad Peller 已提交
2387
static int wl1271_unjoin(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2388 2389 2390
{
	int ret;

2391
	if (test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags)) {
2392 2393
		struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);

2394
		wl12xx_cmd_stop_channel_switch(wl);
2395
		ieee80211_chswitch_done(vif, false);
2396 2397
	}

2398
	/* to stop listening to a channel, we disconnect */
E
Eliad Peller 已提交
2399
	ret = wl12xx_cmd_role_stop_sta(wl, wlvif);
2400 2401 2402
	if (ret < 0)
		goto out;

2403
	/* reset TX security counters on a clean disconnect */
2404 2405
	wlvif->tx_security_last_seq_lsb = 0;
	wlvif->tx_security_seq = 0;
2406

2407 2408 2409 2410
out:
	return ret;
}

E
Eliad Peller 已提交
2411
static void wl1271_set_band_rate(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2412
{
E
Eliad Peller 已提交
2413
	wlvif->basic_rate_set = wlvif->bitrate_masks[wlvif->band];
E
Eliad Peller 已提交
2414
	wlvif->rate_set = wlvif->basic_rate_set;
2415 2416
}

E
Eliad Peller 已提交
2417 2418
static int wl1271_sta_handle_idle(struct wl1271 *wl, struct wl12xx_vif *wlvif,
				  bool idle)
2419 2420
{
	int ret;
2421 2422 2423 2424
	bool cur_idle = !test_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);

	if (idle == cur_idle)
		return 0;
2425 2426

	if (idle) {
2427
		/* no need to croc if we weren't busy (e.g. during boot) */
2428
		if (wl12xx_dev_role_started(wlvif)) {
2429
			ret = wl12xx_stop_dev(wl, wlvif);
2430 2431 2432
			if (ret < 0)
				goto out;
		}
E
Eliad Peller 已提交
2433 2434 2435
		wlvif->rate_set =
			wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
		ret = wl1271_acx_sta_rate_policies(wl, wlvif);
2436 2437 2438
		if (ret < 0)
			goto out;
		ret = wl1271_acx_keep_alive_config(
E
Eliad Peller 已提交
2439
			wl, wlvif, CMD_TEMPL_KLV_IDX_NULL_DATA,
2440 2441 2442
			ACX_KEEP_ALIVE_TPL_INVALID);
		if (ret < 0)
			goto out;
2443
		clear_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
2444
	} else {
2445 2446 2447 2448 2449 2450
		/* The current firmware only supports sched_scan in idle */
		if (wl->sched_scanning) {
			wl1271_scan_sched_scan_stop(wl);
			ieee80211_sched_scan_stopped(wl->hw);
		}

2451
		ret = wl12xx_start_dev(wl, wlvif);
2452 2453
		if (ret < 0)
			goto out;
2454
		set_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
2455 2456 2457 2458 2459 2460
	}

out:
	return ret;
}

2461 2462
static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif,
			     struct ieee80211_conf *conf, u32 changed)
L
Luciano Coelho 已提交
2463
{
2464 2465
	bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
	int channel, ret;
L
Luciano Coelho 已提交
2466 2467 2468

	channel = ieee80211_frequency_to_channel(conf->channel->center_freq);

2469
	/* if the channel changes while joined, join again */
2470
	if (changed & IEEE80211_CONF_CHANGE_CHANNEL &&
E
Eliad Peller 已提交
2471
	    ((wlvif->band != conf->channel->band) ||
E
Eliad Peller 已提交
2472
	     (wlvif->channel != channel))) {
2473
		/* send all pending packets */
2474
		wl1271_tx_work_locked(wl);
E
Eliad Peller 已提交
2475 2476
		wlvif->band = conf->channel->band;
		wlvif->channel = channel;
2477

2478 2479 2480 2481 2482 2483 2484
		if (!is_ap) {
			/*
			 * FIXME: the mac80211 should really provide a fixed
			 * rate to use here. for now, just use the smallest
			 * possible rate for the band as a fixed rate for
			 * association frames and other control messages.
			 */
2485
			if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
E
Eliad Peller 已提交
2486
				wl1271_set_band_rate(wl, wlvif);
2487

E
Eliad Peller 已提交
2488
			wlvif->basic_rate =
E
Eliad Peller 已提交
2489 2490
				wl1271_tx_min_rate_get(wl,
						       wlvif->basic_rate_set);
E
Eliad Peller 已提交
2491
			ret = wl1271_acx_sta_rate_policies(wl, wlvif);
2492
			if (ret < 0)
2493
				wl1271_warning("rate policy for channel "
2494
					       "failed %d", ret);
2495

2496 2497 2498 2499 2500 2501 2502 2503 2504 2505
			/*
			 * change the ROC channel. do it only if we are
			 * not idle. otherwise, CROC will be called
			 * anyway.
			 */
			if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED,
				      &wlvif->flags) &&
			    wl12xx_dev_role_started(wlvif) &&
			    !(conf->flags & IEEE80211_CONF_IDLE)) {
				ret = wl12xx_stop_dev(wl, wlvif);
2506
				if (ret < 0)
2507 2508 2509 2510 2511
					return ret;

				ret = wl12xx_start_dev(wl, wlvif);
				if (ret < 0)
					return ret;
2512
			}
2513 2514 2515
		}
	}

2516 2517 2518 2519
	if ((changed & IEEE80211_CONF_CHANGE_PS) && !is_ap) {

		if ((conf->flags & IEEE80211_CONF_PS) &&
		    test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
E
Eyal Shapira 已提交
2520
		    !test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
2521

E
Eyal Shapira 已提交
2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535
			int ps_mode;
			char *ps_mode_str;

			if (wl->conf.conn.forced_ps) {
				ps_mode = STATION_POWER_SAVE_MODE;
				ps_mode_str = "forced";
			} else {
				ps_mode = STATION_AUTO_PS_MODE;
				ps_mode_str = "auto";
			}

			wl1271_debug(DEBUG_PSM, "%s ps enabled", ps_mode_str);

			ret = wl1271_ps_set_mode(wl, wlvif, ps_mode);
L
Luciano Coelho 已提交
2536

2537
			if (ret < 0)
E
Eyal Shapira 已提交
2538 2539
				wl1271_warning("enter %s ps failed %d",
					       ps_mode_str, ret);
L
Luciano Coelho 已提交
2540

2541
		} else if (!(conf->flags & IEEE80211_CONF_PS) &&
E
Eyal Shapira 已提交
2542
			   test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
2543 2544

			wl1271_debug(DEBUG_PSM, "auto ps disabled");
L
Luciano Coelho 已提交
2545

E
Eliad Peller 已提交
2546
			ret = wl1271_ps_set_mode(wl, wlvif,
2547
						 STATION_ACTIVE_MODE);
2548 2549 2550
			if (ret < 0)
				wl1271_warning("exit auto ps failed %d", ret);
		}
L
Luciano Coelho 已提交
2551 2552
	}

2553
	if (conf->power_level != wlvif->power_level) {
E
Eliad Peller 已提交
2554
		ret = wl1271_acx_tx_power(wl, wlvif, conf->power_level);
L
Luciano Coelho 已提交
2555
		if (ret < 0)
2556
			return ret;
L
Luciano Coelho 已提交
2557

2558
		wlvif->power_level = conf->power_level;
L
Luciano Coelho 已提交
2559 2560
	}

2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577 2578 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 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614
	return 0;
}

static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
{
	struct wl1271 *wl = hw->priv;
	struct wl12xx_vif *wlvif;
	struct ieee80211_conf *conf = &hw->conf;
	int channel, ret = 0;

	channel = ieee80211_frequency_to_channel(conf->channel->center_freq);

	wl1271_debug(DEBUG_MAC80211, "mac80211 config ch %d psm %s power %d %s"
		     " changed 0x%x",
		     channel,
		     conf->flags & IEEE80211_CONF_PS ? "on" : "off",
		     conf->power_level,
		     conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
			 changed);

	/*
	 * mac80211 will go to idle nearly immediately after transmitting some
	 * frames, such as the deauth. To make sure those frames reach the air,
	 * wait here until the TX queue is fully flushed.
	 */
	if ((changed & IEEE80211_CONF_CHANGE_IDLE) &&
	    (conf->flags & IEEE80211_CONF_IDLE))
		wl1271_tx_flush(wl);

	mutex_lock(&wl->mutex);

	/* we support configuring the channel and band even while off */
	if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
		wl->band = conf->channel->band;
		wl->channel = channel;
	}

	if (changed & IEEE80211_CONF_CHANGE_POWER)
		wl->power_level = conf->power_level;

	if (unlikely(wl->state == WL1271_STATE_OFF))
		goto out;

	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

	/* configure each interface */
	wl12xx_for_each_wlvif(wl, wlvif) {
		ret = wl12xx_config_vif(wl, wlvif, conf, changed);
		if (ret < 0)
			goto out_sleep;
	}

L
Luciano Coelho 已提交
2615 2616 2617 2618 2619 2620 2621 2622 2623
out_sleep:
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

J
Juuso Oikarinen 已提交
2624 2625 2626 2627 2628 2629
struct wl1271_filter_params {
	bool enabled;
	int mc_list_length;
	u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
};

2630 2631
static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
				       struct netdev_hw_addr_list *mc_list)
2632 2633
{
	struct wl1271_filter_params *fp;
2634
	struct netdev_hw_addr *ha;
2635
	struct wl1271 *wl = hw->priv;
2636

2637 2638
	if (unlikely(wl->state == WL1271_STATE_OFF))
		return 0;
2639

2640
	fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
2641 2642 2643 2644 2645 2646 2647
	if (!fp) {
		wl1271_error("Out of memory setting filters.");
		return 0;
	}

	/* update multicast filtering parameters */
	fp->mc_list_length = 0;
2648 2649 2650 2651 2652
	if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
		fp->enabled = false;
	} else {
		fp->enabled = true;
		netdev_hw_addr_list_for_each(ha, mc_list) {
2653
			memcpy(fp->mc_list[fp->mc_list_length],
2654
					ha->addr, ETH_ALEN);
2655
			fp->mc_list_length++;
2656
		}
2657 2658
	}

J
Juuso Oikarinen 已提交
2659
	return (u64)(unsigned long)fp;
2660
}
L
Luciano Coelho 已提交
2661

J
Juuso Oikarinen 已提交
2662 2663 2664 2665 2666 2667 2668
#define WL1271_SUPPORTED_FILTERS (FIF_PROMISC_IN_BSS | \
				  FIF_ALLMULTI | \
				  FIF_FCSFAIL | \
				  FIF_BCN_PRBRESP_PROMISC | \
				  FIF_CONTROL | \
				  FIF_OTHER_BSS)

L
Luciano Coelho 已提交
2669 2670
static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
				       unsigned int changed,
2671
				       unsigned int *total, u64 multicast)
L
Luciano Coelho 已提交
2672
{
J
Juuso Oikarinen 已提交
2673
	struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
L
Luciano Coelho 已提交
2674
	struct wl1271 *wl = hw->priv;
2675
	struct wl12xx_vif *wlvif;
E
Eliad Peller 已提交
2676

J
Juuso Oikarinen 已提交
2677
	int ret;
L
Luciano Coelho 已提交
2678

2679 2680
	wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
		     " total %x", changed, *total);
L
Luciano Coelho 已提交
2681

J
Juuso Oikarinen 已提交
2682 2683
	mutex_lock(&wl->mutex);

2684 2685 2686 2687
	*total &= WL1271_SUPPORTED_FILTERS;
	changed &= WL1271_SUPPORTED_FILTERS;

	if (unlikely(wl->state == WL1271_STATE_OFF))
J
Juuso Oikarinen 已提交
2688 2689
		goto out;

2690
	ret = wl1271_ps_elp_wakeup(wl);
J
Juuso Oikarinen 已提交
2691 2692 2693
	if (ret < 0)
		goto out;

2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706 2707
	wl12xx_for_each_wlvif(wl, wlvif) {
		if (wlvif->bss_type != BSS_TYPE_AP_BSS) {
			if (*total & FIF_ALLMULTI)
				ret = wl1271_acx_group_address_tbl(wl, wlvif,
								   false,
								   NULL, 0);
			else if (fp)
				ret = wl1271_acx_group_address_tbl(wl, wlvif,
							fp->enabled,
							fp->mc_list,
							fp->mc_list_length);
			if (ret < 0)
				goto out_sleep;
		}
2708
	}
L
Luciano Coelho 已提交
2709

E
Eliad Peller 已提交
2710 2711 2712 2713 2714
	/*
	 * the fw doesn't provide an api to configure the filters. instead,
	 * the filters configuration is based on the active roles / ROC
	 * state.
	 */
J
Juuso Oikarinen 已提交
2715 2716 2717 2718 2719 2720

out_sleep:
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);
2721
	kfree(fp);
L
Luciano Coelho 已提交
2722 2723
}

2724 2725 2726 2727
static int wl1271_record_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
				u8 id, u8 key_type, u8 key_size,
				const u8 *key, u8 hlid, u32 tx_seq_32,
				u16 tx_seq_16)
2728 2729 2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741
{
	struct wl1271_ap_key *ap_key;
	int i;

	wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);

	if (key_size > MAX_KEY_SIZE)
		return -EINVAL;

	/*
	 * Find next free entry in ap_keys. Also check we are not replacing
	 * an existing key.
	 */
	for (i = 0; i < MAX_NUM_KEYS; i++) {
2742
		if (wlvif->ap.recorded_keys[i] == NULL)
2743 2744
			break;

2745
		if (wlvif->ap.recorded_keys[i]->id == id) {
2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765
			wl1271_warning("trying to record key replacement");
			return -EINVAL;
		}
	}

	if (i == MAX_NUM_KEYS)
		return -EBUSY;

	ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
	if (!ap_key)
		return -ENOMEM;

	ap_key->id = id;
	ap_key->key_type = key_type;
	ap_key->key_size = key_size;
	memcpy(ap_key->key, key, key_size);
	ap_key->hlid = hlid;
	ap_key->tx_seq_32 = tx_seq_32;
	ap_key->tx_seq_16 = tx_seq_16;

2766
	wlvif->ap.recorded_keys[i] = ap_key;
2767 2768 2769
	return 0;
}

2770
static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2771 2772 2773 2774
{
	int i;

	for (i = 0; i < MAX_NUM_KEYS; i++) {
2775 2776
		kfree(wlvif->ap.recorded_keys[i]);
		wlvif->ap.recorded_keys[i] = NULL;
2777 2778 2779
	}
}

2780
static int wl1271_ap_init_hwenc(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2781 2782 2783 2784 2785 2786
{
	int i, ret = 0;
	struct wl1271_ap_key *key;
	bool wep_key_added = false;

	for (i = 0; i < MAX_NUM_KEYS; i++) {
2787
		u8 hlid;
2788
		if (wlvif->ap.recorded_keys[i] == NULL)
2789 2790
			break;

2791
		key = wlvif->ap.recorded_keys[i];
2792 2793
		hlid = key->hlid;
		if (hlid == WL12XX_INVALID_LINK_ID)
2794
			hlid = wlvif->ap.bcast_hlid;
2795

2796
		ret = wl1271_cmd_set_ap_key(wl, wlvif, KEY_ADD_OR_REPLACE,
2797 2798
					    key->id, key->key_type,
					    key->key_size, key->key,
2799
					    hlid, key->tx_seq_32,
2800 2801 2802 2803 2804 2805 2806 2807 2808
					    key->tx_seq_16);
		if (ret < 0)
			goto out;

		if (key->key_type == KEY_WEP)
			wep_key_added = true;
	}

	if (wep_key_added) {
E
Eliad Peller 已提交
2809
		ret = wl12xx_cmd_set_default_wep_key(wl, wlvif->default_key,
2810
						     wlvif->ap.bcast_hlid);
2811 2812 2813 2814 2815
		if (ret < 0)
			goto out;
	}

out:
2816
	wl1271_free_ap_keys(wl, wlvif);
2817 2818 2819
	return ret;
}

E
Eliad Peller 已提交
2820 2821
static int wl1271_set_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
		       u16 action, u8 id, u8 key_type,
2822 2823 2824 2825
		       u8 key_size, const u8 *key, u32 tx_seq_32,
		       u16 tx_seq_16, struct ieee80211_sta *sta)
{
	int ret;
E
Eliad Peller 已提交
2826
	bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
2827

2828 2829 2830 2831 2832 2833 2834 2835 2836 2837 2838
	/*
	 * A role set to GEM cipher requires different Tx settings (namely
	 * spare blocks). Note when we are in this mode so the HW can adjust.
	 */
	if (key_type == KEY_GEM) {
		if (action == KEY_ADD_OR_REPLACE)
			wlvif->is_gem = true;
		else if (action == KEY_REMOVE)
			wlvif->is_gem = false;
	}

2839 2840 2841 2842 2843 2844 2845 2846
	if (is_ap) {
		struct wl1271_station *wl_sta;
		u8 hlid;

		if (sta) {
			wl_sta = (struct wl1271_station *)sta->drv_priv;
			hlid = wl_sta->hlid;
		} else {
2847
			hlid = wlvif->ap.bcast_hlid;
2848 2849
		}

2850
		if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
2851 2852 2853 2854 2855 2856 2857
			/*
			 * We do not support removing keys after AP shutdown.
			 * Pretend we do to make mac80211 happy.
			 */
			if (action != KEY_ADD_OR_REPLACE)
				return 0;

2858
			ret = wl1271_record_ap_key(wl, wlvif, id,
2859 2860 2861 2862
					     key_type, key_size,
					     key, hlid, tx_seq_32,
					     tx_seq_16);
		} else {
2863
			ret = wl1271_cmd_set_ap_key(wl, wlvif, action,
2864 2865 2866 2867 2868 2869 2870 2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890
					     id, key_type, key_size,
					     key, hlid, tx_seq_32,
					     tx_seq_16);
		}

		if (ret < 0)
			return ret;
	} else {
		const u8 *addr;
		static const u8 bcast_addr[ETH_ALEN] = {
			0xff, 0xff, 0xff, 0xff, 0xff, 0xff
		};

		addr = sta ? sta->addr : bcast_addr;

		if (is_zero_ether_addr(addr)) {
			/* We dont support TX only encryption */
			return -EOPNOTSUPP;
		}

		/* The wl1271 does not allow to remove unicast keys - they
		   will be cleared automatically on next CMD_JOIN. Ignore the
		   request silently, as we dont want the mac80211 to emit
		   an error message. */
		if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
			return 0;

2891 2892
		/* don't remove key if hlid was already deleted */
		if (action == KEY_REMOVE &&
E
Eliad Peller 已提交
2893
		    wlvif->sta.hlid == WL12XX_INVALID_LINK_ID)
2894 2895
			return 0;

2896
		ret = wl1271_cmd_set_sta_key(wl, wlvif, action,
2897 2898 2899 2900 2901 2902 2903 2904
					     id, key_type, key_size,
					     key, addr, tx_seq_32,
					     tx_seq_16);
		if (ret < 0)
			return ret;

		/* the default WEP key needs to be configured at least once */
		if (key_type == KEY_WEP) {
E
Eliad Peller 已提交
2905
			ret = wl12xx_cmd_set_default_wep_key(wl,
E
Eliad Peller 已提交
2906 2907
							wlvif->default_key,
							wlvif->sta.hlid);
2908 2909 2910 2911 2912 2913 2914 2915
			if (ret < 0)
				return ret;
		}
	}

	return 0;
}

L
Luciano Coelho 已提交
2916 2917 2918 2919 2920 2921
static int wl1271_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
			     struct ieee80211_vif *vif,
			     struct ieee80211_sta *sta,
			     struct ieee80211_key_conf *key_conf)
{
	struct wl1271 *wl = hw->priv;
E
Eliad Peller 已提交
2922
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
L
Luciano Coelho 已提交
2923
	int ret;
2924 2925
	u32 tx_seq_32 = 0;
	u16 tx_seq_16 = 0;
L
Luciano Coelho 已提交
2926 2927 2928 2929
	u8 key_type;

	wl1271_debug(DEBUG_MAC80211, "mac80211 set key");

2930
	wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
L
Luciano Coelho 已提交
2931
	wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
2932
		     key_conf->cipher, key_conf->keyidx,
L
Luciano Coelho 已提交
2933 2934 2935 2936 2937
		     key_conf->keylen, key_conf->flags);
	wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);

	mutex_lock(&wl->mutex);

2938 2939 2940 2941 2942
	if (unlikely(wl->state == WL1271_STATE_OFF)) {
		ret = -EAGAIN;
		goto out_unlock;
	}

2943
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
2944 2945 2946
	if (ret < 0)
		goto out_unlock;

2947 2948 2949
	switch (key_conf->cipher) {
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_WEP104:
L
Luciano Coelho 已提交
2950 2951 2952 2953
		key_type = KEY_WEP;

		key_conf->hw_key_idx = key_conf->keyidx;
		break;
2954
	case WLAN_CIPHER_SUITE_TKIP:
L
Luciano Coelho 已提交
2955 2956 2957
		key_type = KEY_TKIP;

		key_conf->hw_key_idx = key_conf->keyidx;
2958 2959
		tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
		tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
L
Luciano Coelho 已提交
2960
		break;
2961
	case WLAN_CIPHER_SUITE_CCMP:
L
Luciano Coelho 已提交
2962 2963
		key_type = KEY_AES;

2964
		key_conf->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
2965 2966
		tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
		tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
L
Luciano Coelho 已提交
2967
		break;
2968 2969
	case WL1271_CIPHER_SUITE_GEM:
		key_type = KEY_GEM;
2970 2971
		tx_seq_32 = WL1271_TX_SECURITY_HI32(wlvif->tx_security_seq);
		tx_seq_16 = WL1271_TX_SECURITY_LO16(wlvif->tx_security_seq);
2972
		break;
L
Luciano Coelho 已提交
2973
	default:
2974
		wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
L
Luciano Coelho 已提交
2975 2976 2977 2978 2979 2980 2981

		ret = -EOPNOTSUPP;
		goto out_sleep;
	}

	switch (cmd) {
	case SET_KEY:
E
Eliad Peller 已提交
2982
		ret = wl1271_set_key(wl, wlvif, KEY_ADD_OR_REPLACE,
2983 2984 2985
				 key_conf->keyidx, key_type,
				 key_conf->keylen, key_conf->key,
				 tx_seq_32, tx_seq_16, sta);
L
Luciano Coelho 已提交
2986 2987 2988 2989
		if (ret < 0) {
			wl1271_error("Could not add or replace key");
			goto out_sleep;
		}
2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004

		/*
		 * reconfiguring arp response if the unicast (or common)
		 * encryption key type was changed
		 */
		if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
		    (sta || key_type == KEY_WEP) &&
		    wlvif->encryption_type != key_type) {
			wlvif->encryption_type = key_type;
			ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
			if (ret < 0) {
				wl1271_warning("build arp rsp failed: %d", ret);
				goto out_sleep;
			}
		}
L
Luciano Coelho 已提交
3005 3006 3007
		break;

	case DISABLE_KEY:
E
Eliad Peller 已提交
3008
		ret = wl1271_set_key(wl, wlvif, KEY_REMOVE,
3009 3010 3011
				     key_conf->keyidx, key_type,
				     key_conf->keylen, key_conf->key,
				     0, 0, sta);
L
Luciano Coelho 已提交
3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033
		if (ret < 0) {
			wl1271_error("Could not remove key");
			goto out_sleep;
		}
		break;

	default:
		wl1271_error("Unsupported key cmd 0x%x", cmd);
		ret = -EOPNOTSUPP;
		break;
	}

out_sleep:
	wl1271_ps_elp_sleep(wl);

out_unlock:
	mutex_unlock(&wl->mutex);

	return ret;
}

static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
3034
			     struct ieee80211_vif *vif,
L
Luciano Coelho 已提交
3035 3036 3037 3038 3039
			     struct cfg80211_scan_request *req)
{
	struct wl1271 *wl = hw->priv;
	int ret;
	u8 *ssid = NULL;
3040
	size_t len = 0;
L
Luciano Coelho 已提交
3041 3042 3043 3044 3045

	wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");

	if (req->n_ssids) {
		ssid = req->ssids[0].ssid;
3046
		len = req->ssids[0].ssid_len;
L
Luciano Coelho 已提交
3047 3048 3049 3050
	}

	mutex_lock(&wl->mutex);

3051 3052 3053 3054 3055 3056 3057 3058 3059 3060
	if (wl->state == WL1271_STATE_OFF) {
		/*
		 * We cannot return -EBUSY here because cfg80211 will expect
		 * a call to ieee80211_scan_completed if we do - in this case
		 * there won't be any call.
		 */
		ret = -EAGAIN;
		goto out;
	}

3061
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
3062 3063 3064
	if (ret < 0)
		goto out;

3065 3066
	/* fail if there is any role in ROC */
	if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
3067 3068 3069 3070 3071
		/* don't allow scanning right now */
		ret = -EBUSY;
		goto out_sleep;
	}

3072
	ret = wl1271_scan(hw->priv, vif, ssid, len, req);
3073
out_sleep:
L
Luciano Coelho 已提交
3074 3075 3076 3077 3078 3079 3080
	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);

	return ret;
}

3081 3082 3083 3084 3085 3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096 3097 3098 3099 3100 3101 3102 3103 3104 3105
static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
				     struct ieee80211_vif *vif)
{
	struct wl1271 *wl = hw->priv;
	int ret;

	wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");

	mutex_lock(&wl->mutex);

	if (wl->state == WL1271_STATE_OFF)
		goto out;

	if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
		goto out;

	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

	if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
		ret = wl1271_scan_stop(wl);
		if (ret < 0)
			goto out_sleep;
	}
A
Arik Nemtsov 已提交
3106 3107 3108 3109 3110 3111 3112

	/*
	 * Rearm the tx watchdog just before idling scan. This
	 * prevents just-finished scans from triggering the watchdog
	 */
	wl12xx_rearm_tx_watchdog_locked(wl);

3113 3114
	wl->scan.state = WL1271_SCAN_STATE_IDLE;
	memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
3115
	wl->scan_vif = NULL;
3116 3117 3118 3119 3120 3121 3122 3123 3124 3125 3126
	wl->scan.req = NULL;
	ieee80211_scan_completed(wl->hw, true);

out_sleep:
	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);

	cancel_delayed_work_sync(&wl->scan_complete_work);
}

3127 3128 3129 3130 3131 3132
static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
				      struct ieee80211_vif *vif,
				      struct cfg80211_sched_scan_request *req,
				      struct ieee80211_sched_scan_ies *ies)
{
	struct wl1271 *wl = hw->priv;
E
Eliad Peller 已提交
3133
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3134 3135 3136 3137 3138 3139
	int ret;

	wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");

	mutex_lock(&wl->mutex);

3140 3141 3142 3143 3144
	if (wl->state == WL1271_STATE_OFF) {
		ret = -EAGAIN;
		goto out;
	}

3145 3146 3147 3148
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

E
Eliad Peller 已提交
3149
	ret = wl1271_scan_sched_scan_config(wl, wlvif, req, ies);
3150 3151 3152
	if (ret < 0)
		goto out_sleep;

E
Eliad Peller 已提交
3153
	ret = wl1271_scan_sched_scan_start(wl, wlvif);
3154 3155 3156 3157 3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175
	if (ret < 0)
		goto out_sleep;

	wl->sched_scanning = true;

out_sleep:
	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
	return ret;
}

static void wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
				      struct ieee80211_vif *vif)
{
	struct wl1271 *wl = hw->priv;
	int ret;

	wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");

	mutex_lock(&wl->mutex);

3176 3177 3178
	if (wl->state == WL1271_STATE_OFF)
		goto out;

3179 3180 3181 3182 3183 3184 3185 3186 3187 3188 3189
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

	wl1271_scan_sched_scan_stop(wl);

	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
}

3190 3191 3192 3193 3194 3195 3196 3197 3198 3199 3200 3201
static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
{
	struct wl1271 *wl = hw->priv;
	int ret = 0;

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF)) {
		ret = -EAGAIN;
		goto out;
	}

3202
	ret = wl1271_ps_elp_wakeup(wl);
3203 3204 3205
	if (ret < 0)
		goto out;

3206
	ret = wl1271_acx_frag_threshold(wl, value);
3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217
	if (ret < 0)
		wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);

	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

L
Luciano Coelho 已提交
3218 3219 3220
static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
{
	struct wl1271 *wl = hw->priv;
3221
	struct wl12xx_vif *wlvif;
3222
	int ret = 0;
L
Luciano Coelho 已提交
3223 3224 3225

	mutex_lock(&wl->mutex);

3226 3227
	if (unlikely(wl->state == WL1271_STATE_OFF)) {
		ret = -EAGAIN;
3228
		goto out;
3229
	}
3230

3231
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
3232 3233 3234
	if (ret < 0)
		goto out;

3235 3236 3237 3238 3239
	wl12xx_for_each_wlvif(wl, wlvif) {
		ret = wl1271_acx_rts_threshold(wl, wlvif, value);
		if (ret < 0)
			wl1271_warning("set rts threshold failed: %d", ret);
	}
L
Luciano Coelho 已提交
3240 3241 3242 3243 3244 3245 3246 3247
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

3248
static int wl1271_ssid_set(struct ieee80211_vif *vif, struct sk_buff *skb,
3249
			    int offset)
3250
{
3251
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3252 3253 3254
	u8 ssid_len;
	const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
					 skb->len - offset);
3255

3256 3257 3258 3259 3260 3261 3262 3263 3264
	if (!ptr) {
		wl1271_error("No SSID in IEs!");
		return -ENOENT;
	}

	ssid_len = ptr[1];
	if (ssid_len > IEEE80211_MAX_SSID_LEN) {
		wl1271_error("SSID is too long!");
		return -EINVAL;
3265
	}
3266

3267 3268
	wlvif->ssid_len = ssid_len;
	memcpy(wlvif->ssid, ptr+2, ssid_len);
3269
	return 0;
3270 3271
}

3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285
static void wl12xx_remove_ie(struct sk_buff *skb, u8 eid, int ieoffset)
{
	int len;
	const u8 *next, *end = skb->data + skb->len;
	u8 *ie = (u8 *)cfg80211_find_ie(eid, skb->data + ieoffset,
					skb->len - ieoffset);
	if (!ie)
		return;
	len = ie[1] + 2;
	next = ie + len;
	memmove(ie, next, end - next);
	skb_trim(skb, skb->len - len);
}

3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302
static void wl12xx_remove_vendor_ie(struct sk_buff *skb,
					    unsigned int oui, u8 oui_type,
					    int ieoffset)
{
	int len;
	const u8 *next, *end = skb->data + skb->len;
	u8 *ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
					       skb->data + ieoffset,
					       skb->len - ieoffset);
	if (!ie)
		return;
	len = ie[1] + 2;
	next = ie + len;
	memmove(ie, next, end - next);
	skb_trim(skb, skb->len - len);
}

3303 3304
static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl, u32 rates,
					 struct ieee80211_vif *vif)
3305
{
3306
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3307 3308 3309
	struct sk_buff *skb;
	int ret;

3310
	skb = ieee80211_proberesp_get(wl->hw, vif);
3311
	if (!skb)
3312
		return -EOPNOTSUPP;
3313

3314
	ret = wl1271_cmd_template_set(wl, wlvif->role_id,
3315 3316 3317 3318 3319 3320 3321 3322 3323 3324 3325 3326 3327 3328
				      CMD_TEMPL_AP_PROBE_RESPONSE,
				      skb->data,
				      skb->len, 0,
				      rates);

	dev_kfree_skb(skb);
	return ret;
}

static int wl1271_ap_set_probe_resp_tmpl_legacy(struct wl1271 *wl,
					     struct ieee80211_vif *vif,
					     u8 *probe_rsp_data,
					     size_t probe_rsp_len,
					     u32 rates)
3329
{
3330 3331
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
	struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
3332 3333 3334 3335 3336
	u8 probe_rsp_templ[WL1271_CMD_TEMPL_MAX_SIZE];
	int ssid_ie_offset, ie_offset, templ_len;
	const u8 *ptr;

	/* no need to change probe response if the SSID is set correctly */
3337
	if (wlvif->ssid_len > 0)
3338
		return wl1271_cmd_template_set(wl, wlvif->role_id,
3339 3340 3341 3342 3343 3344 3345 3346 3347 3348 3349 3350 3351 3352 3353 3354 3355 3356 3357 3358 3359 3360 3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374
					       CMD_TEMPL_AP_PROBE_RESPONSE,
					       probe_rsp_data,
					       probe_rsp_len, 0,
					       rates);

	if (probe_rsp_len + bss_conf->ssid_len > WL1271_CMD_TEMPL_MAX_SIZE) {
		wl1271_error("probe_rsp template too big");
		return -EINVAL;
	}

	/* start searching from IE offset */
	ie_offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);

	ptr = cfg80211_find_ie(WLAN_EID_SSID, probe_rsp_data + ie_offset,
			       probe_rsp_len - ie_offset);
	if (!ptr) {
		wl1271_error("No SSID in beacon!");
		return -EINVAL;
	}

	ssid_ie_offset = ptr - probe_rsp_data;
	ptr += (ptr[1] + 2);

	memcpy(probe_rsp_templ, probe_rsp_data, ssid_ie_offset);

	/* insert SSID from bss_conf */
	probe_rsp_templ[ssid_ie_offset] = WLAN_EID_SSID;
	probe_rsp_templ[ssid_ie_offset + 1] = bss_conf->ssid_len;
	memcpy(probe_rsp_templ + ssid_ie_offset + 2,
	       bss_conf->ssid, bss_conf->ssid_len);
	templ_len = ssid_ie_offset + 2 + bss_conf->ssid_len;

	memcpy(probe_rsp_templ + ssid_ie_offset + 2 + bss_conf->ssid_len,
	       ptr, probe_rsp_len - (ptr - probe_rsp_data));
	templ_len += probe_rsp_len - (ptr - probe_rsp_data);

3375
	return wl1271_cmd_template_set(wl, wlvif->role_id,
3376 3377 3378 3379 3380 3381
				       CMD_TEMPL_AP_PROBE_RESPONSE,
				       probe_rsp_templ,
				       templ_len, 0,
				       rates);
}

3382
static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
E
Eliad Peller 已提交
3383
				       struct ieee80211_vif *vif,
L
Luciano Coelho 已提交
3384 3385 3386
				       struct ieee80211_bss_conf *bss_conf,
				       u32 changed)
{
E
Eliad Peller 已提交
3387
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3388
	int ret = 0;
L
Luciano Coelho 已提交
3389

3390 3391
	if (changed & BSS_CHANGED_ERP_SLOT) {
		if (bss_conf->use_short_slot)
E
Eliad Peller 已提交
3392
			ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_SHORT);
3393
		else
E
Eliad Peller 已提交
3394
			ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_LONG);
3395 3396 3397 3398 3399
		if (ret < 0) {
			wl1271_warning("Set slot time failed %d", ret);
			goto out;
		}
	}
L
Luciano Coelho 已提交
3400

3401 3402
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
		if (bss_conf->use_short_preamble)
E
Eliad Peller 已提交
3403
			wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_SHORT);
3404
		else
E
Eliad Peller 已提交
3405
			wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_LONG);
3406
	}
L
Luciano Coelho 已提交
3407

3408 3409
	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
		if (bss_conf->use_cts_prot)
E
Eliad Peller 已提交
3410 3411
			ret = wl1271_acx_cts_protect(wl, wlvif,
						     CTSPROTECT_ENABLE);
3412
		else
E
Eliad Peller 已提交
3413 3414
			ret = wl1271_acx_cts_protect(wl, wlvif,
						     CTSPROTECT_DISABLE);
3415 3416 3417 3418 3419
		if (ret < 0) {
			wl1271_warning("Set ctsprotect failed %d", ret);
			goto out;
		}
	}
3420

3421 3422 3423
out:
	return ret;
}
L
Luciano Coelho 已提交
3424

3425 3426 3427 3428 3429
static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
					  struct ieee80211_vif *vif,
					  struct ieee80211_bss_conf *bss_conf,
					  u32 changed)
{
E
Eliad Peller 已提交
3430
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
E
Eliad Peller 已提交
3431
	bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
3432 3433 3434 3435
	int ret = 0;

	if ((changed & BSS_CHANGED_BEACON_INT)) {
		wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
3436 3437
			bss_conf->beacon_int);

E
Eliad Peller 已提交
3438
		wlvif->beacon_int = bss_conf->beacon_int;
3439 3440
	}

3441 3442
	if ((changed & BSS_CHANGED_AP_PROBE_RESP) && is_ap) {
		u32 rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
3443 3444 3445 3446
		if (!wl1271_ap_set_probe_resp_tmpl(wl, rate, vif)) {
			wl1271_debug(DEBUG_AP, "probe response updated");
			set_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags);
		}
3447 3448
	}

3449 3450
	if ((changed & BSS_CHANGED_BEACON)) {
		struct ieee80211_hdr *hdr;
3451
		u32 min_rate;
3452 3453 3454 3455 3456
		int ieoffset = offsetof(struct ieee80211_mgmt,
					u.beacon.variable);
		struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
		u16 tmpl_id;

3457 3458
		if (!beacon) {
			ret = -EINVAL;
3459
			goto out;
3460
		}
3461 3462 3463

		wl1271_debug(DEBUG_MASTER, "beacon updated");

3464
		ret = wl1271_ssid_set(vif, beacon, ieoffset);
3465 3466 3467 3468
		if (ret < 0) {
			dev_kfree_skb(beacon);
			goto out;
		}
E
Eliad Peller 已提交
3469
		min_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
3470 3471
		tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
				  CMD_TEMPL_BEACON;
3472
		ret = wl1271_cmd_template_set(wl, wlvif->role_id, tmpl_id,
3473 3474
					      beacon->data,
					      beacon->len, 0,
3475
					      min_rate);
3476 3477 3478 3479 3480
		if (ret < 0) {
			dev_kfree_skb(beacon);
			goto out;
		}

3481 3482 3483 3484 3485 3486 3487
		/*
		 * In case we already have a probe-resp beacon set explicitly
		 * by usermode, don't use the beacon data.
		 */
		if (test_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags))
			goto end_bcn;

3488 3489 3490
		/* remove TIM ie from probe response */
		wl12xx_remove_ie(beacon, WLAN_EID_TIM, ieoffset);

3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501
		/*
		 * remove p2p ie from probe response.
		 * the fw reponds to probe requests that don't include
		 * the p2p ie. probe requests with p2p ie will be passed,
		 * and will be responded by the supplicant (the spec
		 * forbids including the p2p ie when responding to probe
		 * requests that didn't include it).
		 */
		wl12xx_remove_vendor_ie(beacon, WLAN_OUI_WFA,
					WLAN_OUI_TYPE_WFA_P2P, ieoffset);

3502 3503 3504
		hdr = (struct ieee80211_hdr *) beacon->data;
		hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
						 IEEE80211_STYPE_PROBE_RESP);
3505
		if (is_ap)
3506
			ret = wl1271_ap_set_probe_resp_tmpl_legacy(wl, vif,
3507 3508
						beacon->data,
						beacon->len,
3509
						min_rate);
3510
		else
3511
			ret = wl1271_cmd_template_set(wl, wlvif->role_id,
3512 3513 3514
						CMD_TEMPL_PROBE_RESPONSE,
						beacon->data,
						beacon->len, 0,
3515
						min_rate);
3516
end_bcn:
3517 3518 3519 3520 3521 3522
		dev_kfree_skb(beacon);
		if (ret < 0)
			goto out;
	}

out:
3523 3524
	if (ret != 0)
		wl1271_error("beacon info change failed: %d", ret);
3525 3526 3527 3528 3529 3530 3531 3532 3533
	return ret;
}

/* AP mode changes */
static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
				       struct ieee80211_vif *vif,
				       struct ieee80211_bss_conf *bss_conf,
				       u32 changed)
{
E
Eliad Peller 已提交
3534
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3535
	int ret = 0;
3536

3537 3538
	if ((changed & BSS_CHANGED_BASIC_RATES)) {
		u32 rates = bss_conf->basic_rates;
3539

E
Eliad Peller 已提交
3540
		wlvif->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates,
E
Eliad Peller 已提交
3541
								 wlvif->band);
E
Eliad Peller 已提交
3542
		wlvif->basic_rate = wl1271_tx_min_rate_get(wl,
E
Eliad Peller 已提交
3543
							wlvif->basic_rate_set);
3544

E
Eliad Peller 已提交
3545
		ret = wl1271_init_ap_rates(wl, wlvif);
3546
		if (ret < 0) {
3547
			wl1271_error("AP rate policy change failed %d", ret);
3548 3549
			goto out;
		}
3550

3551
		ret = wl1271_ap_init_templates(wl, vif);
3552 3553
		if (ret < 0)
			goto out;
3554
	}
3555

3556 3557 3558
	ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
	if (ret < 0)
		goto out;
3559

3560 3561
	if ((changed & BSS_CHANGED_BEACON_ENABLED)) {
		if (bss_conf->enable_beacon) {
3562
			if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
E
Eliad Peller 已提交
3563
				ret = wl12xx_cmd_role_start_ap(wl, wlvif);
3564 3565
				if (ret < 0)
					goto out;
3566

3567
				ret = wl1271_ap_init_hwenc(wl, wlvif);
3568 3569
				if (ret < 0)
					goto out;
3570

3571
				set_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
3572
				wl1271_debug(DEBUG_AP, "started AP");
3573
			}
3574
		} else {
3575
			if (test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
E
Eliad Peller 已提交
3576
				ret = wl12xx_cmd_role_stop_ap(wl, wlvif);
3577 3578
				if (ret < 0)
					goto out;
3579

3580
				clear_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
3581 3582
				clear_bit(WLVIF_FLAG_AP_PROBE_RESP_SET,
					  &wlvif->flags);
3583 3584 3585 3586
				wl1271_debug(DEBUG_AP, "stopped AP");
			}
		}
	}
3587

E
Eliad Peller 已提交
3588
	ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
3589 3590
	if (ret < 0)
		goto out;
3591 3592 3593 3594

	/* Handle HT information change */
	if ((changed & BSS_CHANGED_HT) &&
	    (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
E
Eliad Peller 已提交
3595
		ret = wl1271_acx_set_ht_information(wl, wlvif,
3596 3597 3598 3599 3600 3601 3602
					bss_conf->ht_operation_mode);
		if (ret < 0) {
			wl1271_warning("Set ht information failed %d", ret);
			goto out;
		}
	}

3603 3604 3605
out:
	return;
}
J
Juuso Oikarinen 已提交
3606

3607 3608 3609 3610 3611 3612
/* STA/IBSS mode changes */
static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
					struct ieee80211_vif *vif,
					struct ieee80211_bss_conf *bss_conf,
					u32 changed)
{
E
Eliad Peller 已提交
3613
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3614
	bool do_join = false, set_assoc = false;
E
Eliad Peller 已提交
3615
	bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
E
Eliad Peller 已提交
3616
	bool ibss_joined = false;
3617
	u32 sta_rate_set = 0;
3618
	int ret;
3619
	struct ieee80211_sta *sta;
3620 3621
	bool sta_exists = false;
	struct ieee80211_sta_ht_cap sta_ht_cap;
3622 3623 3624 3625 3626 3627

	if (is_ibss) {
		ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
						     changed);
		if (ret < 0)
			goto out;
3628 3629
	}

E
Eliad Peller 已提交
3630 3631
	if (changed & BSS_CHANGED_IBSS) {
		if (bss_conf->ibss_joined) {
3632
			set_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags);
E
Eliad Peller 已提交
3633 3634
			ibss_joined = true;
		} else {
3635
			if (test_and_clear_bit(WLVIF_FLAG_IBSS_JOINED,
3636
					       &wlvif->flags))
E
Eliad Peller 已提交
3637
				wl1271_unjoin(wl, wlvif);
E
Eliad Peller 已提交
3638 3639 3640 3641
		}
	}

	if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
3642 3643 3644
		do_join = true;

	/* Need to update the SSID (for filtering etc) */
E
Eliad Peller 已提交
3645
	if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
3646 3647
		do_join = true;

E
Eliad Peller 已提交
3648
	if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
3649 3650 3651 3652 3653 3654
		wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
			     bss_conf->enable_beacon ? "enabled" : "disabled");

		do_join = true;
	}

3655
	if (changed & BSS_CHANGED_IDLE && !is_ibss) {
3656 3657 3658 3659 3660
		ret = wl1271_sta_handle_idle(wl, wlvif, bss_conf->idle);
		if (ret < 0)
			wl1271_warning("idle mode change failed %d", ret);
	}

3661
	if ((changed & BSS_CHANGED_CQM)) {
3662 3663 3664
		bool enable = false;
		if (bss_conf->cqm_rssi_thold)
			enable = true;
E
Eliad Peller 已提交
3665
		ret = wl1271_acx_rssi_snr_trigger(wl, wlvif, enable,
3666 3667 3668 3669
						  bss_conf->cqm_rssi_thold,
						  bss_conf->cqm_rssi_hyst);
		if (ret < 0)
			goto out;
3670
		wlvif->rssi_thold = bss_conf->cqm_rssi_thold;
3671 3672
	}

3673
	if (changed & BSS_CHANGED_BSSID)
3674
		if (!is_zero_ether_addr(bss_conf->bssid)) {
E
Eliad Peller 已提交
3675
			ret = wl12xx_cmd_build_null_data(wl, wlvif);
3676 3677
			if (ret < 0)
				goto out;
3678

3679
			ret = wl1271_build_qos_null_data(wl, vif);
3680 3681 3682
			if (ret < 0)
				goto out;
		}
3683

3684 3685 3686 3687 3688 3689
	if (changed & (BSS_CHANGED_ASSOC | BSS_CHANGED_HT)) {
		rcu_read_lock();
		sta = ieee80211_find_sta(vif, bss_conf->bssid);
		if (!sta)
			goto sta_not_found;

3690 3691 3692 3693 3694
		/* save the supp_rates of the ap */
		sta_rate_set = sta->supp_rates[wl->hw->conf.channel->band];
		if (sta->ht_cap.ht_supported)
			sta_rate_set |=
			    (sta->ht_cap.mcs.rx_mask[0] << HW_HT_RATES_OFFSET);
3695 3696
		sta_ht_cap = sta->ht_cap;
		sta_exists = true;
3697

3698 3699
sta_not_found:
		rcu_read_unlock();
3700 3701
	}

3702
	if ((changed & BSS_CHANGED_ASSOC)) {
L
Luciano Coelho 已提交
3703
		if (bss_conf->assoc) {
3704
			u32 rates;
3705
			int ieoffset;
E
Eliad Peller 已提交
3706
			wlvif->aid = bss_conf->aid;
3707
			wlvif->beacon_int = bss_conf->beacon_int;
3708
			do_join = true;
3709
			set_assoc = true;
L
Luciano Coelho 已提交
3710

3711 3712 3713
			/* Cancel connection_loss_work */
			cancel_delayed_work_sync(&wl->connection_loss_work);

3714 3715 3716 3717 3718
			/*
			 * use basic rates from AP, and determine lowest rate
			 * to use with control frames.
			 */
			rates = bss_conf->basic_rates;
E
Eliad Peller 已提交
3719
			wlvif->basic_rate_set =
3720
				wl1271_tx_enabled_rates_get(wl, rates,
E
Eliad Peller 已提交
3721
							    wlvif->band);
E
Eliad Peller 已提交
3722
			wlvif->basic_rate =
E
Eliad Peller 已提交
3723 3724
				wl1271_tx_min_rate_get(wl,
						       wlvif->basic_rate_set);
3725
			if (sta_rate_set)
E
Eliad Peller 已提交
3726 3727
				wlvif->rate_set =
					wl1271_tx_enabled_rates_get(wl,
3728
								sta_rate_set,
E
Eliad Peller 已提交
3729
								wlvif->band);
E
Eliad Peller 已提交
3730
			ret = wl1271_acx_sta_rate_policies(wl, wlvif);
3731
			if (ret < 0)
3732
				goto out;
3733

3734 3735 3736 3737 3738 3739
			/*
			 * with wl1271, we don't need to update the
			 * beacon_int and dtim_period, because the firmware
			 * updates it by itself when the first beacon is
			 * received after a join.
			 */
E
Eliad Peller 已提交
3740
			ret = wl1271_cmd_build_ps_poll(wl, wlvif, wlvif->aid);
L
Luciano Coelho 已提交
3741
			if (ret < 0)
3742
				goto out;
L
Luciano Coelho 已提交
3743

3744
			/*
3745
			 * Get a template for hardware connection maintenance
3746
			 */
E
Eliad Peller 已提交
3747 3748
			dev_kfree_skb(wlvif->probereq);
			wlvif->probereq = wl1271_cmd_build_ap_probe_req(wl,
3749
									wlvif,
E
Eliad Peller 已提交
3750
									NULL);
3751 3752
			ieoffset = offsetof(struct ieee80211_mgmt,
					    u.probe_req.variable);
E
Eliad Peller 已提交
3753
			wl1271_ssid_set(vif, wlvif->probereq, ieoffset);
3754

3755
			/* enable the connection monitoring feature */
E
Eliad Peller 已提交
3756
			ret = wl1271_acx_conn_monit_params(wl, wlvif, true);
L
Luciano Coelho 已提交
3757
			if (ret < 0)
3758
				goto out;
J
Juuso Oikarinen 已提交
3759 3760
		} else {
			/* use defaults when not associated */
3761
			bool was_assoc =
3762 3763
			    !!test_and_clear_bit(WLVIF_FLAG_STA_ASSOCIATED,
						 &wlvif->flags);
3764
			bool was_ifup =
3765 3766
			    !!test_and_clear_bit(WLVIF_FLAG_STA_STATE_SENT,
						 &wlvif->flags);
E
Eliad Peller 已提交
3767
			wlvif->aid = 0;
3768

3769
			/* free probe-request template */
E
Eliad Peller 已提交
3770 3771
			dev_kfree_skb(wlvif->probereq);
			wlvif->probereq = NULL;
3772

3773
			/* revert back to minimum rates for the current band */
E
Eliad Peller 已提交
3774
			wl1271_set_band_rate(wl, wlvif);
E
Eliad Peller 已提交
3775
			wlvif->basic_rate =
E
Eliad Peller 已提交
3776 3777
				wl1271_tx_min_rate_get(wl,
						       wlvif->basic_rate_set);
E
Eliad Peller 已提交
3778
			ret = wl1271_acx_sta_rate_policies(wl, wlvif);
3779
			if (ret < 0)
3780
				goto out;
3781

3782
			/* disable connection monitor features */
E
Eliad Peller 已提交
3783
			ret = wl1271_acx_conn_monit_params(wl, wlvif, false);
3784 3785

			/* Disable the keep-alive feature */
E
Eliad Peller 已提交
3786
			ret = wl1271_acx_keep_alive_mode(wl, wlvif, false);
3787
			if (ret < 0)
3788
				goto out;
3789 3790

			/* restore the bssid filter and go to dummy bssid */
3791
			if (was_assoc) {
3792 3793 3794 3795 3796
				/*
				 * we might have to disable roc, if there was
				 * no IF_OPER_UP notification.
				 */
				if (!was_ifup) {
E
Eliad Peller 已提交
3797
					ret = wl12xx_croc(wl, wlvif->role_id);
3798 3799 3800 3801 3802 3803 3804 3805
					if (ret < 0)
						goto out;
				}
				/*
				 * (we also need to disable roc in case of
				 * roaming on the same channel. until we will
				 * have a better flow...)
				 */
E
Eliad Peller 已提交
3806 3807 3808
				if (test_bit(wlvif->dev_role_id, wl->roc_map)) {
					ret = wl12xx_croc(wl,
							  wlvif->dev_role_id);
3809 3810 3811 3812
					if (ret < 0)
						goto out;
				}

E
Eliad Peller 已提交
3813
				wl1271_unjoin(wl, wlvif);
3814
				if (!bss_conf->idle)
3815
					wl12xx_start_dev(wl, wlvif);
3816
			}
L
Luciano Coelho 已提交
3817 3818 3819
		}
	}

3820 3821 3822 3823 3824 3825
	if (changed & BSS_CHANGED_IBSS) {
		wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
			     bss_conf->ibss_joined);

		if (bss_conf->ibss_joined) {
			u32 rates = bss_conf->basic_rates;
E
Eliad Peller 已提交
3826
			wlvif->basic_rate_set =
3827
				wl1271_tx_enabled_rates_get(wl, rates,
E
Eliad Peller 已提交
3828
							    wlvif->band);
E
Eliad Peller 已提交
3829
			wlvif->basic_rate =
E
Eliad Peller 已提交
3830 3831
				wl1271_tx_min_rate_get(wl,
						       wlvif->basic_rate_set);
3832

3833
			/* by default, use 11b + OFDM rates */
E
Eliad Peller 已提交
3834 3835
			wlvif->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
			ret = wl1271_acx_sta_rate_policies(wl, wlvif);
3836 3837 3838 3839 3840
			if (ret < 0)
				goto out;
		}
	}

E
Eliad Peller 已提交
3841
	ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
3842 3843
	if (ret < 0)
		goto out;
L
Luciano Coelho 已提交
3844

J
Juuso Oikarinen 已提交
3845
	if (do_join) {
E
Eliad Peller 已提交
3846
		ret = wl1271_join(wl, wlvif, set_assoc);
J
Juuso Oikarinen 已提交
3847 3848
		if (ret < 0) {
			wl1271_warning("cmd join failed %d", ret);
3849
			goto out;
J
Juuso Oikarinen 已提交
3850
		}
3851 3852 3853

		/* ROC until connected (after EAPOL exchange) */
		if (!is_ibss) {
E
Eliad Peller 已提交
3854
			ret = wl12xx_roc(wl, wlvif, wlvif->role_id);
3855 3856 3857
			if (ret < 0)
				goto out;

3858 3859
			if (test_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags))
				wl12xx_set_authorized(wl, wlvif);
3860 3861 3862
		}
		/*
		 * stop device role if started (we might already be in
3863
		 * STA/IBSS role).
3864
		 */
3865
		if (wl12xx_dev_role_started(wlvif)) {
3866
			ret = wl12xx_stop_dev(wl, wlvif);
3867 3868 3869
			if (ret < 0)
				goto out;
		}
3870 3871
	}

3872
	/* Handle new association with HT. Do this after join. */
3873 3874 3875
	if (sta_exists) {
		if ((changed & BSS_CHANGED_HT) &&
		    (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
3876 3877 3878
			ret = wl1271_acx_set_ht_capabilities(wl,
							     &sta_ht_cap,
							     true,
E
Eliad Peller 已提交
3879
							     wlvif->sta.hlid);
3880 3881 3882 3883 3884 3885 3886 3887
			if (ret < 0) {
				wl1271_warning("Set ht cap true failed %d",
					       ret);
				goto out;
			}
		}
		/* handle new association without HT and disassociation */
		else if (changed & BSS_CHANGED_ASSOC) {
3888 3889 3890
			ret = wl1271_acx_set_ht_capabilities(wl,
							     &sta_ht_cap,
							     false,
E
Eliad Peller 已提交
3891
							     wlvif->sta.hlid);
3892 3893 3894 3895 3896 3897 3898 3899
			if (ret < 0) {
				wl1271_warning("Set ht cap false failed %d",
					       ret);
				goto out;
			}
		}
	}

3900 3901
	/* Handle HT information change. Done after join. */
	if ((changed & BSS_CHANGED_HT) &&
3902
	    (bss_conf->channel_type != NL80211_CHAN_NO_HT)) {
E
Eliad Peller 已提交
3903
		ret = wl1271_acx_set_ht_information(wl, wlvif,
3904 3905 3906 3907 3908 3909 3910
					bss_conf->ht_operation_mode);
		if (ret < 0) {
			wl1271_warning("Set ht information failed %d", ret);
			goto out;
		}
	}

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
	/* Handle arp filtering. Done after join. */
	if ((changed & BSS_CHANGED_ARP_FILTER) ||
	    (!is_ibss && (changed & BSS_CHANGED_QOS))) {
		__be32 addr = bss_conf->arp_addr_list[0];
		wlvif->sta.qos = bss_conf->qos;
		WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS);

		if (bss_conf->arp_addr_cnt == 1 &&
		    bss_conf->arp_filter_enabled) {
			wlvif->ip_addr = addr;
			/*
			 * The template should have been configured only upon
			 * association. however, it seems that the correct ip
			 * isn't being set (when sending), so we have to
			 * reconfigure the template upon every ip change.
			 */
			ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
			if (ret < 0) {
				wl1271_warning("build arp rsp failed: %d", ret);
				goto out;
			}

			ret = wl1271_acx_arp_ip_filter(wl, wlvif,
				(ACX_ARP_FILTER_ARP_FILTERING |
				 ACX_ARP_FILTER_AUTO_ARP),
				addr);
		} else {
			wlvif->ip_addr = 0;
			ret = wl1271_acx_arp_ip_filter(wl, wlvif, 0, addr);
		}

		if (ret < 0)
			goto out;
	}

3946 3947 3948 3949 3950 3951 3952 3953 3954 3955
out:
	return;
}

static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
				       struct ieee80211_vif *vif,
				       struct ieee80211_bss_conf *bss_conf,
				       u32 changed)
{
	struct wl1271 *wl = hw->priv;
E
Eliad Peller 已提交
3956 3957
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
	bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
3958 3959 3960 3961 3962 3963 3964 3965 3966 3967
	int ret;

	wl1271_debug(DEBUG_MAC80211, "mac80211 bss info changed 0x%x",
		     (int)changed);

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF))
		goto out;

3968 3969 3970
	if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)))
		goto out;

3971
	ret = wl1271_ps_elp_wakeup(wl);
3972 3973 3974 3975 3976 3977 3978 3979
	if (ret < 0)
		goto out;

	if (is_ap)
		wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
	else
		wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);

L
Luciano Coelho 已提交
3980 3981 3982 3983 3984 3985
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);
}

3986 3987
static int wl1271_op_conf_tx(struct ieee80211_hw *hw,
			     struct ieee80211_vif *vif, u16 queue,
K
Kalle Valo 已提交
3988 3989 3990
			     const struct ieee80211_tx_queue_params *params)
{
	struct wl1271 *wl = hw->priv;
E
Eliad Peller 已提交
3991
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
K
Kalle Valo 已提交
3992
	u8 ps_scheme;
3993
	int ret = 0;
K
Kalle Valo 已提交
3994 3995 3996 3997 3998

	mutex_lock(&wl->mutex);

	wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);

K
Kalle Valo 已提交
3999 4000 4001 4002 4003
	if (params->uapsd)
		ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
	else
		ps_scheme = CONF_PS_SCHEME_LEGACY;

4004
	if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
4005
		goto out;
4006

4007 4008 4009
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;
4010

4011 4012 4013 4014
	/*
	 * the txop is confed in units of 32us by the mac80211,
	 * we need us
	 */
E
Eliad Peller 已提交
4015
	ret = wl1271_acx_ac_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
4016 4017 4018 4019 4020
				params->cw_min, params->cw_max,
				params->aifs, params->txop << 5);
	if (ret < 0)
		goto out_sleep;

E
Eliad Peller 已提交
4021
	ret = wl1271_acx_tid_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
4022 4023 4024 4025
				 CONF_CHANNEL_TYPE_EDCF,
				 wl1271_tx_get_queue(queue),
				 ps_scheme, CONF_ACK_POLICY_LEGACY,
				 0, 0);
K
Kalle Valo 已提交
4026 4027

out_sleep:
4028
	wl1271_ps_elp_sleep(wl);
K
Kalle Valo 已提交
4029 4030 4031 4032 4033 4034 4035

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

4036 4037
static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw,
			     struct ieee80211_vif *vif)
J
Juuso Oikarinen 已提交
4038 4039 4040
{

	struct wl1271 *wl = hw->priv;
4041
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
J
Juuso Oikarinen 已提交
4042 4043 4044 4045 4046 4047 4048
	u64 mactime = ULLONG_MAX;
	int ret;

	wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");

	mutex_lock(&wl->mutex);

4049 4050 4051
	if (unlikely(wl->state == WL1271_STATE_OFF))
		goto out;

4052
	ret = wl1271_ps_elp_wakeup(wl);
J
Juuso Oikarinen 已提交
4053 4054 4055
	if (ret < 0)
		goto out;

4056
	ret = wl12xx_acx_tsf_info(wl, wlvif, &mactime);
J
Juuso Oikarinen 已提交
4057 4058 4059 4060 4061 4062 4063 4064 4065 4066
	if (ret < 0)
		goto out_sleep;

out_sleep:
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);
	return mactime;
}
L
Luciano Coelho 已提交
4067

4068 4069 4070 4071 4072
static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
				struct survey_info *survey)
{
	struct wl1271 *wl = hw->priv;
	struct ieee80211_conf *conf = &hw->conf;
4073

4074 4075
	if (idx != 0)
		return -ENOENT;
4076

4077 4078 4079
	survey->channel = conf->channel;
	survey->filled = SURVEY_INFO_NOISE_DBM;
	survey->noise = wl->noise;
4080

4081 4082 4083
	return 0;
}

4084
static int wl1271_allocate_sta(struct wl1271 *wl,
4085 4086
			     struct wl12xx_vif *wlvif,
			     struct ieee80211_sta *sta)
4087 4088
{
	struct wl1271_station *wl_sta;
4089
	int ret;
4090

4091 4092

	if (wl->active_sta_count >= AP_MAX_STATIONS) {
4093 4094 4095 4096 4097
		wl1271_warning("could not allocate HLID - too much stations");
		return -EBUSY;
	}

	wl_sta = (struct wl1271_station *)sta->drv_priv;
4098 4099 4100 4101 4102 4103 4104
	ret = wl12xx_allocate_link(wl, wlvif, &wl_sta->hlid);
	if (ret < 0) {
		wl1271_warning("could not allocate HLID - too many links");
		return -EBUSY;
	}

	set_bit(wl_sta->hlid, wlvif->ap.sta_hlid_map);
4105
	memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
4106
	wl->active_sta_count++;
4107 4108 4109
	return 0;
}

4110
void wl1271_free_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 hlid)
4111
{
4112
	if (!test_bit(hlid, wlvif->ap.sta_hlid_map))
4113 4114
		return;

4115
	clear_bit(hlid, wlvif->ap.sta_hlid_map);
4116
	memset(wl->links[hlid].addr, 0, ETH_ALEN);
4117
	wl->links[hlid].ba_bitmap = 0;
4118 4119
	__clear_bit(hlid, &wl->ap_ps_map);
	__clear_bit(hlid, (unsigned long *)&wl->ap_fw_ps_map);
4120
	wl12xx_free_link(wl, wlvif, &hlid);
4121
	wl->active_sta_count--;
A
Arik Nemtsov 已提交
4122 4123 4124 4125 4126 4127 4128

	/*
	 * rearm the tx watchdog when the last STA is freed - give the FW a
	 * chance to return STA-buffered packets before complaining.
	 */
	if (wl->active_sta_count == 0)
		wl12xx_rearm_tx_watchdog_locked(wl);
4129 4130
}

4131 4132 4133
static int wl12xx_sta_add(struct wl1271 *wl,
			  struct wl12xx_vif *wlvif,
			  struct ieee80211_sta *sta)
4134
{
4135
	struct wl1271_station *wl_sta;
4136 4137 4138 4139 4140
	int ret = 0;
	u8 hlid;

	wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);

4141
	ret = wl1271_allocate_sta(wl, wlvif, sta);
4142
	if (ret < 0)
4143
		return ret;
4144

4145 4146 4147
	wl_sta = (struct wl1271_station *)sta->drv_priv;
	hlid = wl_sta->hlid;

E
Eliad Peller 已提交
4148
	ret = wl12xx_cmd_add_peer(wl, wlvif, sta, hlid);
4149
	if (ret < 0)
4150
		wl1271_free_sta(wl, wlvif, hlid);
4151

4152 4153
	return ret;
}
4154

4155 4156 4157 4158 4159 4160
static int wl12xx_sta_remove(struct wl1271 *wl,
			     struct wl12xx_vif *wlvif,
			     struct ieee80211_sta *sta)
{
	struct wl1271_station *wl_sta;
	int ret = 0, id;
4161

4162 4163 4164 4165 4166 4167
	wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);

	wl_sta = (struct wl1271_station *)sta->drv_priv;
	id = wl_sta->hlid;
	if (WARN_ON(!test_bit(id, wlvif->ap.sta_hlid_map)))
		return -EINVAL;
4168

4169
	ret = wl12xx_cmd_remove_peer(wl, wl_sta->hlid);
4170
	if (ret < 0)
4171
		return ret;
4172

4173
	wl1271_free_sta(wl, wlvif, wl_sta->hlid);
4174 4175 4176
	return ret;
}

4177 4178 4179 4180 4181
static int wl12xx_update_sta_state(struct wl1271 *wl,
				   struct wl12xx_vif *wlvif,
				   struct ieee80211_sta *sta,
				   enum ieee80211_sta_state old_state,
				   enum ieee80211_sta_state new_state)
4182 4183
{
	struct wl1271_station *wl_sta;
4184 4185 4186 4187
	u8 hlid;
	bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
	bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
	int ret;
4188

4189 4190
	wl_sta = (struct wl1271_station *)sta->drv_priv;
	hlid = wl_sta->hlid;
4191

4192 4193 4194 4195 4196 4197 4198 4199 4200 4201 4202 4203 4204 4205
	/* Add station (AP mode) */
	if (is_ap &&
	    old_state == IEEE80211_STA_NOTEXIST &&
	    new_state == IEEE80211_STA_NONE)
		return wl12xx_sta_add(wl, wlvif, sta);

	/* Remove station (AP mode) */
	if (is_ap &&
	    old_state == IEEE80211_STA_NONE &&
	    new_state == IEEE80211_STA_NOTEXIST) {
		/* must not fail */
		wl12xx_sta_remove(wl, wlvif, sta);
		return 0;
	}
4206

4207 4208 4209 4210 4211 4212
	/* Authorize station (AP mode) */
	if (is_ap &&
	    new_state == IEEE80211_STA_AUTHORIZED) {
		ret = wl12xx_cmd_set_peer_state(wl, hlid);
		if (ret < 0)
			return ret;
4213

4214 4215 4216 4217
		ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true,
						     hlid);
		return ret;
	}
4218

4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232
	/* Authorize station */
	if (is_sta &&
	    new_state == IEEE80211_STA_AUTHORIZED) {
		set_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
		return wl12xx_set_authorized(wl, wlvif);
	}

	if (is_sta &&
	    old_state == IEEE80211_STA_AUTHORIZED &&
	    new_state == IEEE80211_STA_ASSOC) {
		clear_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
		return 0;
	}

4233 4234 4235 4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252
	return 0;
}

static int wl12xx_op_sta_state(struct ieee80211_hw *hw,
			       struct ieee80211_vif *vif,
			       struct ieee80211_sta *sta,
			       enum ieee80211_sta_state old_state,
			       enum ieee80211_sta_state new_state)
{
	struct wl1271 *wl = hw->priv;
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
	int ret;

	wl1271_debug(DEBUG_MAC80211, "mac80211 sta %d state=%d->%d",
		     sta->aid, old_state, new_state);

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF)) {
		ret = -EBUSY;
4253
		goto out;
4254
	}
4255

4256
	ret = wl1271_ps_elp_wakeup(wl);
4257 4258 4259
	if (ret < 0)
		goto out;

4260
	ret = wl12xx_update_sta_state(wl, wlvif, sta, old_state, new_state);
4261 4262 4263 4264

	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
4265 4266
	if (new_state < old_state)
		return 0;
4267 4268 4269
	return ret;
}

4270 4271 4272 4273 4274
static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif,
				  enum ieee80211_ampdu_mlme_action action,
				  struct ieee80211_sta *sta, u16 tid, u16 *ssn,
				  u8 buf_size)
L
Levi, Shahar 已提交
4275 4276
{
	struct wl1271 *wl = hw->priv;
E
Eliad Peller 已提交
4277
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
L
Levi, Shahar 已提交
4278
	int ret;
4279 4280 4281 4282 4283 4284 4285 4286
	u8 hlid, *ba_bitmap;

	wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
		     tid);

	/* sanity check - the fields in FW are only 8bits wide */
	if (WARN_ON(tid > 0xFF))
		return -ENOTSUPP;
L
Levi, Shahar 已提交
4287 4288 4289 4290 4291 4292 4293 4294

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF)) {
		ret = -EAGAIN;
		goto out;
	}

E
Eliad Peller 已提交
4295
	if (wlvif->bss_type == BSS_TYPE_STA_BSS) {
E
Eliad Peller 已提交
4296
		hlid = wlvif->sta.hlid;
E
Eliad Peller 已提交
4297
		ba_bitmap = &wlvif->sta.ba_rx_bitmap;
E
Eliad Peller 已提交
4298
	} else if (wlvif->bss_type == BSS_TYPE_AP_BSS) {
4299 4300 4301 4302 4303 4304 4305 4306 4307 4308
		struct wl1271_station *wl_sta;

		wl_sta = (struct wl1271_station *)sta->drv_priv;
		hlid = wl_sta->hlid;
		ba_bitmap = &wl->links[hlid].ba_bitmap;
	} else {
		ret = -EINVAL;
		goto out;
	}

4309
	ret = wl1271_ps_elp_wakeup(wl);
L
Levi, Shahar 已提交
4310 4311 4312
	if (ret < 0)
		goto out;

4313 4314 4315
	wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
		     tid, action);

L
Levi, Shahar 已提交
4316 4317
	switch (action) {
	case IEEE80211_AMPDU_RX_START:
E
Eliad Peller 已提交
4318
		if (!wlvif->ba_support || !wlvif->ba_allowed) {
L
Levi, Shahar 已提交
4319
			ret = -ENOTSUPP;
4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340
			break;
		}

		if (wl->ba_rx_session_count >= RX_BA_MAX_SESSIONS) {
			ret = -EBUSY;
			wl1271_error("exceeded max RX BA sessions");
			break;
		}

		if (*ba_bitmap & BIT(tid)) {
			ret = -EINVAL;
			wl1271_error("cannot enable RX BA session on active "
				     "tid: %d", tid);
			break;
		}

		ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
							 hlid);
		if (!ret) {
			*ba_bitmap |= BIT(tid);
			wl->ba_rx_session_count++;
L
Levi, Shahar 已提交
4341 4342 4343 4344
		}
		break;

	case IEEE80211_AMPDU_RX_STOP:
4345 4346 4347 4348 4349 4350 4351 4352 4353 4354 4355 4356 4357
		if (!(*ba_bitmap & BIT(tid))) {
			ret = -EINVAL;
			wl1271_error("no active RX BA session on tid: %d",
				     tid);
			break;
		}

		ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
							 hlid);
		if (!ret) {
			*ba_bitmap &= ~BIT(tid);
			wl->ba_rx_session_count--;
		}
L
Levi, Shahar 已提交
4358 4359 4360 4361 4362 4363 4364 4365 4366 4367 4368 4369 4370 4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382
		break;

	/*
	 * The BA initiator session management in FW independently.
	 * Falling break here on purpose for all TX APDU commands.
	 */
	case IEEE80211_AMPDU_TX_START:
	case IEEE80211_AMPDU_TX_STOP:
	case IEEE80211_AMPDU_TX_OPERATIONAL:
		ret = -EINVAL;
		break;

	default:
		wl1271_error("Incorrect ampdu action id=%x\n", action);
		ret = -EINVAL;
	}

	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

4383 4384 4385 4386
static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw,
				   struct ieee80211_vif *vif,
				   const struct cfg80211_bitrate_mask *mask)
{
4387
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4388
	struct wl1271 *wl = hw->priv;
4389
	int i, ret = 0;
4390 4391 4392 4393 4394 4395 4396 4397

	wl1271_debug(DEBUG_MAC80211, "mac80211 set_bitrate_mask 0x%x 0x%x",
		mask->control[NL80211_BAND_2GHZ].legacy,
		mask->control[NL80211_BAND_5GHZ].legacy);

	mutex_lock(&wl->mutex);

	for (i = 0; i < IEEE80211_NUM_BANDS; i++)
4398
		wlvif->bitrate_masks[i] =
4399 4400 4401
			wl1271_tx_enabled_rates_get(wl,
						    mask->control[i].legacy,
						    i);
4402 4403 4404 4405 4406 4407 4408 4409 4410 4411 4412 4413 4414 4415 4416 4417 4418 4419 4420

	if (unlikely(wl->state == WL1271_STATE_OFF))
		goto out;

	if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
	    !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {

		ret = wl1271_ps_elp_wakeup(wl);
		if (ret < 0)
			goto out;

		wl1271_set_band_rate(wl, wlvif);
		wlvif->basic_rate =
			wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
		ret = wl1271_acx_sta_rate_policies(wl, wlvif);

		wl1271_ps_elp_sleep(wl);
	}
out:
4421 4422
	mutex_unlock(&wl->mutex);

4423
	return ret;
4424 4425
}

4426 4427 4428 4429
static void wl12xx_op_channel_switch(struct ieee80211_hw *hw,
				     struct ieee80211_channel_switch *ch_switch)
{
	struct wl1271 *wl = hw->priv;
4430
	struct wl12xx_vif *wlvif;
4431 4432 4433 4434
	int ret;

	wl1271_debug(DEBUG_MAC80211, "mac80211 channel switch");

4435 4436
	wl1271_tx_flush(wl);

4437 4438 4439
	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF)) {
4440 4441 4442 4443 4444
		wl12xx_for_each_wlvif_sta(wl, wlvif) {
			struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
			ieee80211_chswitch_done(vif, false);
		}
		goto out;
4445 4446 4447 4448 4449 4450
	}

	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

4451 4452
	/* TODO: change mac80211 to pass vif as param */
	wl12xx_for_each_wlvif_sta(wl, wlvif) {
4453
		ret = wl12xx_cmd_channel_switch(wl, wlvif, ch_switch);
4454

4455 4456 4457
		if (!ret)
			set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags);
	}
4458 4459 4460 4461 4462 4463 4464

	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);
}

4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475
static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
{
	struct wl1271 *wl = hw->priv;
	bool ret = false;

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF))
		goto out;

	/* packets are considered pending if in the TX queue or the FW */
4476
	ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
4477 4478 4479 4480 4481 4482
out:
	mutex_unlock(&wl->mutex);

	return ret;
}

L
Luciano Coelho 已提交
4483 4484 4485
/* can't be const, mac80211 writes to this */
static struct ieee80211_rate wl1271_rates[] = {
	{ .bitrate = 10,
4486 4487
	  .hw_value = CONF_HW_BIT_RATE_1MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
L
Luciano Coelho 已提交
4488
	{ .bitrate = 20,
4489 4490
	  .hw_value = CONF_HW_BIT_RATE_2MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
L
Luciano Coelho 已提交
4491 4492
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 55,
4493 4494
	  .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
L
Luciano Coelho 已提交
4495 4496
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 110,
4497 4498
	  .hw_value = CONF_HW_BIT_RATE_11MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
L
Luciano Coelho 已提交
4499 4500
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 60,
4501 4502
	  .hw_value = CONF_HW_BIT_RATE_6MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
L
Luciano Coelho 已提交
4503
	{ .bitrate = 90,
4504 4505
	  .hw_value = CONF_HW_BIT_RATE_9MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
L
Luciano Coelho 已提交
4506
	{ .bitrate = 120,
4507 4508
	  .hw_value = CONF_HW_BIT_RATE_12MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
L
Luciano Coelho 已提交
4509
	{ .bitrate = 180,
4510 4511
	  .hw_value = CONF_HW_BIT_RATE_18MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
L
Luciano Coelho 已提交
4512
	{ .bitrate = 240,
4513 4514
	  .hw_value = CONF_HW_BIT_RATE_24MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
L
Luciano Coelho 已提交
4515
	{ .bitrate = 360,
4516 4517
	 .hw_value = CONF_HW_BIT_RATE_36MBPS,
	 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
L
Luciano Coelho 已提交
4518
	{ .bitrate = 480,
4519 4520
	  .hw_value = CONF_HW_BIT_RATE_48MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
L
Luciano Coelho 已提交
4521
	{ .bitrate = 540,
4522 4523
	  .hw_value = CONF_HW_BIT_RATE_54MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
L
Luciano Coelho 已提交
4524 4525
};

4526
/* can't be const, mac80211 writes to this */
L
Luciano Coelho 已提交
4527
static struct ieee80211_channel wl1271_channels[] = {
4528
	{ .hw_value = 1, .center_freq = 2412, .max_power = 25 },
4529
	{ .hw_value = 2, .center_freq = 2417, .max_power = 25 },
4530 4531 4532
	{ .hw_value = 3, .center_freq = 2422, .max_power = 25 },
	{ .hw_value = 4, .center_freq = 2427, .max_power = 25 },
	{ .hw_value = 5, .center_freq = 2432, .max_power = 25 },
4533
	{ .hw_value = 6, .center_freq = 2437, .max_power = 25 },
4534 4535 4536
	{ .hw_value = 7, .center_freq = 2442, .max_power = 25 },
	{ .hw_value = 8, .center_freq = 2447, .max_power = 25 },
	{ .hw_value = 9, .center_freq = 2452, .max_power = 25 },
4537
	{ .hw_value = 10, .center_freq = 2457, .max_power = 25 },
4538 4539 4540
	{ .hw_value = 11, .center_freq = 2462, .max_power = 25 },
	{ .hw_value = 12, .center_freq = 2467, .max_power = 25 },
	{ .hw_value = 13, .center_freq = 2472, .max_power = 25 },
4541
	{ .hw_value = 14, .center_freq = 2484, .max_power = 25 },
L
Luciano Coelho 已提交
4542 4543 4544 4545 4546 4547 4548 4549 4550 4551
};

/* can't be const, mac80211 writes to this */
static struct ieee80211_supported_band wl1271_band_2ghz = {
	.channels = wl1271_channels,
	.n_channels = ARRAY_SIZE(wl1271_channels),
	.bitrates = wl1271_rates,
	.n_bitrates = ARRAY_SIZE(wl1271_rates),
};

4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575 4576 4577 4578 4579
/* 5 GHz data rates for WL1273 */
static struct ieee80211_rate wl1271_rates_5ghz[] = {
	{ .bitrate = 60,
	  .hw_value = CONF_HW_BIT_RATE_6MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
	{ .bitrate = 90,
	  .hw_value = CONF_HW_BIT_RATE_9MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
	{ .bitrate = 120,
	  .hw_value = CONF_HW_BIT_RATE_12MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
	{ .bitrate = 180,
	  .hw_value = CONF_HW_BIT_RATE_18MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
	{ .bitrate = 240,
	  .hw_value = CONF_HW_BIT_RATE_24MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
	{ .bitrate = 360,
	 .hw_value = CONF_HW_BIT_RATE_36MBPS,
	 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
	{ .bitrate = 480,
	  .hw_value = CONF_HW_BIT_RATE_48MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
	{ .bitrate = 540,
	  .hw_value = CONF_HW_BIT_RATE_54MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
};

4580
/* 5 GHz band channels for WL1273 */
4581
static struct ieee80211_channel wl1271_channels_5ghz[] = {
4582 4583 4584 4585 4586 4587 4588 4589 4590 4591 4592 4593 4594 4595 4596 4597 4598 4599 4600 4601 4602 4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615
	{ .hw_value = 7, .center_freq = 5035, .max_power = 25 },
	{ .hw_value = 8, .center_freq = 5040, .max_power = 25 },
	{ .hw_value = 9, .center_freq = 5045, .max_power = 25 },
	{ .hw_value = 11, .center_freq = 5055, .max_power = 25 },
	{ .hw_value = 12, .center_freq = 5060, .max_power = 25 },
	{ .hw_value = 16, .center_freq = 5080, .max_power = 25 },
	{ .hw_value = 34, .center_freq = 5170, .max_power = 25 },
	{ .hw_value = 36, .center_freq = 5180, .max_power = 25 },
	{ .hw_value = 38, .center_freq = 5190, .max_power = 25 },
	{ .hw_value = 40, .center_freq = 5200, .max_power = 25 },
	{ .hw_value = 42, .center_freq = 5210, .max_power = 25 },
	{ .hw_value = 44, .center_freq = 5220, .max_power = 25 },
	{ .hw_value = 46, .center_freq = 5230, .max_power = 25 },
	{ .hw_value = 48, .center_freq = 5240, .max_power = 25 },
	{ .hw_value = 52, .center_freq = 5260, .max_power = 25 },
	{ .hw_value = 56, .center_freq = 5280, .max_power = 25 },
	{ .hw_value = 60, .center_freq = 5300, .max_power = 25 },
	{ .hw_value = 64, .center_freq = 5320, .max_power = 25 },
	{ .hw_value = 100, .center_freq = 5500, .max_power = 25 },
	{ .hw_value = 104, .center_freq = 5520, .max_power = 25 },
	{ .hw_value = 108, .center_freq = 5540, .max_power = 25 },
	{ .hw_value = 112, .center_freq = 5560, .max_power = 25 },
	{ .hw_value = 116, .center_freq = 5580, .max_power = 25 },
	{ .hw_value = 120, .center_freq = 5600, .max_power = 25 },
	{ .hw_value = 124, .center_freq = 5620, .max_power = 25 },
	{ .hw_value = 128, .center_freq = 5640, .max_power = 25 },
	{ .hw_value = 132, .center_freq = 5660, .max_power = 25 },
	{ .hw_value = 136, .center_freq = 5680, .max_power = 25 },
	{ .hw_value = 140, .center_freq = 5700, .max_power = 25 },
	{ .hw_value = 149, .center_freq = 5745, .max_power = 25 },
	{ .hw_value = 153, .center_freq = 5765, .max_power = 25 },
	{ .hw_value = 157, .center_freq = 5785, .max_power = 25 },
	{ .hw_value = 161, .center_freq = 5805, .max_power = 25 },
	{ .hw_value = 165, .center_freq = 5825, .max_power = 25 },
4616 4617 4618 4619 4620 4621 4622
};

static struct ieee80211_supported_band wl1271_band_5ghz = {
	.channels = wl1271_channels_5ghz,
	.n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
	.bitrates = wl1271_rates_5ghz,
	.n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
4623 4624
};

L
Luciano Coelho 已提交
4625 4626 4627 4628 4629
static const struct ieee80211_ops wl1271_ops = {
	.start = wl1271_op_start,
	.stop = wl1271_op_stop,
	.add_interface = wl1271_op_add_interface,
	.remove_interface = wl1271_op_remove_interface,
E
Eliad Peller 已提交
4630
	.change_interface = wl12xx_op_change_interface,
4631
#ifdef CONFIG_PM
4632 4633
	.suspend = wl1271_op_suspend,
	.resume = wl1271_op_resume,
4634
#endif
L
Luciano Coelho 已提交
4635
	.config = wl1271_op_config,
4636
	.prepare_multicast = wl1271_op_prepare_multicast,
L
Luciano Coelho 已提交
4637 4638 4639 4640
	.configure_filter = wl1271_op_configure_filter,
	.tx = wl1271_op_tx,
	.set_key = wl1271_op_set_key,
	.hw_scan = wl1271_op_hw_scan,
4641
	.cancel_hw_scan = wl1271_op_cancel_hw_scan,
4642 4643
	.sched_scan_start = wl1271_op_sched_scan_start,
	.sched_scan_stop = wl1271_op_sched_scan_stop,
L
Luciano Coelho 已提交
4644
	.bss_info_changed = wl1271_op_bss_info_changed,
4645
	.set_frag_threshold = wl1271_op_set_frag_threshold,
L
Luciano Coelho 已提交
4646
	.set_rts_threshold = wl1271_op_set_rts_threshold,
K
Kalle Valo 已提交
4647
	.conf_tx = wl1271_op_conf_tx,
J
Juuso Oikarinen 已提交
4648
	.get_tsf = wl1271_op_get_tsf,
4649
	.get_survey = wl1271_op_get_survey,
4650
	.sta_state = wl12xx_op_sta_state,
L
Levi, Shahar 已提交
4651
	.ampdu_action = wl1271_op_ampdu_action,
4652
	.tx_frames_pending = wl1271_tx_frames_pending,
4653
	.set_bitrate_mask = wl12xx_set_bitrate_mask,
4654
	.channel_switch = wl12xx_op_channel_switch,
K
Kalle Valo 已提交
4655
	CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
L
Luciano Coelho 已提交
4656 4657
};

4658

4659
u8 wlcore_rate_to_idx(struct wl1271 *wl, u8 rate, enum ieee80211_band band)
4660 4661 4662
{
	u8 idx;

4663
	BUG_ON(band >= 2);
4664

4665
	if (unlikely(rate >= wl->hw_tx_rate_tbl_size)) {
4666 4667 4668 4669
		wl1271_error("Illegal RX rate from HW: %d", rate);
		return 0;
	}

4670
	idx = wl->band_rate_to_idx[band][rate];
4671 4672 4673 4674 4675 4676 4677 4678
	if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
		wl1271_error("Unsupported RX rate from HW: %d", rate);
		return 0;
	}

	return idx;
}

4679 4680 4681 4682 4683 4684 4685
static ssize_t wl1271_sysfs_show_bt_coex_state(struct device *dev,
					       struct device_attribute *attr,
					       char *buf)
{
	struct wl1271 *wl = dev_get_drvdata(dev);
	ssize_t len;

4686
	len = PAGE_SIZE;
4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697 4698 4699 4700 4701 4702 4703 4704

	mutex_lock(&wl->mutex);
	len = snprintf(buf, len, "%d\n\n0 - off\n1 - on\n",
		       wl->sg_enabled);
	mutex_unlock(&wl->mutex);

	return len;

}

static ssize_t wl1271_sysfs_store_bt_coex_state(struct device *dev,
						struct device_attribute *attr,
						const char *buf, size_t count)
{
	struct wl1271 *wl = dev_get_drvdata(dev);
	unsigned long res;
	int ret;

L
Luciano Coelho 已提交
4705
	ret = kstrtoul(buf, 10, &res);
4706 4707 4708 4709 4710 4711 4712 4713 4714 4715 4716 4717 4718 4719 4720 4721 4722
	if (ret < 0) {
		wl1271_warning("incorrect value written to bt_coex_mode");
		return count;
	}

	mutex_lock(&wl->mutex);

	res = !!res;

	if (res == wl->sg_enabled)
		goto out;

	wl->sg_enabled = res;

	if (wl->state == WL1271_STATE_OFF)
		goto out;

4723
	ret = wl1271_ps_elp_wakeup(wl);
4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737 4738
	if (ret < 0)
		goto out;

	wl1271_acx_sg_enable(wl, wl->sg_enabled);
	wl1271_ps_elp_sleep(wl);

 out:
	mutex_unlock(&wl->mutex);
	return count;
}

static DEVICE_ATTR(bt_coex_state, S_IRUGO | S_IWUSR,
		   wl1271_sysfs_show_bt_coex_state,
		   wl1271_sysfs_store_bt_coex_state);

4739 4740 4741 4742 4743 4744 4745
static ssize_t wl1271_sysfs_show_hw_pg_ver(struct device *dev,
					   struct device_attribute *attr,
					   char *buf)
{
	struct wl1271 *wl = dev_get_drvdata(dev);
	ssize_t len;

4746
	len = PAGE_SIZE;
4747 4748 4749 4750 4751 4752 4753 4754 4755 4756 4757

	mutex_lock(&wl->mutex);
	if (wl->hw_pg_ver >= 0)
		len = snprintf(buf, len, "%d\n", wl->hw_pg_ver);
	else
		len = snprintf(buf, len, "n/a\n");
	mutex_unlock(&wl->mutex);

	return len;
}

4758
static DEVICE_ATTR(hw_pg_ver, S_IRUGO,
4759 4760
		   wl1271_sysfs_show_hw_pg_ver, NULL);

4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771 4772 4773 4774 4775 4776 4777 4778 4779 4780 4781 4782 4783 4784 4785 4786 4787 4788 4789 4790 4791 4792 4793 4794 4795 4796 4797 4798 4799 4800 4801 4802 4803 4804 4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823
static ssize_t wl1271_sysfs_read_fwlog(struct file *filp, struct kobject *kobj,
				       struct bin_attribute *bin_attr,
				       char *buffer, loff_t pos, size_t count)
{
	struct device *dev = container_of(kobj, struct device, kobj);
	struct wl1271 *wl = dev_get_drvdata(dev);
	ssize_t len;
	int ret;

	ret = mutex_lock_interruptible(&wl->mutex);
	if (ret < 0)
		return -ERESTARTSYS;

	/* Let only one thread read the log at a time, blocking others */
	while (wl->fwlog_size == 0) {
		DEFINE_WAIT(wait);

		prepare_to_wait_exclusive(&wl->fwlog_waitq,
					  &wait,
					  TASK_INTERRUPTIBLE);

		if (wl->fwlog_size != 0) {
			finish_wait(&wl->fwlog_waitq, &wait);
			break;
		}

		mutex_unlock(&wl->mutex);

		schedule();
		finish_wait(&wl->fwlog_waitq, &wait);

		if (signal_pending(current))
			return -ERESTARTSYS;

		ret = mutex_lock_interruptible(&wl->mutex);
		if (ret < 0)
			return -ERESTARTSYS;
	}

	/* Check if the fwlog is still valid */
	if (wl->fwlog_size < 0) {
		mutex_unlock(&wl->mutex);
		return 0;
	}

	/* Seeking is not supported - old logs are not kept. Disregard pos. */
	len = min(count, (size_t)wl->fwlog_size);
	wl->fwlog_size -= len;
	memcpy(buffer, wl->fwlog, len);

	/* Make room for new messages */
	memmove(wl->fwlog, wl->fwlog + len, wl->fwlog_size);

	mutex_unlock(&wl->mutex);

	return len;
}

static struct bin_attribute fwlog_attr = {
	.attr = {.name = "fwlog", .mode = S_IRUSR},
	.read = wl1271_sysfs_read_fwlog,
};

4824
static void wl1271_connection_loss_work(struct work_struct *work)
4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851
{
	struct delayed_work *dwork;
	struct wl1271 *wl;
	struct ieee80211_vif *vif;
	struct wl12xx_vif *wlvif;

	dwork = container_of(work, struct delayed_work, work);
	wl = container_of(dwork, struct wl1271, connection_loss_work);

	wl1271_info("Connection loss work.");

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state == WL1271_STATE_OFF))
		goto out;

	/* Call mac80211 connection loss */
	wl12xx_for_each_wlvif_sta(wl, wlvif) {
		if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
			goto out;
		vif = wl12xx_wlvif_to_vif(wlvif);
		ieee80211_connection_loss(vif);
	}
out:
	mutex_unlock(&wl->mutex);
}

4852 4853 4854 4855 4856 4857 4858 4859 4860 4861 4862 4863 4864 4865 4866 4867 4868 4869 4870 4871 4872 4873 4874 4875 4876
static void wl12xx_derive_mac_addresses(struct wl1271 *wl,
					u32 oui, u32 nic, int n)
{
	int i;

	wl1271_debug(DEBUG_PROBE, "base address: oui %06x nic %06x, n %d",
		     oui, nic, n);

	if (nic + n - 1 > 0xffffff)
		wl1271_warning("NIC part of the MAC address wraps around!");

	for (i = 0; i < n; i++) {
		wl->addresses[i].addr[0] = (u8)(oui >> 16);
		wl->addresses[i].addr[1] = (u8)(oui >> 8);
		wl->addresses[i].addr[2] = (u8) oui;
		wl->addresses[i].addr[3] = (u8)(nic >> 16);
		wl->addresses[i].addr[4] = (u8)(nic >> 8);
		wl->addresses[i].addr[5] = (u8) nic;
		nic++;
	}

	wl->hw->wiphy->n_addresses = n;
	wl->hw->wiphy->addresses = wl->addresses;
}

4877 4878 4879 4880 4881 4882 4883 4884
static int wl12xx_get_hw_info(struct wl1271 *wl)
{
	int ret;

	ret = wl12xx_set_power_on(wl);
	if (ret < 0)
		goto out;

4885
	wl->chip.id = wlcore_read_reg(wl, REG_CHIP_ID_B);
4886

4887 4888
	wl->fuse_oui_addr = 0;
	wl->fuse_nic_addr = 0;
4889

4890
	wl->hw_pg_ver = wl->ops->get_pg_ver(wl);
4891

4892 4893
	if (wl->ops->get_mac)
		wl->ops->get_mac(wl);
4894

4895 4896 4897 4898 4899
	wl1271_power_off(wl);
out:
	return ret;
}

F
Felipe Balbi 已提交
4900
static int wl1271_register_hw(struct wl1271 *wl)
L
Luciano Coelho 已提交
4901 4902
{
	int ret;
4903
	u32 oui_addr = 0, nic_addr = 0;
L
Luciano Coelho 已提交
4904 4905 4906 4907

	if (wl->mac80211_registered)
		return 0;

4908 4909 4910 4911 4912 4913
	ret = wl12xx_get_hw_info(wl);
	if (ret < 0) {
		wl1271_error("couldn't get hw info");
		goto out;
	}

4914 4915
	ret = wl1271_fetch_nvs(wl);
	if (ret == 0) {
4916 4917 4918 4919 4920
		/* NOTE: The wl->nvs->nvs element must be first, in
		 * order to simplify the casting, we assume it is at
		 * the beginning of the wl->nvs structure.
		 */
		u8 *nvs_ptr = (u8 *)wl->nvs;
4921

4922 4923 4924 4925 4926 4927 4928 4929 4930 4931 4932
		oui_addr =
			(nvs_ptr[11] << 16) + (nvs_ptr[10] << 8) + nvs_ptr[6];
		nic_addr =
			(nvs_ptr[5] << 16) + (nvs_ptr[4] << 8) + nvs_ptr[3];
	}

	/* if the MAC address is zeroed in the NVS derive from fuse */
	if (oui_addr == 0 && nic_addr == 0) {
		oui_addr = wl->fuse_oui_addr;
		/* fuse has the BD_ADDR, the WLAN addresses are the next two */
		nic_addr = wl->fuse_nic_addr + 1;
4933 4934
	}

4935
	wl12xx_derive_mac_addresses(wl, oui_addr, nic_addr, 2);
L
Luciano Coelho 已提交
4936 4937 4938 4939

	ret = ieee80211_register_hw(wl->hw);
	if (ret < 0) {
		wl1271_error("unable to register mac80211 hw: %d", ret);
4940
		goto out;
L
Luciano Coelho 已提交
4941 4942 4943 4944
	}

	wl->mac80211_registered = true;

4945 4946
	wl1271_debugfs_init(wl);

L
Luciano Coelho 已提交
4947 4948
	wl1271_notice("loaded");

4949 4950
out:
	return ret;
L
Luciano Coelho 已提交
4951 4952
}

F
Felipe Balbi 已提交
4953
static void wl1271_unregister_hw(struct wl1271 *wl)
4954
{
4955
	if (wl->plt)
4956
		wl1271_plt_stop(wl);
4957

4958 4959 4960 4961 4962
	ieee80211_unregister_hw(wl->hw);
	wl->mac80211_registered = false;

}

F
Felipe Balbi 已提交
4963
static int wl1271_init_ieee80211(struct wl1271 *wl)
L
Luciano Coelho 已提交
4964
{
4965 4966 4967 4968 4969 4970 4971 4972
	static const u32 cipher_suites[] = {
		WLAN_CIPHER_SUITE_WEP40,
		WLAN_CIPHER_SUITE_WEP104,
		WLAN_CIPHER_SUITE_TKIP,
		WLAN_CIPHER_SUITE_CCMP,
		WL1271_CIPHER_SUITE_GEM,
	};

4973
	/* The tx descriptor buffer and the TKIP space. */
4974
	wl->hw->extra_tx_headroom = WL1271_EXTRA_SPACE_TKIP +
4975
		sizeof(struct wl1271_tx_hw_descr);
L
Luciano Coelho 已提交
4976 4977 4978 4979

	/* unit us */
	/* FIXME: find a proper value */
	wl->hw->channel_change_time = 10000;
4980
	wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
L
Luciano Coelho 已提交
4981 4982

	wl->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4983
		IEEE80211_HW_SUPPORTS_PS |
4984
		IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
K
Kalle Valo 已提交
4985
		IEEE80211_HW_SUPPORTS_UAPSD |
4986
		IEEE80211_HW_HAS_RATE_CONTROL |
4987
		IEEE80211_HW_CONNECTION_MONITOR |
4988
		IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4989
		IEEE80211_HW_SPECTRUM_MGMT |
4990 4991
		IEEE80211_HW_AP_LINK_PS |
		IEEE80211_HW_AMPDU_AGGREGATION |
4992 4993
		IEEE80211_HW_TX_AMPDU_SETUP_IN_HW |
		IEEE80211_HW_SCAN_WHILE_IDLE;
L
Luciano Coelho 已提交
4994

4995 4996 4997
	wl->hw->wiphy->cipher_suites = cipher_suites;
	wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);

4998
	wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
E
Eliad Peller 已提交
4999 5000
		BIT(NL80211_IFTYPE_ADHOC) | BIT(NL80211_IFTYPE_AP) |
		BIT(NL80211_IFTYPE_P2P_CLIENT) | BIT(NL80211_IFTYPE_P2P_GO);
L
Luciano Coelho 已提交
5001
	wl->hw->wiphy->max_scan_ssids = 1;
5002 5003
	wl->hw->wiphy->max_sched_scan_ssids = 16;
	wl->hw->wiphy->max_match_sets = 16;
5004 5005 5006 5007 5008
	/*
	 * Maximum length of elements in scanning probe request templates
	 * should be the maximum length possible for a template, without
	 * the IEEE80211 header of the template
	 */
5009
	wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
5010
			sizeof(struct ieee80211_header);
5011

5012
	wl->hw->wiphy->max_sched_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
5013 5014
		sizeof(struct ieee80211_header);

5015 5016
	wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD |
				WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
5017

5018 5019 5020 5021
	/* make sure all our channels fit in the scanned_ch bitmask */
	BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
		     ARRAY_SIZE(wl1271_channels_5ghz) >
		     WL1271_MAX_CHANNELS);
5022 5023 5024 5025 5026 5027
	/*
	 * We keep local copies of the band structs because we need to
	 * modify them on a per-device basis.
	 */
	memcpy(&wl->bands[IEEE80211_BAND_2GHZ], &wl1271_band_2ghz,
	       sizeof(wl1271_band_2ghz));
5028 5029
	memcpy(&wl->bands[IEEE80211_BAND_2GHZ].ht_cap, &wl->ht_cap,
	       sizeof(wl->ht_cap));
5030 5031
	memcpy(&wl->bands[IEEE80211_BAND_5GHZ], &wl1271_band_5ghz,
	       sizeof(wl1271_band_5ghz));
5032 5033
	memcpy(&wl->bands[IEEE80211_BAND_5GHZ].ht_cap, &wl->ht_cap,
	       sizeof(wl->ht_cap));
5034 5035 5036 5037 5038

	wl->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
		&wl->bands[IEEE80211_BAND_2GHZ];
	wl->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
		&wl->bands[IEEE80211_BAND_5GHZ];
5039

K
Kalle Valo 已提交
5040
	wl->hw->queues = 4;
J
Juuso Oikarinen 已提交
5041
	wl->hw->max_rates = 1;
K
Kalle Valo 已提交
5042

5043 5044
	wl->hw->wiphy->reg_notifier = wl1271_reg_notify;

5045 5046 5047 5048 5049 5050 5051
	/* the FW answers probe-requests in AP-mode */
	wl->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
	wl->hw->wiphy->probe_resp_offload =
		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;

5052
	SET_IEEE80211_DEV(wl->hw, wl->dev);
L
Luciano Coelho 已提交
5053

5054
	wl->hw->sta_data_size = sizeof(struct wl1271_station);
E
Eliad Peller 已提交
5055
	wl->hw->vif_data_size = sizeof(struct wl12xx_vif);
5056

5057
	wl->hw->max_rx_aggregation_subframes = wl->conf.ht.rx_ba_win_size;
5058

L
Luciano Coelho 已提交
5059 5060 5061 5062
	return 0;
}

#define WL1271_DEFAULT_CHANNEL 0
5063

5064
struct ieee80211_hw *wlcore_alloc_hw(size_t priv_size)
L
Luciano Coelho 已提交
5065 5066 5067
{
	struct ieee80211_hw *hw;
	struct wl1271 *wl;
5068
	int i, j, ret;
5069
	unsigned int order;
L
Luciano Coelho 已提交
5070

5071
	BUILD_BUG_ON(AP_MAX_STATIONS > WL12XX_MAX_LINKS);
5072

L
Luciano Coelho 已提交
5073 5074 5075
	hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
	if (!hw) {
		wl1271_error("could not alloc ieee80211_hw");
5076
		ret = -ENOMEM;
5077 5078 5079
		goto err_hw_alloc;
	}

L
Luciano Coelho 已提交
5080 5081 5082
	wl = hw->priv;
	memset(wl, 0, sizeof(*wl));

5083 5084 5085 5086 5087 5088 5089
	wl->priv = kzalloc(priv_size, GFP_KERNEL);
	if (!wl->priv) {
		wl1271_error("could not alloc wl priv");
		ret = -ENOMEM;
		goto err_priv_alloc;
	}

E
Eliad Peller 已提交
5090
	INIT_LIST_HEAD(&wl->wlvif_list);
5091

L
Luciano Coelho 已提交
5092 5093
	wl->hw = hw;

5094
	for (i = 0; i < NUM_TX_QUEUES; i++)
5095
		for (j = 0; j < WL12XX_MAX_LINKS; j++)
5096 5097
			skb_queue_head_init(&wl->links[j].tx_queue[i]);

5098 5099 5100
	skb_queue_head_init(&wl->deferred_rx_queue);
	skb_queue_head_init(&wl->deferred_tx_queue);

5101
	INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
5102
	INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
5103 5104 5105
	INIT_WORK(&wl->tx_work, wl1271_tx_work);
	INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
	INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
A
Arik Nemtsov 已提交
5106
	INIT_DELAYED_WORK(&wl->tx_watchdog_work, wl12xx_tx_watchdog_work);
5107 5108
	INIT_DELAYED_WORK(&wl->connection_loss_work,
			  wl1271_connection_loss_work);
5109

5110 5111 5112 5113 5114 5115
	wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
	if (!wl->freezable_wq) {
		ret = -ENOMEM;
		goto err_hw;
	}

L
Luciano Coelho 已提交
5116 5117 5118
	wl->channel = WL1271_DEFAULT_CHANNEL;
	wl->rx_counter = 0;
	wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
5119
	wl->band = IEEE80211_BAND_2GHZ;
5120
	wl->flags = 0;
5121
	wl->sg_enabled = true;
5122
	wl->hw_pg_ver = -1;
5123 5124
	wl->ap_ps_map = 0;
	wl->ap_fw_ps_map = 0;
5125
	wl->quirks = 0;
5126
	wl->platform_quirks = 0;
5127
	wl->sched_scanning = false;
E
Eliad Peller 已提交
5128
	wl->system_hlid = WL12XX_SYSTEM_HLID;
5129
	wl->active_sta_count = 0;
5130 5131
	wl->fwlog_size = 0;
	init_waitqueue_head(&wl->fwlog_waitq);
L
Luciano Coelho 已提交
5132

E
Eliad Peller 已提交
5133 5134 5135
	/* The system link is always allocated */
	__set_bit(WL12XX_SYSTEM_HLID, wl->links_map);

5136
	memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
5137
	for (i = 0; i < wl->num_tx_desc; i++)
L
Luciano Coelho 已提交
5138 5139 5140 5141 5142
		wl->tx_frames[i] = NULL;

	spin_lock_init(&wl->wl_lock);

	wl->state = WL1271_STATE_OFF;
5143
	wl->fw_type = WL12XX_FW_TYPE_NONE;
L
Luciano Coelho 已提交
5144 5145
	mutex_init(&wl->mutex);

5146 5147 5148 5149
	order = get_order(WL1271_AGGR_BUFFER_SIZE);
	wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
	if (!wl->aggr_buf) {
		ret = -ENOMEM;
5150
		goto err_wq;
5151 5152
	}

5153 5154 5155 5156 5157 5158
	wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
	if (!wl->dummy_packet) {
		ret = -ENOMEM;
		goto err_aggr;
	}

5159 5160 5161 5162 5163 5164 5165
	/* Allocate one page for the FW log */
	wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
	if (!wl->fwlog) {
		ret = -ENOMEM;
		goto err_dummy_packet;
	}

5166
	wl->mbox = kmalloc(sizeof(*wl->mbox), GFP_KERNEL | GFP_DMA);
5167 5168 5169 5170 5171
	if (!wl->mbox) {
		ret = -ENOMEM;
		goto err_fwlog;
	}

5172
	return hw;
5173

5174 5175 5176
err_fwlog:
	free_page((unsigned long)wl->fwlog);

5177 5178 5179
err_dummy_packet:
	dev_kfree_skb(wl->dummy_packet);

5180 5181 5182
err_aggr:
	free_pages((unsigned long)wl->aggr_buf, order);

5183 5184 5185
err_wq:
	destroy_workqueue(wl->freezable_wq);

5186
err_hw:
5187
	wl1271_debugfs_exit(wl);
5188 5189 5190
	kfree(wl->priv);

err_priv_alloc:
5191 5192 5193
	ieee80211_free_hw(hw);

err_hw_alloc:
5194 5195

	return ERR_PTR(ret);
5196
}
5197
EXPORT_SYMBOL_GPL(wlcore_alloc_hw);
5198

5199
int wlcore_free_hw(struct wl1271 *wl)
5200
{
5201 5202 5203 5204 5205 5206
	/* Unblock any fwlog readers */
	mutex_lock(&wl->mutex);
	wl->fwlog_size = -1;
	wake_up_interruptible_all(&wl->fwlog_waitq);
	mutex_unlock(&wl->mutex);

F
Felipe Balbi 已提交
5207
	device_remove_bin_file(wl->dev, &fwlog_attr);
5208

F
Felipe Balbi 已提交
5209
	device_remove_file(wl->dev, &dev_attr_hw_pg_ver);
5210

F
Felipe Balbi 已提交
5211
	device_remove_file(wl->dev, &dev_attr_bt_coex_state);
5212
	free_page((unsigned long)wl->fwlog);
5213
	dev_kfree_skb(wl->dummy_packet);
5214 5215
	free_pages((unsigned long)wl->aggr_buf,
			get_order(WL1271_AGGR_BUFFER_SIZE));
5216 5217 5218 5219 5220

	wl1271_debugfs_exit(wl);

	vfree(wl->fw);
	wl->fw = NULL;
5221
	wl->fw_type = WL12XX_FW_TYPE_NONE;
5222 5223 5224 5225 5226
	kfree(wl->nvs);
	wl->nvs = NULL;

	kfree(wl->fw_status);
	kfree(wl->tx_res_if);
5227
	destroy_workqueue(wl->freezable_wq);
5228

5229
	kfree(wl->priv);
5230 5231 5232 5233
	ieee80211_free_hw(wl->hw);

	return 0;
}
5234
EXPORT_SYMBOL_GPL(wlcore_free_hw);
5235

5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263 5264
static irqreturn_t wl12xx_hardirq(int irq, void *cookie)
{
	struct wl1271 *wl = cookie;
	unsigned long flags;

	wl1271_debug(DEBUG_IRQ, "IRQ");

	/* complete the ELP completion */
	spin_lock_irqsave(&wl->wl_lock, flags);
	set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
	if (wl->elp_compl) {
		complete(wl->elp_compl);
		wl->elp_compl = NULL;
	}

	if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) {
		/* don't enqueue a work right now. mark it as pending */
		set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags);
		wl1271_debug(DEBUG_IRQ, "should not enqueue work");
		disable_irq_nosync(wl->irq);
		pm_wakeup_event(wl->dev, 0);
		spin_unlock_irqrestore(&wl->wl_lock, flags);
		return IRQ_HANDLED;
	}
	spin_unlock_irqrestore(&wl->wl_lock, flags);

	return IRQ_WAKE_THREAD;
}

5265
int __devinit wlcore_probe(struct wl1271 *wl, struct platform_device *pdev)
5266
{
5267 5268
	struct wl12xx_platform_data *pdata = pdev->dev.platform_data;
	unsigned long irqflags;
5269
	int ret;
5270

5271
	if (!wl->ops || !wl->ptable) {
5272 5273
		ret = -EINVAL;
		goto out_free_hw;
5274 5275
	}

5276 5277
	BUG_ON(wl->num_tx_desc > WLCORE_MAX_TX_DESCRIPTORS);

5278 5279 5280
	/* adjust some runtime configuration parameters */
	wlcore_adjust_conf(wl);

5281 5282 5283 5284 5285 5286 5287 5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307
	wl->irq = platform_get_irq(pdev, 0);
	wl->ref_clock = pdata->board_ref_clock;
	wl->tcxo_clock = pdata->board_tcxo_clock;
	wl->platform_quirks = pdata->platform_quirks;
	wl->set_power = pdata->set_power;
	wl->dev = &pdev->dev;
	wl->if_ops = pdata->ops;

	platform_set_drvdata(pdev, wl);

	if (wl->platform_quirks & WL12XX_PLATFORM_QUIRK_EDGE_IRQ)
		irqflags = IRQF_TRIGGER_RISING;
	else
		irqflags = IRQF_TRIGGER_HIGH | IRQF_ONESHOT;

	ret = request_threaded_irq(wl->irq, wl12xx_hardirq, wl1271_irq,
				   irqflags,
				   pdev->name, wl);
	if (ret < 0) {
		wl1271_error("request_irq() failed: %d", ret);
		goto out_free_hw;
	}

	ret = enable_irq_wake(wl->irq);
	if (!ret) {
		wl->irq_wake_enabled = true;
		device_init_wakeup(wl->dev, 1);
5308
		if (pdata->pwr_in_suspend) {
5309
			wl->hw->wiphy->wowlan.flags = WIPHY_WOWLAN_ANY;
5310 5311 5312 5313 5314 5315
			wl->hw->wiphy->wowlan.n_patterns =
				WL1271_MAX_RX_FILTERS;
			wl->hw->wiphy->wowlan.pattern_min_len = 1;
			wl->hw->wiphy->wowlan.pattern_max_len =
				WL1271_RX_FILTER_MAX_PATTERN_SIZE;
		}
5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326
	}
	disable_irq(wl->irq);

	ret = wl1271_init_ieee80211(wl);
	if (ret)
		goto out_irq;

	ret = wl1271_register_hw(wl);
	if (ret)
		goto out_irq;

F
Felipe Balbi 已提交
5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338 5339 5340 5341 5342 5343 5344 5345 5346 5347
	/* Create sysfs file to control bt coex state */
	ret = device_create_file(wl->dev, &dev_attr_bt_coex_state);
	if (ret < 0) {
		wl1271_error("failed to create sysfs file bt_coex_state");
		goto out_irq;
	}

	/* Create sysfs file to get HW PG version */
	ret = device_create_file(wl->dev, &dev_attr_hw_pg_ver);
	if (ret < 0) {
		wl1271_error("failed to create sysfs file hw_pg_ver");
		goto out_bt_coex_state;
	}

	/* Create sysfs file for the FW log */
	ret = device_create_bin_file(wl->dev, &fwlog_attr);
	if (ret < 0) {
		wl1271_error("failed to create sysfs file fwlog");
		goto out_hw_pg_ver;
	}

5348
	goto out;
5349

F
Felipe Balbi 已提交
5350 5351 5352 5353 5354 5355
out_hw_pg_ver:
	device_remove_file(wl->dev, &dev_attr_hw_pg_ver);

out_bt_coex_state:
	device_remove_file(wl->dev, &dev_attr_bt_coex_state);

5356 5357 5358 5359
out_irq:
	free_irq(wl->irq, wl);

out_free_hw:
5360
	wlcore_free_hw(wl);
5361 5362 5363

out:
	return ret;
5364
}
5365
EXPORT_SYMBOL_GPL(wlcore_probe);
5366

5367
int __devexit wlcore_remove(struct platform_device *pdev)
5368
{
5369 5370 5371 5372 5373 5374 5375 5376
	struct wl1271 *wl = platform_get_drvdata(pdev);

	if (wl->irq_wake_enabled) {
		device_init_wakeup(wl->dev, 0);
		disable_irq_wake(wl->irq);
	}
	wl1271_unregister_hw(wl);
	free_irq(wl->irq, wl);
5377
	wlcore_free_hw(wl);
5378

5379 5380
	return 0;
}
5381
EXPORT_SYMBOL_GPL(wlcore_remove);
5382

5383
u32 wl12xx_debug_level = DEBUG_NONE;
5384
EXPORT_SYMBOL_GPL(wl12xx_debug_level);
5385
module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
5386 5387
MODULE_PARM_DESC(debug_level, "wl12xx debugging level");

5388
module_param_named(fwlog, fwlog_param, charp, 0);
5389
MODULE_PARM_DESC(fwlog,
5390 5391
		 "FW logger options: continuous, ondemand, dbgpins or disable");

5392 5393 5394
module_param(bug_on_recovery, bool, S_IRUSR | S_IWUSR);
MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");

5395 5396 5397
module_param(no_recovery, bool, S_IRUSR | S_IWUSR);
MODULE_PARM_DESC(no_recovery, "Prevent HW recovery. FW will remain stuck.");

5398
MODULE_LICENSE("GPL");
5399
MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
5400
MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");