main.c 164.5 KB
Newer Older
L
Luciano Coelho 已提交
1
/*
2
 * This file is part of wlcore
L
Luciano Coelho 已提交
3
 *
J
Juuso Oikarinen 已提交
4
 * Copyright (C) 2008-2010 Nokia Corporation
5
 * Copyright (C) 2011-2013 Texas Instruments Inc.
L
Luciano Coelho 已提交
6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
 *
 * 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/etherdevice.h>
26
#include <linux/vmalloc.h>
27
#include <linux/interrupt.h>
28
#include <linux/irq.h>
L
Luciano Coelho 已提交
29

30
#include "wlcore.h"
31
#include "debug.h"
L
Luciano Coelho 已提交
32
#include "wl12xx_80211.h"
S
Shahar Levi 已提交
33 34 35 36 37 38
#include "io.h"
#include "tx.h"
#include "ps.h"
#include "init.h"
#include "debugfs.h"
#include "testmode.h"
E
Eliad Peller 已提交
39
#include "vendor_cmd.h"
S
Shahar Levi 已提交
40
#include "scan.h"
41
#include "hw_ops.h"
42
#include "sysfs.h"
L
Luciano Coelho 已提交
43

44
#define WL1271_BOOT_RETRIES 3
45
#define WL1271_SUSPEND_SLEEP 100
46

47
static char *fwlog_param;
I
Ido Reis 已提交
48
static int fwlog_mem_blocks = -1;
49 50
static int bug_on_recovery = -1;
static int no_recovery     = -1;
51

52
static void __wl1271_op_remove_interface(struct wl1271 *wl,
E
Eliad Peller 已提交
53
					 struct ieee80211_vif *vif,
54
					 bool reset_tx_queues);
55
static void wlcore_op_stop_locked(struct wl1271 *wl);
56
static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif);
57

58
static int wl12xx_set_authorized(struct wl1271 *wl, struct wl12xx_vif *wlvif)
59 60
{
	int ret;
E
Eliad Peller 已提交
61

62 63 64 65
	if (WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS))
		return -EINVAL;

	if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
66 67
		return 0;

68
	if (test_and_set_bit(WLVIF_FLAG_STA_STATE_SENT, &wlvif->flags))
69 70
		return 0;

71
	ret = wl12xx_cmd_set_peer_state(wl, wlvif, wlvif->sta.hlid);
72 73 74 75 76 77
	if (ret < 0)
		return ret;

	wl1271_info("Association completed.");
	return 0;
}
78

79 80
static void wl1271_reg_notify(struct wiphy *wiphy,
			      struct regulatory_request *request)
81
{
82 83
	struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
	struct wl1271 *wl = hw->priv;
84

85 86 87 88
	/* copy the current dfs region */
	if (request)
		wl->dfs_region = request->dfs_region;

89
	wlcore_regdomain_config(wl);
90 91
}

E
Eliad Peller 已提交
92 93
static int wl1271_set_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif,
				   bool enable)
94 95 96 97
{
	int ret = 0;

	/* we should hold wl->mutex */
E
Eliad Peller 已提交
98
	ret = wl1271_acx_ps_rx_streaming(wl, wlvif, enable);
99 100 101 102
	if (ret < 0)
		goto out;

	if (enable)
103
		set_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
104
	else
105
		clear_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
106 107 108 109 110 111 112 113
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 已提交
114
int wl1271_recalc_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif)
115 116 117 118 119
{
	int ret = 0;
	int period = wl->conf.rx_streaming.interval;

	/* don't reconfigure if rx_streaming is disabled */
120
	if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
121 122 123 124
		goto out;

	/* reconfigure/disable according to new streaming_period */
	if (period &&
125
	    test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
126 127
	    (wl->conf.rx_streaming.always ||
	     test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
E
Eliad Peller 已提交
128
		ret = wl1271_set_rx_streaming(wl, wlvif, true);
129
	else {
E
Eliad Peller 已提交
130
		ret = wl1271_set_rx_streaming(wl, wlvif, false);
131
		/* don't cancel_work_sync since we might deadlock */
E
Eliad Peller 已提交
132
		del_timer_sync(&wlvif->rx_streaming_timer);
133 134 135 136 137 138 139 140
	}
out:
	return ret;
}

static void wl1271_rx_streaming_enable_work(struct work_struct *work)
{
	int ret;
E
Eliad Peller 已提交
141 142 143
	struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
						rx_streaming_enable_work);
	struct wl1271 *wl = wlvif->wl;
144 145 146

	mutex_lock(&wl->mutex);

147
	if (test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags) ||
148
	    !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
149 150 151 152 153 154 155 156 157 158 159
	    (!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 已提交
160
	ret = wl1271_set_rx_streaming(wl, wlvif, true);
161 162 163 164
	if (ret < 0)
		goto out_sleep;

	/* stop it after some time of inactivity */
E
Eliad Peller 已提交
165
	mod_timer(&wlvif->rx_streaming_timer,
166 167 168 169 170 171 172 173 174 175 176
		  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 已提交
177 178 179
	struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
						rx_streaming_disable_work);
	struct wl1271 *wl = wlvif->wl;
180 181 182

	mutex_lock(&wl->mutex);

183
	if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
184 185 186 187 188 189
		goto out;

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

E
Eliad Peller 已提交
190
	ret = wl1271_set_rx_streaming(wl, wlvif, false);
191 192 193 194 195 196 197 198 199
	if (ret)
		goto out_sleep;

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

200
static void wl1271_rx_streaming_timer(struct timer_list *t)
201
{
202
	struct wl12xx_vif *wlvif = from_timer(wlvif, t, rx_streaming_timer);
E
Eliad Peller 已提交
203 204
	struct wl1271 *wl = wlvif->wl;
	ieee80211_queue_work(wl->hw, &wlvif->rx_streaming_disable_work);
205 206
}

A
Arik Nemtsov 已提交
207 208 209 210 211 212 213 214 215 216 217 218
/* 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));
}

219 220 221 222 223 224
static void wlcore_rc_update_work(struct work_struct *work)
{
	int ret;
	struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
						rc_update_work);
	struct wl1271 *wl = wlvif->wl;
225
	struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
226 227 228 229 230 231 232 233 234 235

	mutex_lock(&wl->mutex);

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

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

236 237 238 239 240 241 242 243
	if (ieee80211_vif_is_mesh(vif)) {
		ret = wl1271_acx_set_ht_capabilities(wl, &wlvif->rc_ht_cap,
						     true, wlvif->sta.hlid);
		if (ret < 0)
			goto out_sleep;
	} else {
		wlcore_hw_sta_rc_update(wl, wlvif);
	}
244

245
out_sleep:
246 247 248 249 250
	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
}

A
Arik Nemtsov 已提交
251 252 253 254 255
static void wl12xx_tx_watchdog_work(struct work_struct *work)
{
	struct delayed_work *dwork;
	struct wl1271 *wl;

G
Geliang Tang 已提交
256
	dwork = to_delayed_work(work);
A
Arik Nemtsov 已提交
257 258 259 260
	wl = container_of(dwork, struct wl1271, tx_watchdog_work);

	mutex_lock(&wl->mutex);

261
	if (unlikely(wl->state != WLCORE_STATE_ON))
A
Arik Nemtsov 已提交
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 303 304 305 306 307 308 309 310 311 312
		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);
}

313
static void wlcore_adjust_conf(struct wl1271 *wl)
314
{
I
Ido Reis 已提交
315

316 317 318
	if (fwlog_param) {
		if (!strcmp(fwlog_param, "continuous")) {
			wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
S
Shahar Patury 已提交
319
			wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_HOST;
320 321 322 323 324 325 326 327 328 329
		} 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);
		}
	}
330 331 332 333 334 335

	if (bug_on_recovery != -1)
		wl->conf.recovery.bug_on_recovery = (u8) bug_on_recovery;

	if (no_recovery != -1)
		wl->conf.recovery.no_recovery = (u8) no_recovery;
336
}
337

338 339 340
static void wl12xx_irq_ps_regulate_link(struct wl1271 *wl,
					struct wl12xx_vif *wlvif,
					u8 hlid, u8 tx_pkts)
341
{
342
	bool fw_ps;
343

344
	fw_ps = test_bit(hlid, &wl->ap_fw_ps_map);
345 346 347

	/*
	 * Wake up from high level PS if the STA is asleep with too little
348
	 * packets in FW or if the STA is awake.
349
	 */
350
	if (!fw_ps || tx_pkts < WL1271_PS_STA_MAX_PACKETS)
351
		wl12xx_ps_link_end(wl, wlvif, hlid);
352

353 354
	/*
	 * Start high-level PS if the STA is asleep with enough blocks in FW.
355 356
	 * Make an exception if this is the only connected link. In this
	 * case FW-memory congestion is less of a problem.
357 358 359 360
	 * Note that a single connected STA means 2*ap_count + 1 active links,
	 * since we must account for the global and broadcast AP links
	 * for each AP. The "fw_ps" check assures us the other link is a STA
	 * connected to the AP. Otherwise the FW would not set the PSM bit.
361
	 */
362
	else if (wl->active_link_count > (wl->ap_count*2 + 1) && fw_ps &&
363
		 tx_pkts >= WL1271_PS_STA_MAX_PACKETS)
364
		wl12xx_ps_link_start(wl, wlvif, hlid, true);
365 366
}

367
static void wl12xx_irq_update_links_status(struct wl1271 *wl,
368
					   struct wl12xx_vif *wlvif,
369
					   struct wl_fw_status *status)
370
{
371
	unsigned long cur_fw_ps_map;
372
	u8 hlid;
373

374
	cur_fw_ps_map = status->link_ps_bitmap;
375 376
	if (wl->ap_fw_ps_map != cur_fw_ps_map) {
		wl1271_debug(DEBUG_PSM,
377
			     "link ps prev 0x%lx cur 0x%lx changed 0x%lx",
378 379 380 381 382 383
			     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;
	}

384
	for_each_set_bit(hlid, wlvif->ap.sta_hlid_map, wl->num_links)
385
		wl12xx_irq_ps_regulate_link(wl, wlvif, hlid,
386
					    wl->links[hlid].allocated_pkts);
387 388
}

389
static int wlcore_fw_status(struct wl1271 *wl, struct wl_fw_status *status)
L
Luciano Coelho 已提交
390
{
391
	struct wl12xx_vif *wlvif;
392
	u32 old_tx_blk_count = wl->tx_blocks_available;
E
Eliad Peller 已提交
393
	int avail, freed_blocks;
394
	int i;
395
	int ret;
396
	struct wl1271_link *lnk;
397

398 399 400
	ret = wlcore_raw_read_data(wl, REG_RAW_FW_STATUS_ADDR,
				   wl->raw_fw_status,
				   wl->fw_status_len, false);
401 402
	if (ret < 0)
		return ret;
403

404 405
	wlcore_hw_convert_fw_status(wl, wl->raw_fw_status, wl->fw_status);

L
Luciano Coelho 已提交
406 407
	wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
		     "drv_rx_counter = %d, tx_results_counter = %d)",
408 409 410 411
		     status->intr,
		     status->fw_rx_counter,
		     status->drv_rx_counter,
		     status->tx_results_counter);
L
Luciano Coelho 已提交
412

413 414
	for (i = 0; i < NUM_TX_QUEUES; i++) {
		/* prevent wrap-around in freed-packets counter */
415
		wl->tx_allocated_pkts[i] -=
416
				(status->counters.tx_released_pkts[i] -
417 418
				wl->tx_pkts_freed[i]) & 0xff;

419
		wl->tx_pkts_freed[i] = status->counters.tx_released_pkts[i];
420 421
	}

422

423
	for_each_set_bit(i, wl->links_map, wl->num_links) {
424
		u8 diff;
425
		lnk = &wl->links[i];
426

427
		/* prevent wrap-around in freed-packets counter */
428
		diff = (status->counters.tx_lnk_free_pkts[i] -
429 430 431 432
		       lnk->prev_freed_pkts) & 0xff;

		if (diff == 0)
			continue;
433

434
		lnk->allocated_pkts -= diff;
435
		lnk->prev_freed_pkts = status->counters.tx_lnk_free_pkts[i];
436 437 438

		/* accumulate the prev_freed_pkts counter */
		lnk->total_freed_pkts += diff;
439 440
	}

441
	/* prevent wrap-around in total blocks counter */
442 443
	if (likely(wl->tx_blocks_freed <= status->total_released_blks))
		freed_blocks = status->total_released_blks -
444 445 446
			       wl->tx_blocks_freed;
	else
		freed_blocks = 0x100000000LL - wl->tx_blocks_freed +
447
			       status->total_released_blks;
448

449
	wl->tx_blocks_freed = status->total_released_blks;
450

451 452
	wl->tx_allocated_blocks -= freed_blocks;

A
Arik Nemtsov 已提交
453 454 455 456 457 458 459 460 461 462 463 464
	/*
	 * 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);
	}

465
	avail = status->tx_total - wl->tx_allocated_blocks;
466

E
Eliad Peller 已提交
467 468 469 470 471 472 473 474 475 476
	/*
	 * 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 已提交
477

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

E
Eliad Peller 已提交
482
	/* for AP update num of allocated TX blocks per link and ps status */
483
	wl12xx_for_each_wlvif_ap(wl, wlvif) {
484
		wl12xx_irq_update_links_status(wl, wlvif, status);
485
	}
E
Eliad Peller 已提交
486

L
Luciano Coelho 已提交
487
	/* update the host-chipset time offset */
488
	wl->time_offset = (ktime_get_boot_ns() >> 10) -
489
		(s64)(status->fw_localtime);
490

491
	wl->fw_fast_lnk_map = status->link_fast_bitmap;
492

493
	return 0;
L
Luciano Coelho 已提交
494 495
}

496 497 498 499 500 501 502 503 504 505
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)))
506
		ieee80211_tx_status_ni(wl->hw, skb);
507 508 509 510 511 512 513 514 515 516 517
}

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

519 520
#define WL1271_IRQ_MAX_LOOPS 256

521
static int wlcore_irq_locked(struct wl1271 *wl)
L
Luciano Coelho 已提交
522
{
523
	int ret = 0;
524
	u32 intr;
525
	int loopcount = WL1271_IRQ_MAX_LOOPS;
526 527
	bool done = false;
	unsigned int defer_count;
I
Ido Yariv 已提交
528 529
	unsigned long flags;

530 531 532 533
	/*
	 * In case edge triggered interrupt must be used, we cannot iterate
	 * more than once without introducing race conditions with the hardirq.
	 */
534
	if (wl->irq_flags & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING))
535 536
		loopcount = 1;

L
Luciano Coelho 已提交
537 538
	wl1271_debug(DEBUG_IRQ, "IRQ work");

539
	if (unlikely(wl->state != WLCORE_STATE_ON))
L
Luciano Coelho 已提交
540 541
		goto out;

542
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
543 544 545
	if (ret < 0)
		goto out;

546 547 548 549 550 551 552
	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);
553
		smp_mb__after_atomic();
554

555
		ret = wlcore_fw_status(wl, wl->fw_status);
556
		if (ret < 0)
557
			goto out;
558 559 560

		wlcore_hw_tx_immediate_compl(wl);

561
		intr = wl->fw_status->intr;
562
		intr &= WLCORE_ALL_INTR_MASK;
563
		if (!intr) {
564
			done = true;
565 566
			continue;
		}
L
Luciano Coelho 已提交
567

568
		if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
569 570
			wl1271_error("HW watchdog interrupt received! starting recovery.");
			wl->watchdog_recovery = true;
571
			ret = -EIO;
572 573 574 575 576 577 578

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

		if (unlikely(intr & WL1271_ACX_SW_INTR_WATCHDOG)) {
			wl1271_error("SW watchdog interrupt received! "
579
				     "starting recovery.");
580
			wl->watchdog_recovery = true;
581
			ret = -EIO;
582 583 584 585 586

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

587
		if (likely(intr & WL1271_ACX_INTR_DATA)) {
588
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
589

590
			ret = wlcore_rx(wl, wl->fw_status);
591
			if (ret < 0)
592
				goto out;
L
Luciano Coelho 已提交
593

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

610
			/* check for tx results */
611
			ret = wlcore_hw_tx_delayed_compl(wl);
612
			if (ret < 0)
613
				goto out;
614 615 616 617 618 619

			/* 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);
620
		}
L
Luciano Coelho 已提交
621

622 623
		if (intr & WL1271_ACX_INTR_EVENT_A) {
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
624
			ret = wl1271_event_handle(wl, 0);
625
			if (ret < 0)
626
				goto out;
627
		}
L
Luciano Coelho 已提交
628

629 630
		if (intr & WL1271_ACX_INTR_EVENT_B) {
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
631
			ret = wl1271_event_handle(wl, 1);
632
			if (ret < 0)
633
				goto out;
634
		}
L
Luciano Coelho 已提交
635

636 637 638
		if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
			wl1271_debug(DEBUG_IRQ,
				     "WL1271_ACX_INTR_INIT_COMPLETE");
L
Luciano Coelho 已提交
639

640 641
		if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
642
	}
L
Luciano Coelho 已提交
643 644 645 646

	wl1271_ps_elp_sleep(wl);

out:
647 648 649 650 651 652 653 654 655
	return ret;
}

static irqreturn_t wlcore_irq(int irq, void *cookie)
{
	int ret;
	unsigned long flags;
	struct wl1271 *wl = cookie;

656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674
	/* 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);

675 676 677 678 679 680 681 682 683 684
	/* TX might be handled here, avoid redundant work */
	set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
	cancel_work_sync(&wl->tx_work);

	mutex_lock(&wl->mutex);

	ret = wlcore_irq_locked(wl);
	if (ret)
		wl12xx_queue_recovery_work(wl);

I
Ido Yariv 已提交
685 686 687 688
	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) &&
689
	    wl1271_tx_total_queue_count(wl) > 0)
I
Ido Yariv 已提交
690 691 692
		ieee80211_queue_work(wl->hw, &wl->tx_work);
	spin_unlock_irqrestore(&wl->wl_lock, flags);

L
Luciano Coelho 已提交
693
	mutex_unlock(&wl->mutex);
694 695

	return IRQ_HANDLED;
L
Luciano Coelho 已提交
696 697
}

698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722
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;

723
	ieee80211_iterate_active_interfaces(hw, IEEE80211_IFACE_ITER_RESUME_ALL,
724 725 726
					    wl12xx_vif_count_iter, data);
}

727
static int wl12xx_fetch_firmware(struct wl1271 *wl, bool plt)
L
Luciano Coelho 已提交
728 729
{
	const struct firmware *fw;
730
	const char *fw_name;
731
	enum wl12xx_fw_type fw_type;
L
Luciano Coelho 已提交
732 733
	int ret;

734 735
	if (plt) {
		fw_type = WL12XX_FW_TYPE_PLT;
736
		fw_name = wl->plt_fw_name;
737
	} else {
738 739 740 741
		/*
		 * we can't call wl12xx_get_vif_count() here because
		 * wl->mutex is taken, so use the cached last_vif_count value
		 */
E
Eliad Peller 已提交
742
		if (wl->last_vif_count > 1 && wl->mr_fw_name) {
743
			fw_type = WL12XX_FW_TYPE_MULTI;
744
			fw_name = wl->mr_fw_name;
745 746
		} else {
			fw_type = WL12XX_FW_TYPE_NORMAL;
747
			fw_name = wl->sr_fw_name;
748
		}
749 750 751 752
	}

	if (wl->fw_type == fw_type)
		return 0;
753 754 755

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

756
	ret = request_firmware(&fw, fw_name, wl->dev);
L
Luciano Coelho 已提交
757 758

	if (ret < 0) {
759
		wl1271_error("could not get firmware %s: %d", fw_name, ret);
L
Luciano Coelho 已提交
760 761 762 763 764 765 766 767 768 769
		return ret;
	}

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

770
	vfree(wl->fw);
771
	wl->fw_type = WL12XX_FW_TYPE_NONE;
L
Luciano Coelho 已提交
772
	wl->fw_len = fw->size;
773
	wl->fw = vmalloc(wl->fw_len);
L
Luciano Coelho 已提交
774 775 776 777 778 779 780 781 782

	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;
783
	wl->fw_type = fw_type;
L
Luciano Coelho 已提交
784 785 786 787 788 789
out:
	release_firmware(fw);

	return ret;
}

790 791
void wl12xx_queue_recovery_work(struct wl1271 *wl)
{
792
	/* Avoid a recursive recovery */
I
Ido Yariv 已提交
793
	if (wl->state == WLCORE_STATE_ON) {
794 795 796
		WARN_ON(!test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY,
				  &wl->flags));

797
		wl->state = WLCORE_STATE_RESTARTING;
I
Ido Yariv 已提交
798
		set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
799
		wl1271_ps_elp_wakeup(wl);
800
		wlcore_disable_interrupts_nosync(wl);
801
		ieee80211_queue_work(wl->hw, &wl->recovery_work);
802
	}
803 804
}

805 806
size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen)
{
807
	size_t len;
808 809

	/* Make sure we have enough room */
S
Silvan Jegen 已提交
810
	len = min_t(size_t, maxlen, PAGE_SIZE - wl->fwlog_size);
811 812 813 814 815 816 817 818 819 820

	/* 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)
{
S
Shahar Patury 已提交
821
	u32 end_of_log = 0;
822

S
Shahar Patury 已提交
823
	if (wl->quirks & WLCORE_QUIRK_FWLOG_NOT_IMPLEMENTED)
824 825 826 827 828 829
		return;

	wl1271_info("Reading FW panic log");

	/*
	 * Make sure the chip is awake and the logger isn't active.
830 831
	 * Do not send a stop fwlog command if the fw is hanged or if
	 * dbgpins are used (due to some fw bug).
832
	 */
833
	if (wl1271_ps_elp_wakeup(wl))
S
Shahar Patury 已提交
834
		return;
835 836
	if (!wl->watchdog_recovery &&
	    wl->conf.fwlog.output != WL12XX_FWLOG_OUTPUT_DBG_PINS)
837
		wl12xx_cmd_stop_fwlog(wl);
838 839 840

	/* Traverse the memory blocks linked list */
	do {
S
Shahar Patury 已提交
841 842 843 844
		end_of_log = wlcore_event_fw_logger(wl);
		if (end_of_log == 0) {
			msleep(100);
			end_of_log = wlcore_event_fw_logger(wl);
845
		}
S
Shahar Patury 已提交
846
	} while (end_of_log != 0);
847 848
}

849 850 851 852
static void wlcore_save_freed_pkts(struct wl1271 *wl, struct wl12xx_vif *wlvif,
				   u8 hlid, struct ieee80211_sta *sta)
{
	struct wl1271_station *wl_sta;
853
	u32 sqn_recovery_padding = WL1271_TX_SQN_POST_RECOVERY_PADDING;
854 855 856 857 858 859 860 861

	wl_sta = (void *)sta->drv_priv;
	wl_sta->total_freed_pkts = wl->links[hlid].total_freed_pkts;

	/*
	 * increment the initial seq number on recovery to account for
	 * transmitted packets that we haven't yet got in the FW status
	 */
862 863 864
	if (wlvif->encryption_type == KEY_GEM)
		sqn_recovery_padding = WL1271_TX_SQN_POST_RECOVERY_PADDING_GEM;

865
	if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
866
		wl_sta->total_freed_pkts += sqn_recovery_padding;
867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886
}

static void wlcore_save_freed_pkts_addr(struct wl1271 *wl,
					struct wl12xx_vif *wlvif,
					u8 hlid, const u8 *addr)
{
	struct ieee80211_sta *sta;
	struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);

	if (WARN_ON(hlid == WL12XX_INVALID_LINK_ID ||
		    is_zero_ether_addr(addr)))
		return;

	rcu_read_lock();
	sta = ieee80211_find_sta(vif, addr);
	if (sta)
		wlcore_save_freed_pkts(wl, wlvif, hlid, sta);
	rcu_read_unlock();
}

887 888 889 890 891 892 893 894 895 896
static void wlcore_print_recovery(struct wl1271 *wl)
{
	u32 pc = 0;
	u32 hint_sts = 0;
	int ret;

	wl1271_info("Hardware recovery in progress. FW ver: %s",
		    wl->chip.fw_ver_str);

	/* change partitions momentarily so we can read the FW pc */
897 898 899
	ret = wlcore_set_partition(wl, &wl->ptable[PART_BOOT]);
	if (ret < 0)
		return;
900 901 902 903 904 905 906 907 908

	ret = wlcore_read_reg(wl, REG_PC_ON_RECOVERY, &pc);
	if (ret < 0)
		return;

	ret = wlcore_read_reg(wl, REG_INTERRUPT_NO_CLEAR, &hint_sts);
	if (ret < 0)
		return;

909 910
	wl1271_info("pc: 0x%x, hint_sts: 0x%08x count: %d",
				pc, hint_sts, ++wl->recovery_count);
911 912 913 914 915

	wlcore_set_partition(wl, &wl->ptable[PART_WORK]);
}


916 917 918 919
static void wl1271_recovery_work(struct work_struct *work)
{
	struct wl1271 *wl =
		container_of(work, struct wl1271, recovery_work);
920
	struct wl12xx_vif *wlvif;
921
	struct ieee80211_vif *vif;
922 923 924

	mutex_lock(&wl->mutex);

925
	if (wl->state == WLCORE_STATE_OFF || wl->plt)
E
Eliad Peller 已提交
926
		goto out_unlock;
927

928
	if (!test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags)) {
929 930
		if (wl->conf.fwlog.output == WL12XX_FWLOG_OUTPUT_HOST)
			wl12xx_read_fwlog_panic(wl);
931 932
		wlcore_print_recovery(wl);
	}
933

934
	BUG_ON(wl->conf.recovery.bug_on_recovery &&
935
	       !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags));
936

937
	if (wl->conf.recovery.no_recovery) {
938 939 940 941
		wl1271_info("No recovery (chosen on module load). Fw will remain stuck.");
		goto out_unlock;
	}

942
	/* Prevent spurious TX during FW restart */
943
	wlcore_stop_queues(wl, WLCORE_QUEUE_STOP_REASON_FW_RESTART);
944

945
	/* reboot the chipset */
946 947 948 949
	while (!list_empty(&wl->wlvif_list)) {
		wlvif = list_first_entry(&wl->wlvif_list,
				       struct wl12xx_vif, list);
		vif = wl12xx_wlvif_to_vif(wlvif);
950 951 952 953 954 955 956

		if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
		    test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
			wlcore_save_freed_pkts_addr(wl, wlvif, wlvif->sta.hlid,
						    vif->bss_conf.bssid);
		}

957 958
		__wl1271_op_remove_interface(wl, vif, false);
	}
959 960

	wlcore_op_stop_locked(wl);
961

962 963
	ieee80211_restart_hw(wl->hw);

964 965 966 967
	/*
	 * Its safe to enable TX now - the queues are stopped after a request
	 * to restart the HW.
	 */
968
	wlcore_wake_queues(wl, WLCORE_QUEUE_STOP_REASON_FW_RESTART);
969

E
Eliad Peller 已提交
970
out_unlock:
971 972
	wl->watchdog_recovery = false;
	clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
973 974 975
	mutex_unlock(&wl->mutex);
}

976
static int wlcore_fw_wakeup(struct wl1271 *wl)
L
Luciano Coelho 已提交
977
{
978
	return wlcore_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG, ELPCTRL_WAKE_UP);
L
Luciano Coelho 已提交
979 980
}

981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998
static int wlcore_fw_sleep(struct wl1271 *wl)
{
	int ret;

	mutex_lock(&wl->mutex);
	ret = wlcore_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG, ELPCTRL_SLEEP);
	if (ret < 0) {
		wl12xx_queue_recovery_work(wl);
		goto out;
	}
	set_bit(WL1271_FLAG_IN_ELP, &wl->flags);
out:
	mutex_unlock(&wl->mutex);
	mdelay(WL1271_SUSPEND_SLEEP);

	return 0;
}

L
Luciano Coelho 已提交
999 1000
static int wl1271_setup(struct wl1271 *wl)
{
1001 1002 1003
	wl->raw_fw_status = kzalloc(wl->fw_status_len, GFP_KERNEL);
	if (!wl->raw_fw_status)
		goto err;
L
Luciano Coelho 已提交
1004

1005 1006 1007
	wl->fw_status = kzalloc(sizeof(*wl->fw_status), GFP_KERNEL);
	if (!wl->fw_status)
		goto err;
1008

1009
	wl->tx_res_if = kzalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
1010 1011
	if (!wl->tx_res_if)
		goto err;
L
Luciano Coelho 已提交
1012 1013

	return 0;
1014 1015 1016 1017
err:
	kfree(wl->fw_status);
	kfree(wl->raw_fw_status);
	return -ENOMEM;
L
Luciano Coelho 已提交
1018 1019
}

1020
static int wl12xx_set_power_on(struct wl1271 *wl)
L
Luciano Coelho 已提交
1021
{
1022
	int ret;
L
Luciano Coelho 已提交
1023

J
Juuso Oikarinen 已提交
1024
	msleep(WL1271_PRE_POWER_ON_SLEEP);
1025 1026 1027
	ret = wl1271_power_on(wl);
	if (ret < 0)
		goto out;
L
Luciano Coelho 已提交
1028
	msleep(WL1271_POWER_ON_SLEEP);
1029 1030
	wl1271_io_reset(wl);
	wl1271_io_init(wl);
L
Luciano Coelho 已提交
1031

1032 1033 1034
	ret = wlcore_set_partition(wl, &wl->ptable[PART_BOOT]);
	if (ret < 0)
		goto fail;
L
Luciano Coelho 已提交
1035 1036

	/* ELP module wake up */
1037 1038 1039
	ret = wlcore_fw_wakeup(wl);
	if (ret < 0)
		goto fail;
L
Luciano Coelho 已提交
1040

1041 1042
out:
	return ret;
1043 1044 1045 1046

fail:
	wl1271_power_off(wl);
	return ret;
1047
}
L
Luciano Coelho 已提交
1048

1049
static int wl12xx_chip_wakeup(struct wl1271 *wl, bool plt)
1050 1051 1052 1053 1054 1055
{
	int ret = 0;

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

1057 1058 1059 1060 1061 1062 1063
	/*
	 * 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.
1064 1065 1066
	 *
	 * Check if the bus supports blocksize alignment and, if it
	 * doesn't, make sure we don't have the quirk.
1067
	 */
1068 1069
	if (!wl1271_set_block_size(wl))
		wl->quirks &= ~WLCORE_QUIRK_TX_BLOCKSIZE_ALIGN;
L
Luciano Coelho 已提交
1070

1071
	/* TODO: make sure the lower driver has set things up correctly */
1072

1073 1074
	ret = wl1271_setup(wl);
	if (ret < 0)
1075
		goto out;
L
Luciano Coelho 已提交
1076

1077 1078 1079
	ret = wl12xx_fetch_firmware(wl, plt);
	if (ret < 0)
		goto out;
L
Luciano Coelho 已提交
1080 1081 1082 1083 1084

out:
	return ret;
}

1085
int wl1271_plt_start(struct wl1271 *wl, const enum plt_mode plt_mode)
L
Luciano Coelho 已提交
1086
{
1087
	int retries = WL1271_BOOT_RETRIES;
1088
	struct wiphy *wiphy = wl->hw->wiphy;
1089 1090 1091 1092

	static const char* const PLT_MODE[] = {
		"PLT_OFF",
		"PLT_ON",
1093 1094
		"PLT_FEM_DETECT",
		"PLT_CHIP_AWAKE"
1095 1096
	};

L
Luciano Coelho 已提交
1097 1098 1099 1100 1101 1102
	int ret;

	mutex_lock(&wl->mutex);

	wl1271_notice("power up");

1103
	if (wl->state != WLCORE_STATE_OFF) {
L
Luciano Coelho 已提交
1104 1105 1106 1107 1108 1109
		wl1271_error("cannot go into PLT state because not "
			     "in off state: %d", wl->state);
		ret = -EBUSY;
		goto out;
	}

1110 1111 1112 1113
	/* Indicate to lower levels that we are now in PLT mode */
	wl->plt = true;
	wl->plt_mode = plt_mode;

1114 1115
	while (retries) {
		retries--;
1116
		ret = wl12xx_chip_wakeup(wl, true);
1117 1118
		if (ret < 0)
			goto power_off;
L
Luciano Coelho 已提交
1119

1120 1121 1122 1123 1124
		if (plt_mode != PLT_CHIP_AWAKE) {
			ret = wl->ops->plt_init(wl);
			if (ret < 0)
				goto power_off;
		}
1125

1126
		wl->state = WLCORE_STATE_ON;
1127 1128
		wl1271_notice("firmware booted in PLT mode %s (%s)",
			      PLT_MODE[plt_mode],
L
Levi, Shahar 已提交
1129
			      wl->chip.fw_ver_str);
1130

1131 1132 1133 1134 1135
		/* 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));

1136
		goto out;
1137

1138 1139 1140
power_off:
		wl1271_power_off(wl);
	}
L
Luciano Coelho 已提交
1141

1142 1143 1144
	wl->plt = false;
	wl->plt_mode = PLT_OFF;

1145 1146
	wl1271_error("firmware boot in PLT mode failed despite %d retries",
		     WL1271_BOOT_RETRIES);
L
Luciano Coelho 已提交
1147 1148 1149 1150 1151 1152
out:
	mutex_unlock(&wl->mutex);

	return ret;
}

1153
int wl1271_plt_stop(struct wl1271 *wl)
L
Luciano Coelho 已提交
1154 1155 1156 1157 1158
{
	int ret = 0;

	wl1271_notice("power down");

1159 1160 1161 1162 1163
	/*
	 * Interrupts must be disabled before setting the state to OFF.
	 * Otherwise, the interrupt handler might be called and exit without
	 * reading the interrupt status.
	 */
1164
	wlcore_disable_interrupts(wl);
1165
	mutex_lock(&wl->mutex);
1166
	if (!wl->plt) {
1167
		mutex_unlock(&wl->mutex);
1168 1169 1170 1171 1172 1173

		/*
		 * 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().
		 */
1174
		wlcore_enable_interrupts(wl);
1175

L
Luciano Coelho 已提交
1176 1177 1178 1179 1180 1181 1182
		wl1271_error("cannot power down because not in PLT "
			     "state: %d", wl->state);
		ret = -EBUSY;
		goto out;
	}

	mutex_unlock(&wl->mutex);
1183

1184 1185
	wl1271_flush_deferred_work(wl);
	cancel_work_sync(&wl->netstack_work);
1186
	cancel_work_sync(&wl->recovery_work);
1187
	cancel_delayed_work_sync(&wl->elp_work);
A
Arik Nemtsov 已提交
1188
	cancel_delayed_work_sync(&wl->tx_watchdog_work);
1189 1190 1191

	mutex_lock(&wl->mutex);
	wl1271_power_off(wl);
1192
	wl->flags = 0;
1193
	wl->sleep_auth = WL1271_PSM_ILLEGAL;
1194
	wl->state = WLCORE_STATE_OFF;
1195
	wl->plt = false;
1196
	wl->plt_mode = PLT_OFF;
1197
	wl->rx_counter = 0;
1198 1199
	mutex_unlock(&wl->mutex);

1200 1201 1202 1203
out:
	return ret;
}

1204 1205 1206
static void wl1271_op_tx(struct ieee80211_hw *hw,
			 struct ieee80211_tx_control *control,
			 struct sk_buff *skb)
L
Luciano Coelho 已提交
1207 1208
{
	struct wl1271 *wl = hw->priv;
1209 1210
	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
	struct ieee80211_vif *vif = info->control.vif;
E
Eliad Peller 已提交
1211
	struct wl12xx_vif *wlvif = NULL;
1212
	unsigned long flags;
1213
	int q, mapping;
1214
	u8 hlid;
L
Luciano Coelho 已提交
1215

1216 1217 1218 1219 1220
	if (!vif) {
		wl1271_debug(DEBUG_TX, "DROP skb with no vif");
		ieee80211_free_txskb(hw, skb);
		return;
	}
E
Eliad Peller 已提交
1221

1222
	wlvif = wl12xx_vif_to_data(vif);
1223 1224
	mapping = skb_get_queue_mapping(skb);
	q = wl1271_tx_get_queue(mapping);
I
Ido Yariv 已提交
1225

1226
	hlid = wl12xx_tx_get_hlid(wl, wlvif, skb, control->sta);
I
Ido Yariv 已提交
1227

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

1230 1231 1232 1233 1234
	/*
	 * drop the packet if the link is invalid or the queue is stopped
	 * for any reason but watermark. Watermark is a "soft"-stop so we
	 * allow these packets through.
	 */
1235
	if (hlid == WL12XX_INVALID_LINK_ID ||
1236
	    (!test_bit(hlid, wlvif->links_map)) ||
1237 1238
	     (wlcore_is_queue_stopped_locked(wl, wlvif, q) &&
	      !wlcore_is_queue_stopped_by_reason_locked(wl, wlvif, q,
1239
			WLCORE_QUEUE_STOP_REASON_WATERMARK))) {
1240
		wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d", hlid, q);
E
Eliad Peller 已提交
1241
		ieee80211_free_txskb(hw, skb);
1242
		goto out;
1243
	}
L
Luciano Coelho 已提交
1244

E
Eliad Peller 已提交
1245 1246
	wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d len %d",
		     hlid, q, skb->len);
1247 1248
	skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);

1249
	wl->tx_queue_count[q]++;
1250
	wlvif->tx_queue_count[q]++;
1251 1252 1253 1254 1255

	/*
	 * The workqueue is slow to process the tx_queue and we need stop
	 * the queue here, otherwise the queue will get too long.
	 */
1256
	if (wlvif->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK &&
1257
	    !wlcore_is_queue_stopped_by_reason_locked(wl, wlvif, q,
1258
					WLCORE_QUEUE_STOP_REASON_WATERMARK)) {
1259
		wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
1260
		wlcore_stop_queue_locked(wl, wlvif, q,
1261
					 WLCORE_QUEUE_STOP_REASON_WATERMARK);
1262 1263
	}

L
Luciano Coelho 已提交
1264 1265 1266 1267 1268
	/*
	 * The chip specific setup must run before the first TX packet -
	 * before that, the tx_work will not be initialized!
	 */

I
Ido Yariv 已提交
1269 1270
	if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
	    !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
I
Ido Yariv 已提交
1271
		ieee80211_queue_work(wl->hw, &wl->tx_work);
I
Ido Yariv 已提交
1272

1273
out:
I
Ido Yariv 已提交
1274
	spin_unlock_irqrestore(&wl->wl_lock, flags);
L
Luciano Coelho 已提交
1275 1276
}

1277 1278
int wl1271_tx_dummy_packet(struct wl1271 *wl)
{
1279
	unsigned long flags;
1280 1281 1282 1283 1284 1285 1286
	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));
1287 1288 1289

	spin_lock_irqsave(&wl->wl_lock, flags);
	set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1290
	wl->tx_queue_count[q]++;
1291 1292 1293 1294
	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))
1295
		return wlcore_tx_work_locked(wl);
1296 1297 1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310

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

1311
static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1312 1313
{
	struct sk_buff *skb;
1314
	struct ieee80211_hdr_3addr *hdr;
1315 1316 1317 1318
	unsigned int dummy_packet_size;

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

1320
	skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1321
	if (!skb) {
1322 1323
		wl1271_warning("Failed to allocate a dummy packet skb");
		return NULL;
1324 1325 1326 1327
	}

	skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));

1328
	hdr = skb_put_zero(skb, sizeof(*hdr));
1329
	hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1330 1331
					 IEEE80211_STYPE_NULLFUNC |
					 IEEE80211_FCTL_TODS);
1332

1333
	skb_put_zero(skb, dummy_packet_size);
1334

1335 1336
	/* Dummy packets require the TID to be management */
	skb->priority = WL1271_TID_MGMT;
1337

1338
	/* Initialize all fields that might be used */
1339
	skb_set_queue_mapping(skb, 0);
1340
	memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1341

1342
	return skb;
1343 1344
}

1345

1346
#ifdef CONFIG_PM
1347
static int
1348
wl1271_validate_wowlan_pattern(struct cfg80211_pkt_pattern *p)
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 1405 1406 1407 1408
{
	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;
}

1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428
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,
1429
				 const u8 *pattern, u8 len)
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
{
	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;
	}
}

1487 1488 1489 1490
/*
 * Allocates an RX filter returned through f
 * which needs to be freed using rx_filter_free()
 */
1491 1492 1493
static int
wl1271_convert_wowlan_pattern_to_rx_filter(struct cfg80211_pkt_pattern *p,
					   struct wl12xx_rx_filter **f)
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 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560
{
	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) {
1561 1562 1563 1564 1565 1566 1567 1568 1569
		ret = wl1271_acx_default_rx_filter_enable(wl, 0,
							  FILTER_SIGNAL);
		if (ret)
			goto out;

		ret = wl1271_rx_filter_clear_all(wl);
		if (ret)
			goto out;

1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584
		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;
		}
	}

1585 1586 1587 1588 1589 1590 1591
	ret = wl1271_acx_default_rx_filter_enable(wl, 0, FILTER_SIGNAL);
	if (ret)
		goto out;

	ret = wl1271_rx_filter_clear_all(wl);
	if (ret)
		goto out;
1592 1593 1594

	/* Translate WoWLAN patterns into filters */
	for (i = 0; i < wow->n_patterns; i++) {
1595
		struct cfg80211_pkt_pattern *p;
1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619
		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;
}

1620
static int wl1271_configure_suspend_sta(struct wl1271 *wl,
1621 1622
					struct wl12xx_vif *wlvif,
					struct cfg80211_wowlan *wow)
1623 1624 1625 1626
{
	int ret = 0;

	if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
1627
		goto out;
1628

1629 1630
	ret = wl1271_configure_wowlan(wl, wow);
	if (ret < 0)
1631
		goto out;
1632

1633 1634 1635 1636
	if ((wl->conf.conn.suspend_wake_up_event ==
	     wl->conf.conn.wake_up_event) &&
	    (wl->conf.conn.suspend_listen_interval ==
	     wl->conf.conn.listen_interval))
1637
		goto out;
1638

1639 1640 1641 1642 1643 1644
	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);
1645
out:
1646 1647 1648
	return ret;

}
1649

E
Eliad Peller 已提交
1650
static int wl1271_configure_suspend_ap(struct wl1271 *wl,
E
Eliad Peller 已提交
1651 1652
					struct wl12xx_vif *wlvif,
					struct cfg80211_wowlan *wow)
1653
{
1654
	int ret = 0;
1655

1656
	if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
1657
		goto out;
1658

E
Eliad Peller 已提交
1659
	ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true);
E
Eliad Peller 已提交
1660 1661 1662 1663 1664 1665
	if (ret < 0)
		goto out;

	ret = wl1271_configure_wowlan(wl, wow);
	if (ret < 0)
		goto out;
1666

1667
out:
1668 1669 1670 1671
	return ret;

}

E
Eliad Peller 已提交
1672
static int wl1271_configure_suspend(struct wl1271 *wl,
1673 1674
				    struct wl12xx_vif *wlvif,
				    struct cfg80211_wowlan *wow)
1675
{
1676
	if (wlvif->bss_type == BSS_TYPE_STA_BSS)
1677
		return wl1271_configure_suspend_sta(wl, wlvif, wow);
E
Eliad Peller 已提交
1678
	if (wlvif->bss_type == BSS_TYPE_AP_BSS)
E
Eliad Peller 已提交
1679
		return wl1271_configure_suspend_ap(wl, wlvif, wow);
1680 1681 1682
	return 0;
}

1683
static void wl1271_configure_resume(struct wl1271 *wl, struct wl12xx_vif *wlvif)
1684
{
1685
	int ret = 0;
E
Eliad Peller 已提交
1686
	bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
1687
	bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
1688

1689
	if ((!is_ap) && (!is_sta))
1690 1691
		return;

E
Eliad Peller 已提交
1692 1693
	if ((is_sta && !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) ||
	    (is_ap && !test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)))
1694 1695
		return;

E
Eliad Peller 已提交
1696
	wl1271_configure_wowlan(wl, NULL);
1697

E
Eliad Peller 已提交
1698
	if (is_sta) {
1699 1700 1701 1702
		if ((wl->conf.conn.suspend_wake_up_event ==
		     wl->conf.conn.wake_up_event) &&
		    (wl->conf.conn.suspend_listen_interval ==
		     wl->conf.conn.listen_interval))
1703
			return;
1704

1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715
		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);
	}
1716 1717
}

1718 1719 1720 1721
static int wl1271_op_suspend(struct ieee80211_hw *hw,
			    struct cfg80211_wowlan *wow)
{
	struct wl1271 *wl = hw->priv;
1722
	struct wl12xx_vif *wlvif;
1723 1724
	int ret;

1725
	wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1726
	WARN_ON(!wow);
1727

1728 1729 1730 1731 1732 1733
	/* we want to perform the recovery before suspending */
	if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
		wl1271_warning("postponing suspend to perform recovery");
		return -EBUSY;
	}

1734 1735
	wl1271_tx_flush(wl);

1736
	mutex_lock(&wl->mutex);
1737 1738

	ret = wl1271_ps_elp_wakeup(wl);
1739 1740
	if (ret < 0) {
		mutex_unlock(&wl->mutex);
1741
		return ret;
1742
	}
1743

1744
	wl->wow_enabled = true;
1745
	wl12xx_for_each_wlvif(wl, wlvif) {
E
Eliad Peller 已提交
1746 1747 1748
		if (wlcore_is_p2p_mgmt(wlvif))
			continue;

1749
		ret = wl1271_configure_suspend(wl, wlvif, wow);
1750
		if (ret < 0) {
1751
			mutex_unlock(&wl->mutex);
1752 1753 1754
			wl1271_warning("couldn't prepare device to suspend");
			return ret;
		}
1755
	}
1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768

	/* disable fast link flow control notifications from FW */
	ret = wlcore_hw_interrupt_notify(wl, false);
	if (ret < 0)
		goto out_sleep;

	/* if filtering is enabled, configure the FW to drop all RX BA frames */
	ret = wlcore_hw_rx_ba_filter(wl,
				     !!wl->conf.conn.suspend_rx_ba_activity);
	if (ret < 0)
		goto out_sleep;

out_sleep:
1769
	mutex_unlock(&wl->mutex);
1770 1771 1772 1773 1774 1775

	if (ret < 0) {
		wl1271_warning("couldn't prepare device to suspend");
		return ret;
	}

1776 1777
	/* flush any remaining work */
	wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1778

1779 1780 1781 1782
	/*
	 * disable and re-enable interrupts in order to flush
	 * the threaded_irq
	 */
1783
	wlcore_disable_interrupts(wl);
1784 1785 1786 1787 1788 1789 1790

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

1791
	wlcore_enable_interrupts(wl);
1792 1793
	flush_work(&wl->tx_work);
	flush_delayed_work(&wl->elp_work);
1794

1795 1796 1797 1798 1799 1800
	/*
	 * Cancel the watchdog even if above tx_flush failed. We will detect
	 * it on resume anyway.
	 */
	cancel_delayed_work(&wl->tx_watchdog_work);

1801 1802 1803 1804 1805 1806 1807 1808 1809
	/*
	 * Use an immediate call for allowing the firmware to go into power
	 * save during suspend.
	 * Using a workque for this last write was only hapenning on resume
	 * leaving the firmware with power save disabled during suspend,
	 * while consuming full power during wowlan suspend.
	 */
	wlcore_fw_sleep(wl);

1810 1811 1812 1813 1814 1815
	return 0;
}

static int wl1271_op_resume(struct ieee80211_hw *hw)
{
	struct wl1271 *wl = hw->priv;
1816
	struct wl12xx_vif *wlvif;
1817
	unsigned long flags;
1818
	bool run_irq_work = false, pending_recovery;
1819
	int ret;
1820

1821 1822
	wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
		     wl->wow_enabled);
1823
	WARN_ON(!wl->wow_enabled);
1824 1825 1826 1827 1828

	/*
	 * re-enable irq_work enqueuing, and call irq_work directly if
	 * there is a pending work.
	 */
1829 1830 1831 1832 1833
	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);
1834

1835 1836
	mutex_lock(&wl->mutex);

1837 1838 1839 1840
	/* test the recovery flag before calling any SDIO functions */
	pending_recovery = test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS,
				    &wl->flags);

1841 1842 1843
	if (run_irq_work) {
		wl1271_debug(DEBUG_MAC80211,
			     "run postponed irq_work directly");
1844 1845

		/* don't talk to the HW if recovery is pending */
1846 1847 1848 1849 1850
		if (!pending_recovery) {
			ret = wlcore_irq_locked(wl);
			if (ret)
				wl12xx_queue_recovery_work(wl);
		}
1851

1852
		wlcore_enable_interrupts(wl);
1853
	}
1854

1855 1856 1857
	if (pending_recovery) {
		wl1271_warning("queuing forgotten recovery on resume");
		ieee80211_queue_work(wl->hw, &wl->recovery_work);
1858
		goto out_sleep;
1859 1860
	}

1861 1862 1863 1864
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

1865
	wl12xx_for_each_wlvif(wl, wlvif) {
E
Eliad Peller 已提交
1866 1867 1868
		if (wlcore_is_p2p_mgmt(wlvif))
			continue;

1869 1870
		wl1271_configure_resume(wl, wlvif);
	}
1871

1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883
	ret = wlcore_hw_interrupt_notify(wl, true);
	if (ret < 0)
		goto out_sleep;

	/* if filtering is enabled, configure the FW to drop all RX BA frames */
	ret = wlcore_hw_rx_ba_filter(wl, false);
	if (ret < 0)
		goto out_sleep;

out_sleep:
	wl1271_ps_elp_sleep(wl);

1884
out:
1885
	wl->wow_enabled = false;
1886 1887 1888 1889 1890 1891 1892

	/*
	 * Set a flag to re-init the watchdog on the first Tx after resume.
	 * That way we avoid possible conditions where Tx-complete interrupts
	 * fail to arrive and we perform a spurious recovery.
	 */
	set_bit(WL1271_FLAG_REINIT_TX_WDOG, &wl->flags);
1893
	mutex_unlock(&wl->mutex);
1894

1895 1896
	return 0;
}
1897
#endif
1898

L
Luciano Coelho 已提交
1899
static int wl1271_op_start(struct ieee80211_hw *hw)
1900 1901 1902 1903 1904 1905 1906 1907 1908 1909 1910 1911 1912 1913
{
	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.
	 */

1914
	return 0;
1915 1916
}

1917
static void wlcore_op_stop_locked(struct wl1271 *wl)
1918
{
1919 1920
	int i;

1921
	if (wl->state == WLCORE_STATE_OFF) {
1922 1923 1924 1925
		if (test_and_clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS,
					&wl->flags))
			wlcore_enable_interrupts(wl);

1926 1927
		return;
	}
1928

1929 1930 1931 1932
	/*
	 * this must be before the cancel_work calls below, so that the work
	 * functions don't perform further work.
	 */
1933
	wl->state = WLCORE_STATE_OFF;
1934 1935 1936 1937 1938 1939 1940

	/*
	 * Use the nosync variant to disable interrupts, so the mutex could be
	 * held while doing so without deadlocking.
	 */
	wlcore_disable_interrupts_nosync(wl);

1941 1942
	mutex_unlock(&wl->mutex);

1943
	wlcore_synchronize_interrupts(wl);
1944 1945
	if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
		cancel_work_sync(&wl->recovery_work);
1946 1947 1948 1949 1950
	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 已提交
1951
	cancel_delayed_work_sync(&wl->tx_watchdog_work);
1952 1953 1954

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

	wl1271_power_off(wl);
1958 1959 1960 1961 1962 1963 1964
	/*
	 * In case a recovery was scheduled, interrupts were disabled to avoid
	 * an interrupt storm. Now that the power is down, it is safe to
	 * re-enable interrupts to balance the disable depth
	 */
	if (test_and_clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
		wlcore_enable_interrupts(wl);
1965

1966
	wl->band = NL80211_BAND_2GHZ;
1967 1968 1969

	wl->rx_counter = 0;
	wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1970
	wl->channel_type = NL80211_CHAN_NO_HT;
1971 1972 1973 1974 1975 1976 1977
	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;
1978
	wl->sleep_auth = WL1271_PSM_ILLEGAL;
1979 1980 1981
	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));
E
Eliad Peller 已提交
1982
	memset(wl->session_ids, 0, sizeof(wl->session_ids));
1983
	memset(wl->rx_filter_enabled, 0, sizeof(wl->rx_filter_enabled));
1984
	wl->active_sta_count = 0;
1985
	wl->active_link_count = 0;
1986 1987

	/* The system link is always allocated */
1988 1989
	wl->links[WL12XX_SYSTEM_HLID].allocated_pkts = 0;
	wl->links[WL12XX_SYSTEM_HLID].prev_freed_pkts = 0;
1990 1991 1992 1993 1994 1995 1996 1997 1998 1999 2000 2001 2002 2003 2004 2005 2006 2007
	__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);

2008 2009 2010 2011
	kfree(wl->raw_fw_status);
	wl->raw_fw_status = NULL;
	kfree(wl->fw_status);
	wl->fw_status = NULL;
2012 2013 2014 2015
	kfree(wl->tx_res_if);
	wl->tx_res_if = NULL;
	kfree(wl->target_mem_map);
	wl->target_mem_map = NULL;
2016 2017 2018

	/*
	 * FW channels must be re-calibrated after recovery,
2019
	 * save current Reg-Domain channel configuration and clear it.
2020
	 */
2021 2022
	memcpy(wl->reg_ch_conf_pending, wl->reg_ch_conf_last,
	       sizeof(wl->reg_ch_conf_pending));
2023
	memset(wl->reg_ch_conf_last, 0, sizeof(wl->reg_ch_conf_last));
2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034
}

static void wlcore_op_stop(struct ieee80211_hw *hw)
{
	struct wl1271 *wl = hw->priv;

	wl1271_debug(DEBUG_MAC80211, "mac80211 stop");

	mutex_lock(&wl->mutex);

	wlcore_op_stop_locked(wl);
2035 2036

	mutex_unlock(&wl->mutex);
2037 2038
}

2039 2040 2041 2042 2043 2044 2045 2046
static void wlcore_channel_switch_work(struct work_struct *work)
{
	struct delayed_work *dwork;
	struct wl1271 *wl;
	struct ieee80211_vif *vif;
	struct wl12xx_vif *wlvif;
	int ret;

G
Geliang Tang 已提交
2047
	dwork = to_delayed_work(work);
2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082
	wlvif = container_of(dwork, struct wl12xx_vif, channel_switch_work);
	wl = wlvif->wl;

	wl1271_info("channel switch failed (role_id: %d).", wlvif->role_id);

	mutex_lock(&wl->mutex);

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

	/* check the channel switch is still ongoing */
	if (!test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags))
		goto out;

	vif = wl12xx_wlvif_to_vif(wlvif);
	ieee80211_chswitch_done(vif, false);

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

	wl12xx_cmd_stop_channel_switch(wl, wlvif);

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

static void wlcore_connection_loss_work(struct work_struct *work)
{
	struct delayed_work *dwork;
	struct wl1271 *wl;
	struct ieee80211_vif *vif;
	struct wl12xx_vif *wlvif;

G
Geliang Tang 已提交
2083
	dwork = to_delayed_work(work);
2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103
	wlvif = container_of(dwork, struct wl12xx_vif, connection_loss_work);
	wl = wlvif->wl;

	wl1271_info("Connection loss work (role_id: %d).", wlvif->role_id);

	mutex_lock(&wl->mutex);

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

	/* Call mac80211 connection loss */
	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);
}

2104 2105 2106 2107 2108 2109 2110 2111
static void wlcore_pending_auth_complete_work(struct work_struct *work)
{
	struct delayed_work *dwork;
	struct wl1271 *wl;
	struct wl12xx_vif *wlvif;
	unsigned long time_spare;
	int ret;

G
Geliang Tang 已提交
2112
	dwork = to_delayed_work(work);
2113 2114 2115 2116 2117 2118 2119 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
	wlvif = container_of(dwork, struct wl12xx_vif,
			     pending_auth_complete_work);
	wl = wlvif->wl;

	mutex_lock(&wl->mutex);

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

	/*
	 * Make sure a second really passed since the last auth reply. Maybe
	 * a second auth reply arrived while we were stuck on the mutex.
	 * Check for a little less than the timeout to protect from scheduler
	 * irregularities.
	 */
	time_spare = jiffies +
			msecs_to_jiffies(WLCORE_PEND_AUTH_ROC_TIMEOUT - 50);
	if (!time_after(time_spare, wlvif->pending_auth_reply_time))
		goto out;

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

	/* cancel the ROC if active */
	wlcore_update_inconn_sta(wl, wlvif, NULL, false);

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

E
Eliad Peller 已提交
2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165
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;
}

2166 2167 2168 2169 2170 2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186
static int wlcore_allocate_klv_template(struct wl1271 *wl, u8 *idx)
{
	u8 policy = find_first_zero_bit(wl->klv_templates_map,
					WLCORE_MAX_KLV_TEMPLATES);
	if (policy >= WLCORE_MAX_KLV_TEMPLATES)
		return -EBUSY;

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

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

	__clear_bit(*idx, wl->klv_templates_map);
	*idx = WLCORE_MAX_KLV_TEMPLATES;
}

E
Eliad Peller 已提交
2187
static u8 wl12xx_get_role_type(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2188
{
2189 2190
	struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);

E
Eliad Peller 已提交
2191
	switch (wlvif->bss_type) {
2192
	case BSS_TYPE_AP_BSS:
E
Eliad Peller 已提交
2193
		if (wlvif->p2p)
E
Eliad Peller 已提交
2194
			return WL1271_ROLE_P2P_GO;
2195 2196
		else if (ieee80211_vif_is_mesh(vif))
			return WL1271_ROLE_MESH_POINT;
E
Eliad Peller 已提交
2197 2198
		else
			return WL1271_ROLE_AP;
2199 2200

	case BSS_TYPE_STA_BSS:
E
Eliad Peller 已提交
2201
		if (wlvif->p2p)
E
Eliad Peller 已提交
2202 2203 2204
			return WL1271_ROLE_P2P_CL;
		else
			return WL1271_ROLE_STA;
2205

E
Eliad Peller 已提交
2206 2207 2208
	case BSS_TYPE_IBSS:
		return WL1271_ROLE_IBSS;

2209
	default:
E
Eliad Peller 已提交
2210
		wl1271_error("invalid bss_type: %d", wlvif->bss_type);
2211 2212 2213 2214
	}
	return WL12XX_INVALID_ROLE_TYPE;
}

2215
static int wl12xx_init_vif_data(struct wl1271 *wl, struct ieee80211_vif *vif)
E
Eliad Peller 已提交
2216
{
2217
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
E
Eliad Peller 已提交
2218
	int i;
2219

2220 2221
	/* clear everything but the persistent data */
	memset(wlvif, 0, offsetof(struct wl12xx_vif, persistent));
2222 2223 2224 2225 2226 2227

	switch (ieee80211_vif_type_p2p(vif)) {
	case NL80211_IFTYPE_P2P_CLIENT:
		wlvif->p2p = 1;
		/* fall-through */
	case NL80211_IFTYPE_STATION:
E
Eliad Peller 已提交
2228
	case NL80211_IFTYPE_P2P_DEVICE:
2229 2230 2231 2232 2233 2234 2235 2236 2237
		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:
2238
	case NL80211_IFTYPE_MESH_POINT:
2239 2240 2241 2242 2243 2244 2245
		wlvif->bss_type = BSS_TYPE_AP_BSS;
		break;
	default:
		wlvif->bss_type = MAX_BSS_TYPE;
		return -EOPNOTSUPP;
	}

E
Eliad Peller 已提交
2246
	wlvif->role_id = WL12XX_INVALID_ROLE_ID;
E
Eliad Peller 已提交
2247
	wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
E
Eliad Peller 已提交
2248
	wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
2249

2250 2251 2252 2253
	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 已提交
2254 2255 2256
		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);
2257
		wlcore_allocate_klv_template(wl, &wlvif->sta.klv_template_id);
2258 2259 2260
		wlvif->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
		wlvif->basic_rate = CONF_TX_RATE_MASK_BASIC;
		wlvif->rate_set = CONF_TX_RATE_MASK_BASIC;
2261 2262 2263 2264
	} else {
		/* init ap data */
		wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
		wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
E
Eliad Peller 已提交
2265 2266 2267 2268 2269
		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]);
2270
		wlvif->basic_rate_set = CONF_TX_ENABLED_RATES;
2271 2272 2273 2274 2275
		/*
		 * TODO: check if basic_rate shouldn't be
		 * wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
		 * instead (the same thing for STA above).
		*/
2276
		wlvif->basic_rate = CONF_TX_ENABLED_RATES;
2277
		/* TODO: this seems to be used only for STA, check it */
2278
		wlvif->rate_set = CONF_TX_ENABLED_RATES;
2279
	}
2280

2281 2282
	wlvif->bitrate_masks[NL80211_BAND_2GHZ] = wl->conf.tx.basic_rate;
	wlvif->bitrate_masks[NL80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5;
E
Eliad Peller 已提交
2283 2284
	wlvif->beacon_int = WL1271_DEFAULT_BEACON_INT;

E
Eliad Peller 已提交
2285 2286 2287 2288 2289
	/*
	 * 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 已提交
2290
	wlvif->channel = wl->channel;
2291
	wlvif->power_level = wl->power_level;
2292
	wlvif->channel_type = wl->channel_type;
E
Eliad Peller 已提交
2293

E
Eliad Peller 已提交
2294 2295 2296 2297
	INIT_WORK(&wlvif->rx_streaming_enable_work,
		  wl1271_rx_streaming_enable_work);
	INIT_WORK(&wlvif->rx_streaming_disable_work,
		  wl1271_rx_streaming_disable_work);
2298
	INIT_WORK(&wlvif->rc_update_work, wlcore_rc_update_work);
2299 2300 2301 2302
	INIT_DELAYED_WORK(&wlvif->channel_switch_work,
			  wlcore_channel_switch_work);
	INIT_DELAYED_WORK(&wlvif->connection_loss_work,
			  wlcore_connection_loss_work);
2303 2304
	INIT_DELAYED_WORK(&wlvif->pending_auth_complete_work,
			  wlcore_pending_auth_complete_work);
E
Eliad Peller 已提交
2305
	INIT_LIST_HEAD(&wlvif->list);
E
Eliad Peller 已提交
2306

2307
	timer_setup(&wlvif->rx_streaming_timer, wl1271_rx_streaming_timer, 0);
2308
	return 0;
E
Eliad Peller 已提交
2309 2310
}

2311
static int wl12xx_init_fw(struct wl1271 *wl)
L
Luciano Coelho 已提交
2312
{
2313
	int retries = WL1271_BOOT_RETRIES;
2314
	bool booted = false;
2315 2316
	struct wiphy *wiphy = wl->hw->wiphy;
	int ret;
L
Luciano Coelho 已提交
2317

2318 2319
	while (retries) {
		retries--;
2320
		ret = wl12xx_chip_wakeup(wl, false);
2321 2322
		if (ret < 0)
			goto power_off;
L
Luciano Coelho 已提交
2323

2324
		ret = wl->ops->boot(wl);
2325 2326
		if (ret < 0)
			goto power_off;
L
Luciano Coelho 已提交
2327

2328 2329 2330 2331
		ret = wl1271_hw_init(wl);
		if (ret < 0)
			goto irq_disable;

2332 2333
		booted = true;
		break;
2334

2335 2336 2337 2338 2339
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
2340
		   the system (and while we are WLCORE_STATE_OFF the IRQ
2341 2342 2343
		   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. */
2344
		wlcore_disable_interrupts(wl);
2345 2346
		wl1271_flush_deferred_work(wl);
		cancel_work_sync(&wl->netstack_work);
2347 2348 2349 2350
		mutex_lock(&wl->mutex);
power_off:
		wl1271_power_off(wl);
	}
2351

2352 2353 2354 2355 2356 2357
	if (!booted) {
		wl1271_error("firmware boot failed despite %d retries",
			     WL1271_BOOT_RETRIES);
		goto out;
	}

L
Levi, Shahar 已提交
2358
	wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
2359 2360 2361

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

2365 2366 2367 2368 2369
	/*
	 * Now we know if 11a is supported (info from the NVS), so disable
	 * 11a channels if not supported
	 */
	if (!wl->enable_11a)
2370
		wiphy->bands[NL80211_BAND_5GHZ]->n_channels = 0;
2371 2372 2373 2374

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

2375
	wl->state = WLCORE_STATE_ON;
2376
out:
2377
	return ret;
2378 2379
}

2380 2381 2382 2383 2384
static bool wl12xx_dev_role_started(struct wl12xx_vif *wlvif)
{
	return wlvif->dev_hlid != WL12XX_INVALID_LINK_ID;
}

2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408
/*
 * 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 */
2409
	if (wl->state == WLCORE_STATE_OFF)
2410 2411
		return false;

E
Eliad Peller 已提交
2412 2413 2414 2415
	/* no need for fw change if a single fw is used */
	if (!wl->mr_fw_name)
		return false;

2416 2417 2418 2419 2420 2421 2422 2423
	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;
}

2424 2425 2426 2427 2428 2429 2430 2431 2432 2433 2434 2435 2436
/*
 * 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);
	}
}

2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449
struct wlcore_hw_queue_iter_data {
	unsigned long hw_queue_map[BITS_TO_LONGS(WLCORE_NUM_MAC_ADDRESSES)];
	/* current vif */
	struct ieee80211_vif *vif;
	/* is the current vif among those iterated */
	bool cur_running;
};

static void wlcore_hw_queue_iter(void *data, u8 *mac,
				 struct ieee80211_vif *vif)
{
	struct wlcore_hw_queue_iter_data *iter_data = data;

E
Eliad Peller 已提交
2450 2451
	if (vif->type == NL80211_IFTYPE_P2P_DEVICE ||
	    WARN_ON_ONCE(vif->hw_queue[0] == IEEE80211_INVAL_HW_QUEUE))
2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463 2464 2465 2466 2467 2468
		return;

	if (iter_data->cur_running || vif == iter_data->vif) {
		iter_data->cur_running = true;
		return;
	}

	__set_bit(vif->hw_queue[0] / NUM_TX_QUEUES, iter_data->hw_queue_map);
}

static int wlcore_allocate_hw_queue_base(struct wl1271 *wl,
					 struct wl12xx_vif *wlvif)
{
	struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
	struct wlcore_hw_queue_iter_data iter_data = {};
	int i, q_base;

E
Eliad Peller 已提交
2469 2470 2471 2472 2473
	if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
		vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;
		return 0;
	}

2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516 2517
	iter_data.vif = vif;

	/* mark all bits taken by active interfaces */
	ieee80211_iterate_active_interfaces_atomic(wl->hw,
					IEEE80211_IFACE_ITER_RESUME_ALL,
					wlcore_hw_queue_iter, &iter_data);

	/* the current vif is already running in mac80211 (resume/recovery) */
	if (iter_data.cur_running) {
		wlvif->hw_queue_base = vif->hw_queue[0];
		wl1271_debug(DEBUG_MAC80211,
			     "using pre-allocated hw queue base %d",
			     wlvif->hw_queue_base);

		/* interface type might have changed type */
		goto adjust_cab_queue;
	}

	q_base = find_first_zero_bit(iter_data.hw_queue_map,
				     WLCORE_NUM_MAC_ADDRESSES);
	if (q_base >= WLCORE_NUM_MAC_ADDRESSES)
		return -EBUSY;

	wlvif->hw_queue_base = q_base * NUM_TX_QUEUES;
	wl1271_debug(DEBUG_MAC80211, "allocating hw queue base: %d",
		     wlvif->hw_queue_base);

	for (i = 0; i < NUM_TX_QUEUES; i++) {
		wl->queue_stop_reasons[wlvif->hw_queue_base + i] = 0;
		/* register hw queues in mac80211 */
		vif->hw_queue[i] = wlvif->hw_queue_base + i;
	}

adjust_cab_queue:
	/* the last places are reserved for cab queues per interface */
	if (wlvif->bss_type == BSS_TYPE_AP_BSS)
		vif->cab_queue = NUM_TX_QUEUES * WLCORE_NUM_MAC_ADDRESSES +
				 wlvif->hw_queue_base / NUM_TX_QUEUES;
	else
		vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;

	return 0;
}

2518 2519 2520 2521 2522
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);
2523
	struct vif_counter_data vif_count;
2524 2525 2526
	int ret = 0;
	u8 role_type;

2527 2528 2529 2530 2531
	if (wl->plt) {
		wl1271_error("Adding Interface not allowed while in PLT mode");
		return -EBUSY;
	}

2532
	vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER |
2533
			     IEEE80211_VIF_SUPPORTS_UAPSD |
2534
			     IEEE80211_VIF_SUPPORTS_CQM_RSSI;
2535

2536 2537 2538
	wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
		     ieee80211_vif_type_p2p(vif), vif->addr);

2539 2540
	wl12xx_get_vif_count(hw, vif, &vif_count);

2541
	mutex_lock(&wl->mutex);
2542 2543 2544 2545
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out_unlock;

2546 2547 2548 2549 2550
	/*
	 * 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.
	 */
2551 2552
	if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) ||
	    test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) {
2553 2554 2555 2556
		ret = -EBUSY;
		goto out;
	}

2557

2558
	ret = wl12xx_init_vif_data(wl, vif);
2559 2560 2561 2562 2563 2564 2565 2566 2567 2568
	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;
	}

2569 2570 2571 2572
	ret = wlcore_allocate_hw_queue_base(wl, wlvif);
	if (ret < 0)
		goto out;

2573
	if (wl12xx_need_fw_change(wl, vif_count, true)) {
2574
		wl12xx_force_active_psm(wl);
2575
		set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
2576 2577 2578 2579 2580
		mutex_unlock(&wl->mutex);
		wl1271_recovery_work(&wl->recovery_work);
		return 0;
	}

2581 2582 2583 2584
	/*
	 * TODO: after the nvs issue will be solved, move this block
	 * to start(), and make sure here the driver is ON.
	 */
2585
	if (wl->state == WLCORE_STATE_OFF) {
2586 2587 2588 2589
		/*
		 * we still need this in order to configure the fw
		 * while uploading the nvs
		 */
2590
		memcpy(wl->addresses[0].addr, vif->addr, ETH_ALEN);
2591

2592 2593
		ret = wl12xx_init_fw(wl);
		if (ret < 0)
2594 2595 2596
			goto out;
	}

E
Eliad Peller 已提交
2597 2598 2599 2600 2601
	if (!wlcore_is_p2p_mgmt(wlvif)) {
		ret = wl12xx_cmd_role_enable(wl, vif->addr,
					     role_type, &wlvif->role_id);
		if (ret < 0)
			goto out;
2602

E
Eliad Peller 已提交
2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617
		ret = wl1271_init_vif_specific(wl, vif);
		if (ret < 0)
			goto out;

	} else {
		ret = wl12xx_cmd_role_enable(wl, vif->addr, WL1271_ROLE_DEVICE,
					     &wlvif->dev_role_id);
		if (ret < 0)
			goto out;

		/* needed mainly for configuring rate policies */
		ret = wl1271_sta_hw_init(wl, wlvif);
		if (ret < 0)
			goto out;
	}
2618

E
Eliad Peller 已提交
2619
	list_add(&wlvif->list, &wl->wlvif_list);
2620
	set_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags);
2621 2622 2623 2624 2625

	if (wlvif->bss_type == BSS_TYPE_AP_BSS)
		wl->ap_count++;
	else
		wl->sta_count++;
2626
out:
2627 2628
	wl1271_ps_elp_sleep(wl);
out_unlock:
L
Luciano Coelho 已提交
2629 2630 2631 2632 2633
	mutex_unlock(&wl->mutex);

	return ret;
}

2634
static void __wl1271_op_remove_interface(struct wl1271 *wl,
E
Eliad Peller 已提交
2635
					 struct ieee80211_vif *vif,
2636
					 bool reset_tx_queues)
L
Luciano Coelho 已提交
2637
{
E
Eliad Peller 已提交
2638
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
E
Eliad Peller 已提交
2639
	int i, ret;
2640
	bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
L
Luciano Coelho 已提交
2641

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

2644 2645 2646
	if (!test_and_clear_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
		return;

2647
	/* because of hardware recovery, we may get here twice */
2648
	if (wl->state == WLCORE_STATE_OFF)
2649 2650
		return;

2651
	wl1271_info("down");
L
Luciano Coelho 已提交
2652

2653
	if (wl->scan.state != WL1271_SCAN_STATE_IDLE &&
2654
	    wl->scan_wlvif == wlvif) {
2655 2656 2657 2658
		struct cfg80211_scan_info info = {
			.aborted = true,
		};

A
Arik Nemtsov 已提交
2659 2660 2661 2662 2663 2664
		/*
		 * 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 已提交
2665
		wl->scan.state = WL1271_SCAN_STATE_IDLE;
2666
		memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2667
		wl->scan_wlvif = NULL;
2668
		wl->scan.req = NULL;
2669
		ieee80211_scan_completed(wl->hw, &info);
L
Luciano Coelho 已提交
2670 2671
	}

2672
	if (wl->sched_vif == wlvif)
2673 2674
		wl->sched_vif = NULL;

2675 2676 2677 2678 2679
	if (wl->roc_vif == vif) {
		wl->roc_vif = NULL;
		ieee80211_remain_on_channel_expired(wl->hw);
	}

2680 2681 2682 2683 2684 2685
	if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
		/* disable active roles */
		ret = wl1271_ps_elp_wakeup(wl);
		if (ret < 0)
			goto deinit;

2686 2687 2688 2689
		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 已提交
2690 2691
		}

E
Eliad Peller 已提交
2692 2693 2694 2695 2696 2697 2698 2699 2700
		if (!wlcore_is_p2p_mgmt(wlvif)) {
			ret = wl12xx_cmd_role_disable(wl, &wlvif->role_id);
			if (ret < 0)
				goto deinit;
		} else {
			ret = wl12xx_cmd_role_disable(wl, &wlvif->dev_role_id);
			if (ret < 0)
				goto deinit;
		}
2701 2702 2703 2704

		wl1271_ps_elp_sleep(wl);
	}
deinit:
2705 2706
	wl12xx_tx_reset_wlvif(wl, wlvif);

2707
	/* clear all hlids (except system_hlid) */
E
Eliad Peller 已提交
2708
	wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
E
Eliad Peller 已提交
2709 2710 2711 2712 2713 2714 2715

	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);
2716
		wlcore_free_klv_template(wl, &wlvif->sta.klv_template_id);
E
Eliad Peller 已提交
2717 2718 2719 2720 2721 2722 2723 2724
	} 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]);
2725
		wl1271_free_ap_keys(wl, wlvif);
E
Eliad Peller 已提交
2726
	}
2727

2728 2729
	dev_kfree_skb(wlvif->probereq);
	wlvif->probereq = NULL;
2730 2731
	if (wl->last_wlvif == wlvif)
		wl->last_wlvif = NULL;
E
Eliad Peller 已提交
2732
	list_del(&wlvif->list);
2733
	memset(wlvif->ap.sta_hlid_map, 0, sizeof(wlvif->ap.sta_hlid_map));
E
Eliad Peller 已提交
2734
	wlvif->role_id = WL12XX_INVALID_ROLE_ID;
E
Eliad Peller 已提交
2735
	wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
2736

2737
	if (is_ap)
2738 2739 2740 2741
		wl->ap_count--;
	else
		wl->sta_count--;

2742 2743 2744 2745 2746 2747 2748 2749
	/*
	 * Last AP, have more stations. Configure sleep auth according to STA.
	 * Don't do thin on unintended recovery.
	 */
	if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) &&
	    !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags))
		goto unlock;

E
Eliad Peller 已提交
2750 2751 2752 2753 2754 2755
	if (wl->ap_count == 0 && is_ap) {
		/* mask ap events */
		wl->event_mask &= ~wl->ap_event_mask;
		wl1271_event_unmask(wl);
	}

2756 2757 2758 2759 2760 2761 2762 2763 2764 2765
	if (wl->ap_count == 0 && is_ap && wl->sta_count) {
		u8 sta_auth = wl->conf.conn.sta_sleep_auth;
		/* Configure for power according to debugfs */
		if (sta_auth != WL1271_PSM_ILLEGAL)
			wl1271_acx_sleep_auth(wl, sta_auth);
		/* Configure for ELP power saving */
		else
			wl1271_acx_sleep_auth(wl, WL1271_PSM_ELP);
	}

2766
unlock:
2767
	mutex_unlock(&wl->mutex);
E
Eyal Shapira 已提交
2768

E
Eliad Peller 已提交
2769 2770 2771
	del_timer_sync(&wlvif->rx_streaming_timer);
	cancel_work_sync(&wlvif->rx_streaming_enable_work);
	cancel_work_sync(&wlvif->rx_streaming_disable_work);
2772
	cancel_work_sync(&wlvif->rc_update_work);
2773
	cancel_delayed_work_sync(&wlvif->connection_loss_work);
2774
	cancel_delayed_work_sync(&wlvif->channel_switch_work);
2775
	cancel_delayed_work_sync(&wlvif->pending_auth_complete_work);
2776

2777
	mutex_lock(&wl->mutex);
2778
}
2779

2780 2781 2782 2783
static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
				       struct ieee80211_vif *vif)
{
	struct wl1271 *wl = hw->priv;
2784
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2785
	struct wl12xx_vif *iter;
2786
	struct vif_counter_data vif_count;
2787

2788
	wl12xx_get_vif_count(hw, vif, &vif_count);
2789
	mutex_lock(&wl->mutex);
2790

2791
	if (wl->state == WLCORE_STATE_OFF ||
2792 2793 2794
	    !test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
		goto out;

2795 2796 2797 2798
	/*
	 * wl->vif can be null here if someone shuts down the interface
	 * just when hardware recovery has been started.
	 */
2799 2800 2801 2802
	wl12xx_for_each_wlvif(wl, iter) {
		if (iter != wlvif)
			continue;

E
Eliad Peller 已提交
2803
		__wl1271_op_remove_interface(wl, vif, true);
2804
		break;
2805
	}
2806
	WARN_ON(iter != wlvif);
2807
	if (wl12xx_need_fw_change(wl, vif_count, false)) {
2808
		wl12xx_force_active_psm(wl);
2809
		set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
2810 2811
		wl12xx_queue_recovery_work(wl);
	}
2812
out:
2813
	mutex_unlock(&wl->mutex);
L
Luciano Coelho 已提交
2814 2815
}

E
Eliad Peller 已提交
2816 2817 2818 2819
static int wl12xx_op_change_interface(struct ieee80211_hw *hw,
				      struct ieee80211_vif *vif,
				      enum nl80211_iftype new_type, bool p2p)
{
2820 2821 2822 2823
	struct wl1271 *wl = hw->priv;
	int ret;

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

2826
	vif->type = new_type;
E
Eliad Peller 已提交
2827
	vif->p2p = p2p;
2828 2829 2830 2831
	ret = wl1271_op_add_interface(hw, vif);

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

2834
static int wlcore_join(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2835 2836
{
	int ret;
E
Eliad Peller 已提交
2837
	bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
2838

2839 2840 2841 2842
	/*
	 * 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.
2843 2844 2845 2846
	 * 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 :)
2847
	 */
2848
	if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2849 2850
		wl1271_info("JOIN while associated.");

2851 2852 2853
	/* clear encryption type */
	wlvif->encryption_type = KEY_NONE;

E
Eliad Peller 已提交
2854
	if (is_ibss)
E
Eliad Peller 已提交
2855
		ret = wl12xx_cmd_role_start_ibss(wl, wlvif);
2856 2857 2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868
	else {
		if (wl->quirks & WLCORE_QUIRK_START_STA_FAILS) {
			/*
			 * TODO: this is an ugly workaround for wl12xx fw
			 * bug - we are not able to tx/rx after the first
			 * start_sta, so make dummy start+stop calls,
			 * and then call start_sta again.
			 * this should be fixed in the fw.
			 */
			wl12xx_cmd_role_start_sta(wl, wlvif);
			wl12xx_cmd_role_stop_sta(wl, wlvif);
		}

E
Eliad Peller 已提交
2869
		ret = wl12xx_cmd_role_start_sta(wl, wlvif);
2870
	}
2871 2872 2873 2874 2875 2876 2877 2878 2879 2880 2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894 2895 2896 2897 2898 2899 2900 2901 2902 2903 2904 2905 2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918 2919 2920

	return ret;
}

static int wl1271_ssid_set(struct wl12xx_vif *wlvif, struct sk_buff *skb,
			    int offset)
{
	u8 ssid_len;
	const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
					 skb->len - offset);

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

	wlvif->ssid_len = ssid_len;
	memcpy(wlvif->ssid, ptr+2, ssid_len);
	return 0;
}

static int wlcore_set_ssid(struct wl1271 *wl, struct wl12xx_vif *wlvif)
{
	struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
	struct sk_buff *skb;
	int ieoffset;

	/* we currently only support setting the ssid from the ap probe req */
	if (wlvif->bss_type != BSS_TYPE_STA_BSS)
		return -EINVAL;

	skb = ieee80211_ap_probereq_get(wl->hw, vif);
	if (!skb)
		return -EINVAL;

	ieoffset = offsetof(struct ieee80211_mgmt,
			    u.probe_req.variable);
	wl1271_ssid_set(wlvif, skb, ieoffset);
	dev_kfree_skb(skb);

	return 0;
}

static int wlcore_set_assoc(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2921 2922
			    struct ieee80211_bss_conf *bss_conf,
			    u32 sta_rate_set)
2923 2924 2925 2926 2927
{
	int ieoffset;
	int ret;

	wlvif->aid = bss_conf->aid;
2928
	wlvif->channel_type = cfg80211_get_chandef_type(&bss_conf->chandef);
2929
	wlvif->beacon_int = bss_conf->beacon_int;
2930
	wlvif->wmm_enabled = bss_conf->qos;
2931 2932 2933 2934 2935 2936 2937 2938 2939 2940

	set_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags);

	/*
	 * 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.
	 */
	ret = wl1271_cmd_build_ps_poll(wl, wlvif, wlvif->aid);
2941
	if (ret < 0)
2942
		return ret;
2943

2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958
	/*
	 * Get a template for hardware connection maintenance
	 */
	dev_kfree_skb(wlvif->probereq);
	wlvif->probereq = wl1271_cmd_build_ap_probe_req(wl,
							wlvif,
							NULL);
	ieoffset = offsetof(struct ieee80211_mgmt,
			    u.probe_req.variable);
	wl1271_ssid_set(wlvif, wlvif->probereq, ieoffset);

	/* enable the connection monitoring feature */
	ret = wl1271_acx_conn_monit_params(wl, wlvif, true);
	if (ret < 0)
		return ret;
2959 2960 2961 2962 2963 2964 2965

	/*
	 * 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 已提交
2966
	ret = wl1271_acx_keep_alive_mode(wl, wlvif, true);
2967
	if (ret < 0)
2968
		return ret;
2969

E
Eliad Peller 已提交
2970
	ret = wl1271_acx_aid(wl, wlvif, wlvif->aid);
2971
	if (ret < 0)
2972
		return ret;
2973

E
Eliad Peller 已提交
2974
	ret = wl12xx_cmd_build_klv_null_data(wl, wlvif);
2975
	if (ret < 0)
2976
		return ret;
2977

E
Eliad Peller 已提交
2978
	ret = wl1271_acx_keep_alive_config(wl, wlvif,
2979
					   wlvif->sta.klv_template_id,
2980 2981
					   ACX_KEEP_ALIVE_TPL_VALID);
	if (ret < 0)
2982
		return ret;
2983

2984 2985 2986 2987 2988
	/*
	 * The default fw psm configuration is AUTO, while mac80211 default
	 * setting is off (ACTIVE), so sync the fw with the correct value.
	 */
	ret = wl1271_ps_set_mode(wl, wlvif, STATION_ACTIVE_MODE);
2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000
	if (ret < 0)
		return ret;

	if (sta_rate_set) {
		wlvif->rate_set =
			wl1271_tx_enabled_rates_get(wl,
						    sta_rate_set,
						    wlvif->band);
		ret = wl1271_acx_sta_rate_policies(wl, wlvif);
		if (ret < 0)
			return ret;
	}
3001 3002 3003 3004

	return ret;
}

3005
static int wlcore_unset_assoc(struct wl1271 *wl, struct wl12xx_vif *wlvif)
3006 3007
{
	int ret;
3008 3009 3010 3011 3012 3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025 3026 3027 3028 3029 3030 3031 3032 3033 3034 3035 3036
	bool sta = wlvif->bss_type == BSS_TYPE_STA_BSS;

	/* make sure we are connected (sta) joined */
	if (sta &&
	    !test_and_clear_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
		return false;

	/* make sure we are joined (ibss) */
	if (!sta &&
	    test_and_clear_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags))
		return false;

	if (sta) {
		/* use defaults when not associated */
		wlvif->aid = 0;

		/* free probe-request template */
		dev_kfree_skb(wlvif->probereq);
		wlvif->probereq = NULL;

		/* disable connection monitor features */
		ret = wl1271_acx_conn_monit_params(wl, wlvif, false);
		if (ret < 0)
			return ret;

		/* Disable the keep-alive feature */
		ret = wl1271_acx_keep_alive_mode(wl, wlvif, false);
		if (ret < 0)
			return ret;
3037 3038 3039 3040 3041

		/* disable beacon filtering */
		ret = wl1271_acx_beacon_filter_opt(wl, wlvif, false);
		if (ret < 0)
			return ret;
3042
	}
3043

3044
	if (test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags)) {
3045 3046
		struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);

3047
		wl12xx_cmd_stop_channel_switch(wl, wlvif);
3048
		ieee80211_chswitch_done(vif, false);
3049
		cancel_delayed_work(&wlvif->channel_switch_work);
3050 3051
	}

3052 3053
	/* invalidate keep-alive template */
	wl1271_acx_keep_alive_config(wl, wlvif,
3054
				     wlvif->sta.klv_template_id,
3055 3056
				     ACX_KEEP_ALIVE_TPL_INVALID);

3057
	return 0;
3058 3059
}

E
Eliad Peller 已提交
3060
static void wl1271_set_band_rate(struct wl1271 *wl, struct wl12xx_vif *wlvif)
3061
{
E
Eliad Peller 已提交
3062
	wlvif->basic_rate_set = wlvif->bitrate_masks[wlvif->band];
E
Eliad Peller 已提交
3063
	wlvif->rate_set = wlvif->basic_rate_set;
3064 3065
}

A
Arik Nemtsov 已提交
3066 3067 3068 3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081 3082 3083 3084
static void wl1271_sta_handle_idle(struct wl1271 *wl, struct wl12xx_vif *wlvif,
				   bool idle)
{
	bool cur_idle = !test_bit(WLVIF_FLAG_ACTIVE, &wlvif->flags);

	if (idle == cur_idle)
		return;

	if (idle) {
		clear_bit(WLVIF_FLAG_ACTIVE, &wlvif->flags);
	} else {
		/* The current firmware only supports sched_scan in idle */
		if (wl->sched_vif == wlvif)
			wl->ops->sched_scan_stop(wl, wlvif);

		set_bit(WLVIF_FLAG_ACTIVE, &wlvif->flags);
	}
}

3085 3086
static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif,
			     struct ieee80211_conf *conf, u32 changed)
3087 3088 3089
{
	int ret;

E
Eliad Peller 已提交
3090 3091 3092
	if (wlcore_is_p2p_mgmt(wlvif))
		return 0;

3093
	if (conf->power_level != wlvif->power_level) {
E
Eliad Peller 已提交
3094
		ret = wl1271_acx_tx_power(wl, wlvif, conf->power_level);
3095
		if (ret < 0)
3096
			return ret;
3097

3098
		wlvif->power_level = conf->power_level;
3099 3100
	}

3101
	return 0;
3102 3103
}

3104
static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
L
Luciano Coelho 已提交
3105
{
3106 3107 3108
	struct wl1271 *wl = hw->priv;
	struct wl12xx_vif *wlvif;
	struct ieee80211_conf *conf = &hw->conf;
E
Eliad Peller 已提交
3109
	int ret = 0;
L
Luciano Coelho 已提交
3110

E
Eliad Peller 已提交
3111
	wl1271_debug(DEBUG_MAC80211, "mac80211 config psm %s power %d %s"
3112 3113 3114 3115 3116 3117 3118 3119 3120 3121 3122
		     " changed 0x%x",
		     conf->flags & IEEE80211_CONF_PS ? "on" : "off",
		     conf->power_level,
		     conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
			 changed);

	mutex_lock(&wl->mutex);

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

3123
	if (unlikely(wl->state != WLCORE_STATE_ON))
3124 3125 3126 3127 3128 3129 3130 3131 3132 3133 3134 3135 3136
		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 已提交
3137 3138 3139 3140 3141 3142 3143 3144 3145
out_sleep:
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

J
Juuso Oikarinen 已提交
3146 3147 3148 3149 3150 3151
struct wl1271_filter_params {
	bool enabled;
	int mc_list_length;
	u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
};

3152 3153
static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
				       struct netdev_hw_addr_list *mc_list)
3154 3155
{
	struct wl1271_filter_params *fp;
3156
	struct netdev_hw_addr *ha;
3157

3158
	fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
3159 3160 3161 3162 3163 3164 3165
	if (!fp) {
		wl1271_error("Out of memory setting filters.");
		return 0;
	}

	/* update multicast filtering parameters */
	fp->mc_list_length = 0;
3166 3167 3168 3169 3170
	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) {
3171
			memcpy(fp->mc_list[fp->mc_list_length],
3172
					ha->addr, ETH_ALEN);
3173
			fp->mc_list_length++;
3174
		}
3175 3176
	}

J
Juuso Oikarinen 已提交
3177
	return (u64)(unsigned long)fp;
3178
}
L
Luciano Coelho 已提交
3179

3180
#define WL1271_SUPPORTED_FILTERS (FIF_ALLMULTI | \
J
Juuso Oikarinen 已提交
3181 3182 3183 3184 3185
				  FIF_FCSFAIL | \
				  FIF_BCN_PRBRESP_PROMISC | \
				  FIF_CONTROL | \
				  FIF_OTHER_BSS)

L
Luciano Coelho 已提交
3186 3187
static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
				       unsigned int changed,
3188
				       unsigned int *total, u64 multicast)
L
Luciano Coelho 已提交
3189
{
J
Juuso Oikarinen 已提交
3190
	struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
L
Luciano Coelho 已提交
3191
	struct wl1271 *wl = hw->priv;
3192
	struct wl12xx_vif *wlvif;
E
Eliad Peller 已提交
3193

J
Juuso Oikarinen 已提交
3194
	int ret;
L
Luciano Coelho 已提交
3195

3196 3197
	wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
		     " total %x", changed, *total);
L
Luciano Coelho 已提交
3198

J
Juuso Oikarinen 已提交
3199 3200
	mutex_lock(&wl->mutex);

3201 3202 3203
	*total &= WL1271_SUPPORTED_FILTERS;
	changed &= WL1271_SUPPORTED_FILTERS;

3204
	if (unlikely(wl->state != WLCORE_STATE_ON))
J
Juuso Oikarinen 已提交
3205 3206
		goto out;

3207
	ret = wl1271_ps_elp_wakeup(wl);
J
Juuso Oikarinen 已提交
3208 3209 3210
	if (ret < 0)
		goto out;

3211
	wl12xx_for_each_wlvif(wl, wlvif) {
E
Eliad Peller 已提交
3212 3213 3214
		if (wlcore_is_p2p_mgmt(wlvif))
			continue;

3215 3216 3217 3218 3219 3220 3221 3222 3223 3224 3225 3226 3227
		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;
		}
3228 3229 3230 3231 3232 3233 3234 3235 3236 3237 3238 3239 3240 3241 3242

		/*
		 * If interface in AP mode and created with allmulticast then disable
		 * the firmware filters so that all multicast packets are passed
		 * This is mandatory for MDNS based discovery protocols 
		 */
 		if (wlvif->bss_type == BSS_TYPE_AP_BSS) {
 			if (*total & FIF_ALLMULTI) {
				ret = wl1271_acx_group_address_tbl(wl, wlvif,
							false,
							NULL, 0);
				if (ret < 0)
					goto out_sleep;
			}
		}
3243
	}
L
Luciano Coelho 已提交
3244

E
Eliad Peller 已提交
3245 3246 3247 3248 3249
	/*
	 * 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 已提交
3250 3251 3252 3253 3254 3255

out_sleep:
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);
3256
	kfree(fp);
L
Luciano Coelho 已提交
3257 3258
}

3259 3260 3261 3262
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)
3263 3264 3265 3266 3267 3268 3269 3270 3271 3272 3273 3274 3275 3276
{
	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++) {
3277
		if (wlvif->ap.recorded_keys[i] == NULL)
3278 3279
			break;

3280
		if (wlvif->ap.recorded_keys[i]->id == id) {
3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300
			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;

3301
	wlvif->ap.recorded_keys[i] = ap_key;
3302 3303 3304
	return 0;
}

3305
static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif)
3306 3307 3308 3309
{
	int i;

	for (i = 0; i < MAX_NUM_KEYS; i++) {
3310 3311
		kfree(wlvif->ap.recorded_keys[i]);
		wlvif->ap.recorded_keys[i] = NULL;
3312 3313 3314
	}
}

3315
static int wl1271_ap_init_hwenc(struct wl1271 *wl, struct wl12xx_vif *wlvif)
3316 3317 3318 3319 3320 3321
{
	int i, ret = 0;
	struct wl1271_ap_key *key;
	bool wep_key_added = false;

	for (i = 0; i < MAX_NUM_KEYS; i++) {
3322
		u8 hlid;
3323
		if (wlvif->ap.recorded_keys[i] == NULL)
3324 3325
			break;

3326
		key = wlvif->ap.recorded_keys[i];
3327 3328
		hlid = key->hlid;
		if (hlid == WL12XX_INVALID_LINK_ID)
3329
			hlid = wlvif->ap.bcast_hlid;
3330

3331
		ret = wl1271_cmd_set_ap_key(wl, wlvif, KEY_ADD_OR_REPLACE,
3332 3333
					    key->id, key->key_type,
					    key->key_size, key->key,
3334
					    hlid, key->tx_seq_32,
3335 3336 3337 3338 3339 3340 3341 3342 3343
					    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 已提交
3344
		ret = wl12xx_cmd_set_default_wep_key(wl, wlvif->default_key,
3345
						     wlvif->ap.bcast_hlid);
3346 3347 3348 3349 3350
		if (ret < 0)
			goto out;
	}

out:
3351
	wl1271_free_ap_keys(wl, wlvif);
3352 3353 3354
	return ret;
}

E
Eliad Peller 已提交
3355 3356
static int wl1271_set_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
		       u16 action, u8 id, u8 key_type,
3357 3358 3359 3360
		       u8 key_size, const u8 *key, u32 tx_seq_32,
		       u16 tx_seq_16, struct ieee80211_sta *sta)
{
	int ret;
E
Eliad Peller 已提交
3361
	bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
3362 3363 3364 3365 3366 3367 3368 3369 3370

	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 {
3371
			hlid = wlvif->ap.bcast_hlid;
3372 3373
		}

3374
		if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
3375 3376 3377 3378 3379 3380 3381
			/*
			 * We do not support removing keys after AP shutdown.
			 * Pretend we do to make mac80211 happy.
			 */
			if (action != KEY_ADD_OR_REPLACE)
				return 0;

3382
			ret = wl1271_record_ap_key(wl, wlvif, id,
3383 3384 3385 3386
					     key_type, key_size,
					     key, hlid, tx_seq_32,
					     tx_seq_16);
		} else {
3387
			ret = wl1271_cmd_set_ap_key(wl, wlvif, action,
3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404 3405 3406 3407 3408 3409 3410 3411 3412 3413 3414
					     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;

3415 3416
		/* don't remove key if hlid was already deleted */
		if (action == KEY_REMOVE &&
E
Eliad Peller 已提交
3417
		    wlvif->sta.hlid == WL12XX_INVALID_LINK_ID)
3418 3419
			return 0;

3420
		ret = wl1271_cmd_set_sta_key(wl, wlvif, action,
3421 3422 3423 3424 3425 3426 3427 3428 3429 3430 3431
					     id, key_type, key_size,
					     key, addr, tx_seq_32,
					     tx_seq_16);
		if (ret < 0)
			return ret;

	}

	return 0;
}

3432
static int wlcore_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
L
Luciano Coelho 已提交
3433 3434 3435 3436 3437
			     struct ieee80211_vif *vif,
			     struct ieee80211_sta *sta,
			     struct ieee80211_key_conf *key_conf)
{
	struct wl1271 *wl = hw->priv;
3438 3439 3440 3441 3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457
	int ret;
	bool might_change_spare =
		key_conf->cipher == WL1271_CIPHER_SUITE_GEM ||
		key_conf->cipher == WLAN_CIPHER_SUITE_TKIP;

	if (might_change_spare) {
		/*
		 * stop the queues and flush to ensure the next packets are
		 * in sync with FW spare block accounting
		 */
		wlcore_stop_queues(wl, WLCORE_QUEUE_STOP_REASON_SPARE_BLK);
		wl1271_tx_flush(wl);
	}

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state != WLCORE_STATE_ON)) {
		ret = -EAGAIN;
		goto out_wake_queues;
	}
3458

3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469 3470 3471 3472 3473
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out_wake_queues;

	ret = wlcore_hw_set_key(wl, cmd, vif, sta, key_conf);

	wl1271_ps_elp_sleep(wl);

out_wake_queues:
	if (might_change_spare)
		wlcore_wake_queues(wl, WLCORE_QUEUE_STOP_REASON_SPARE_BLK);

	mutex_unlock(&wl->mutex);

	return ret;
3474 3475 3476 3477 3478 3479 3480
}

int wlcore_set_key(struct wl1271 *wl, enum set_key_cmd cmd,
		   struct ieee80211_vif *vif,
		   struct ieee80211_sta *sta,
		   struct ieee80211_key_conf *key_conf)
{
E
Eliad Peller 已提交
3481
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
L
Luciano Coelho 已提交
3482
	int ret;
3483 3484
	u32 tx_seq_32 = 0;
	u16 tx_seq_16 = 0;
L
Luciano Coelho 已提交
3485
	u8 key_type;
3486
	u8 hlid;
L
Luciano Coelho 已提交
3487 3488 3489

	wl1271_debug(DEBUG_MAC80211, "mac80211 set key");

3490
	wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
L
Luciano Coelho 已提交
3491
	wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
3492
		     key_conf->cipher, key_conf->keyidx,
L
Luciano Coelho 已提交
3493 3494 3495
		     key_conf->keylen, key_conf->flags);
	wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);

3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507 3508 3509 3510 3511
	if (wlvif->bss_type == BSS_TYPE_AP_BSS)
		if (sta) {
			struct wl1271_station *wl_sta = (void *)sta->drv_priv;
			hlid = wl_sta->hlid;
		} else {
			hlid = wlvif->ap.bcast_hlid;
		}
	else
		hlid = wlvif->sta.hlid;

	if (hlid != WL12XX_INVALID_LINK_ID) {
		u64 tx_seq = wl->links[hlid].total_freed_pkts;
		tx_seq_32 = WL1271_TX_SECURITY_HI32(tx_seq);
		tx_seq_16 = WL1271_TX_SECURITY_LO16(tx_seq);
	}

3512 3513 3514
	switch (key_conf->cipher) {
	case WLAN_CIPHER_SUITE_WEP40:
	case WLAN_CIPHER_SUITE_WEP104:
L
Luciano Coelho 已提交
3515 3516 3517 3518
		key_type = KEY_WEP;

		key_conf->hw_key_idx = key_conf->keyidx;
		break;
3519
	case WLAN_CIPHER_SUITE_TKIP:
L
Luciano Coelho 已提交
3520 3521 3522
		key_type = KEY_TKIP;
		key_conf->hw_key_idx = key_conf->keyidx;
		break;
3523
	case WLAN_CIPHER_SUITE_CCMP:
L
Luciano Coelho 已提交
3524
		key_type = KEY_AES;
3525
		key_conf->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
L
Luciano Coelho 已提交
3526
		break;
3527 3528 3529
	case WL1271_CIPHER_SUITE_GEM:
		key_type = KEY_GEM;
		break;
L
Luciano Coelho 已提交
3530
	default:
3531
		wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
L
Luciano Coelho 已提交
3532

3533
		return -EOPNOTSUPP;
L
Luciano Coelho 已提交
3534 3535 3536 3537
	}

	switch (cmd) {
	case SET_KEY:
E
Eliad Peller 已提交
3538
		ret = wl1271_set_key(wl, wlvif, KEY_ADD_OR_REPLACE,
3539 3540 3541
				 key_conf->keyidx, key_type,
				 key_conf->keylen, key_conf->key,
				 tx_seq_32, tx_seq_16, sta);
L
Luciano Coelho 已提交
3542 3543
		if (ret < 0) {
			wl1271_error("Could not add or replace key");
3544
			return ret;
L
Luciano Coelho 已提交
3545
		}
3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556 3557

		/*
		 * 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);
3558
				return ret;
3559 3560
			}
		}
L
Luciano Coelho 已提交
3561 3562 3563
		break;

	case DISABLE_KEY:
E
Eliad Peller 已提交
3564
		ret = wl1271_set_key(wl, wlvif, KEY_REMOVE,
3565 3566 3567
				     key_conf->keyidx, key_type,
				     key_conf->keylen, key_conf->key,
				     0, 0, sta);
L
Luciano Coelho 已提交
3568 3569
		if (ret < 0) {
			wl1271_error("Could not remove key");
3570
			return ret;
L
Luciano Coelho 已提交
3571 3572 3573 3574 3575
		}
		break;

	default:
		wl1271_error("Unsupported key cmd 0x%x", cmd);
3576
		return -EOPNOTSUPP;
L
Luciano Coelho 已提交
3577 3578 3579 3580
	}

	return ret;
}
3581
EXPORT_SYMBOL_GPL(wlcore_set_key);
L
Luciano Coelho 已提交
3582

3583 3584 3585 3586 3587 3588 3589 3590 3591 3592 3593
static void wl1271_op_set_default_key_idx(struct ieee80211_hw *hw,
					  struct ieee80211_vif *vif,
					  int key_idx)
{
	struct wl1271 *wl = hw->priv;
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
	int ret;

	wl1271_debug(DEBUG_MAC80211, "mac80211 set default key idx %d",
		     key_idx);

3594 3595 3596 3597
	/* we don't handle unsetting of default key */
	if (key_idx == -1)
		return;

3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618 3619 3620 3621 3622 3623 3624 3625 3626
	mutex_lock(&wl->mutex);

	if (unlikely(wl->state != WLCORE_STATE_ON)) {
		ret = -EAGAIN;
		goto out_unlock;
	}

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

	wlvif->default_key = key_idx;

	/* the default WEP key needs to be configured at least once */
	if (wlvif->encryption_type == KEY_WEP) {
		ret = wl12xx_cmd_set_default_wep_key(wl,
				key_idx,
				wlvif->sta.hlid);
		if (ret < 0)
			goto out_sleep;
	}

out_sleep:
	wl1271_ps_elp_sleep(wl);

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

3627 3628 3629 3630 3631 3632 3633 3634
void wlcore_regdomain_config(struct wl1271 *wl)
{
	int ret;

	if (!(wl->quirks & WLCORE_QUIRK_REGDOMAIN_CONF))
		return;

	mutex_lock(&wl->mutex);
3635 3636 3637 3638

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

3639 3640 3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

	ret = wlcore_cmd_regdomain_config_locked(wl);
	if (ret < 0) {
		wl12xx_queue_recovery_work(wl);
		goto out;
	}

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

L
Luciano Coelho 已提交
3654
static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
3655
			     struct ieee80211_vif *vif,
3656
			     struct ieee80211_scan_request *hw_req)
L
Luciano Coelho 已提交
3657
{
3658
	struct cfg80211_scan_request *req = &hw_req->req;
L
Luciano Coelho 已提交
3659 3660 3661
	struct wl1271 *wl = hw->priv;
	int ret;
	u8 *ssid = NULL;
3662
	size_t len = 0;
L
Luciano Coelho 已提交
3663 3664 3665 3666 3667

	wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");

	if (req->n_ssids) {
		ssid = req->ssids[0].ssid;
3668
		len = req->ssids[0].ssid_len;
L
Luciano Coelho 已提交
3669 3670 3671 3672
	}

	mutex_lock(&wl->mutex);

3673
	if (unlikely(wl->state != WLCORE_STATE_ON)) {
3674 3675 3676 3677 3678 3679 3680 3681 3682
		/*
		 * 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;
	}

3683
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
3684 3685 3686
	if (ret < 0)
		goto out;

3687 3688
	/* fail if there is any role in ROC */
	if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
3689 3690 3691 3692 3693
		/* don't allow scanning right now */
		ret = -EBUSY;
		goto out_sleep;
	}

3694
	ret = wlcore_scan(hw->priv, vif, ssid, len, req);
3695
out_sleep:
L
Luciano Coelho 已提交
3696 3697 3698 3699 3700 3701 3702
	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);

	return ret;
}

3703 3704 3705 3706
static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
				     struct ieee80211_vif *vif)
{
	struct wl1271 *wl = hw->priv;
3707
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3708 3709 3710
	struct cfg80211_scan_info info = {
		.aborted = true,
	};
3711 3712 3713 3714 3715 3716
	int ret;

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

	mutex_lock(&wl->mutex);

3717
	if (unlikely(wl->state != WLCORE_STATE_ON))
3718 3719 3720 3721 3722 3723 3724 3725 3726 3727
		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) {
3728
		ret = wl->ops->scan_stop(wl, wlvif);
3729 3730 3731
		if (ret < 0)
			goto out_sleep;
	}
A
Arik Nemtsov 已提交
3732 3733 3734 3735 3736 3737 3738

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

3739 3740
	wl->scan.state = WL1271_SCAN_STATE_IDLE;
	memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
3741
	wl->scan_wlvif = NULL;
3742
	wl->scan.req = NULL;
3743
	ieee80211_scan_completed(wl->hw, &info);
3744 3745 3746 3747 3748 3749 3750 3751 3752

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

	cancel_delayed_work_sync(&wl->scan_complete_work);
}

3753 3754 3755
static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
				      struct ieee80211_vif *vif,
				      struct cfg80211_sched_scan_request *req,
D
David Spinadel 已提交
3756
				      struct ieee80211_scan_ies *ies)
3757 3758
{
	struct wl1271 *wl = hw->priv;
E
Eliad Peller 已提交
3759
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3760 3761 3762 3763 3764 3765
	int ret;

	wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");

	mutex_lock(&wl->mutex);

3766
	if (unlikely(wl->state != WLCORE_STATE_ON)) {
3767 3768 3769 3770
		ret = -EAGAIN;
		goto out;
	}

3771 3772 3773 3774
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

3775
	ret = wl->ops->sched_scan_start(wl, wlvif, req, ies);
3776 3777 3778
	if (ret < 0)
		goto out_sleep;

3779
	wl->sched_vif = wlvif;
3780 3781 3782 3783 3784 3785 3786 3787

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

3788 3789
static int wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
				     struct ieee80211_vif *vif)
3790 3791
{
	struct wl1271 *wl = hw->priv;
3792
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3793 3794 3795 3796 3797 3798
	int ret;

	wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");

	mutex_lock(&wl->mutex);

3799
	if (unlikely(wl->state != WLCORE_STATE_ON))
3800 3801
		goto out;

3802 3803 3804 3805
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;

3806
	wl->ops->sched_scan_stop(wl, wlvif);
3807 3808 3809 3810

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

	return 0;
3813 3814
}

3815 3816 3817 3818 3819 3820 3821
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);

3822
	if (unlikely(wl->state != WLCORE_STATE_ON)) {
3823 3824 3825 3826
		ret = -EAGAIN;
		goto out;
	}

3827
	ret = wl1271_ps_elp_wakeup(wl);
3828 3829 3830
	if (ret < 0)
		goto out;

3831
	ret = wl1271_acx_frag_threshold(wl, value);
3832 3833 3834 3835 3836 3837 3838 3839 3840 3841 3842
	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 已提交
3843 3844 3845
static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
{
	struct wl1271 *wl = hw->priv;
3846
	struct wl12xx_vif *wlvif;
3847
	int ret = 0;
L
Luciano Coelho 已提交
3848 3849 3850

	mutex_lock(&wl->mutex);

3851
	if (unlikely(wl->state != WLCORE_STATE_ON)) {
3852
		ret = -EAGAIN;
3853
		goto out;
3854
	}
3855

3856
	ret = wl1271_ps_elp_wakeup(wl);
L
Luciano Coelho 已提交
3857 3858 3859
	if (ret < 0)
		goto out;

3860 3861 3862 3863 3864
	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 已提交
3865 3866 3867 3868 3869 3870 3871 3872
	wl1271_ps_elp_sleep(wl);

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886
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);
}

3887 3888 3889 3890 3891 3892 3893 3894 3895 3896 3897 3898 3899 3900 3901 3902 3903
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);
}

3904 3905
static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl, u32 rates,
					 struct ieee80211_vif *vif)
3906
{
3907
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3908 3909 3910
	struct sk_buff *skb;
	int ret;

3911
	skb = ieee80211_proberesp_get(wl->hw, vif);
3912
	if (!skb)
3913
		return -EOPNOTSUPP;
3914

3915
	ret = wl1271_cmd_template_set(wl, wlvif->role_id,
3916 3917 3918 3919 3920
				      CMD_TEMPL_AP_PROBE_RESPONSE,
				      skb->data,
				      skb->len, 0,
				      rates);
	dev_kfree_skb(skb);
3921 3922 3923 3924 3925 3926 3927 3928

	if (ret < 0)
		goto out;

	wl1271_debug(DEBUG_AP, "probe response updated");
	set_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags);

out:
3929 3930 3931 3932 3933 3934 3935 3936
	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)
3937
{
3938 3939
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
	struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
3940 3941 3942 3943 3944
	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 */
3945
	if (wlvif->ssid_len > 0)
3946
		return wl1271_cmd_template_set(wl, wlvif->role_id,
3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982
					       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);

3983
	return wl1271_cmd_template_set(wl, wlvif->role_id,
3984 3985 3986 3987 3988 3989
				       CMD_TEMPL_AP_PROBE_RESPONSE,
				       probe_rsp_templ,
				       templ_len, 0,
				       rates);
}

3990
static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
E
Eliad Peller 已提交
3991
				       struct ieee80211_vif *vif,
L
Luciano Coelho 已提交
3992 3993 3994
				       struct ieee80211_bss_conf *bss_conf,
				       u32 changed)
{
E
Eliad Peller 已提交
3995
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3996
	int ret = 0;
L
Luciano Coelho 已提交
3997

3998 3999
	if (changed & BSS_CHANGED_ERP_SLOT) {
		if (bss_conf->use_short_slot)
E
Eliad Peller 已提交
4000
			ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_SHORT);
4001
		else
E
Eliad Peller 已提交
4002
			ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_LONG);
4003 4004 4005 4006 4007
		if (ret < 0) {
			wl1271_warning("Set slot time failed %d", ret);
			goto out;
		}
	}
L
Luciano Coelho 已提交
4008

4009 4010
	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
		if (bss_conf->use_short_preamble)
E
Eliad Peller 已提交
4011
			wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_SHORT);
4012
		else
E
Eliad Peller 已提交
4013
			wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_LONG);
4014
	}
L
Luciano Coelho 已提交
4015

4016 4017
	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
		if (bss_conf->use_cts_prot)
E
Eliad Peller 已提交
4018 4019
			ret = wl1271_acx_cts_protect(wl, wlvif,
						     CTSPROTECT_ENABLE);
4020
		else
E
Eliad Peller 已提交
4021 4022
			ret = wl1271_acx_cts_protect(wl, wlvif,
						     CTSPROTECT_DISABLE);
4023 4024 4025 4026 4027
		if (ret < 0) {
			wl1271_warning("Set ctsprotect failed %d", ret);
			goto out;
		}
	}
4028

4029 4030 4031
out:
	return ret;
}
L
Luciano Coelho 已提交
4032

4033 4034 4035 4036 4037 4038 4039 4040
static int wlcore_set_beacon_template(struct wl1271 *wl,
				      struct ieee80211_vif *vif,
				      bool is_ap)
{
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
	struct ieee80211_hdr *hdr;
	u32 min_rate;
	int ret;
4041
	int ieoffset = offsetof(struct ieee80211_mgmt, u.beacon.variable);
4042 4043 4044 4045 4046 4047 4048 4049 4050 4051
	struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif);
	u16 tmpl_id;

	if (!beacon) {
		ret = -EINVAL;
		goto out;
	}

	wl1271_debug(DEBUG_MASTER, "beacon updated");

4052
	ret = wl1271_ssid_set(wlvif, beacon, ieoffset);
4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068
	if (ret < 0) {
		dev_kfree_skb(beacon);
		goto out;
	}
	min_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
	tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
		CMD_TEMPL_BEACON;
	ret = wl1271_cmd_template_set(wl, wlvif->role_id, tmpl_id,
				      beacon->data,
				      beacon->len, 0,
				      min_rate);
	if (ret < 0) {
		dev_kfree_skb(beacon);
		goto out;
	}

4069 4070 4071 4072 4073 4074
	wlvif->wmm_enabled =
		cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
					WLAN_OUI_TYPE_MICROSOFT_WMM,
					beacon->data + ieoffset,
					beacon->len - ieoffset);

4075 4076 4077 4078 4079 4080 4081 4082 4083 4084 4085 4086 4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103 4104 4105 4106 4107 4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118
	/*
	 * 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;

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

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

	hdr = (struct ieee80211_hdr *) beacon->data;
	hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
					 IEEE80211_STYPE_PROBE_RESP);
	if (is_ap)
		ret = wl1271_ap_set_probe_resp_tmpl_legacy(wl, vif,
							   beacon->data,
							   beacon->len,
							   min_rate);
	else
		ret = wl1271_cmd_template_set(wl, wlvif->role_id,
					      CMD_TEMPL_PROBE_RESPONSE,
					      beacon->data,
					      beacon->len, 0,
					      min_rate);
end_bcn:
	dev_kfree_skb(beacon);
	if (ret < 0)
		goto out;

out:
	return ret;
}

4119 4120 4121 4122 4123
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 已提交
4124
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
E
Eliad Peller 已提交
4125
	bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
4126 4127
	int ret = 0;

4128
	if (changed & BSS_CHANGED_BEACON_INT) {
4129
		wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
4130 4131
			bss_conf->beacon_int);

E
Eliad Peller 已提交
4132
		wlvif->beacon_int = bss_conf->beacon_int;
4133 4134
	}

4135 4136
	if ((changed & BSS_CHANGED_AP_PROBE_RESP) && is_ap) {
		u32 rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
4137 4138

		wl1271_ap_set_probe_resp_tmpl(wl, rate, vif);
4139 4140
	}

4141
	if (changed & BSS_CHANGED_BEACON) {
4142
		ret = wlcore_set_beacon_template(wl, vif, is_ap);
4143 4144 4145
		if (ret < 0)
			goto out;

4146 4147 4148 4149 4150 4151 4152
		if (test_and_clear_bit(WLVIF_FLAG_BEACON_DISABLED,
				       &wlvif->flags)) {
			ret = wlcore_hw_dfs_master_restart(wl, wlvif);
			if (ret < 0)
				goto out;
		}
	}
4153
out:
4154 4155
	if (ret != 0)
		wl1271_error("beacon info change failed: %d", ret);
4156 4157 4158 4159 4160 4161 4162 4163 4164
	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 已提交
4165
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4166
	int ret = 0;
4167

E
Eliad Peller 已提交
4168
	if (changed & BSS_CHANGED_BASIC_RATES) {
4169
		u32 rates = bss_conf->basic_rates;
4170

E
Eliad Peller 已提交
4171
		wlvif->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates,
E
Eliad Peller 已提交
4172
								 wlvif->band);
E
Eliad Peller 已提交
4173
		wlvif->basic_rate = wl1271_tx_min_rate_get(wl,
E
Eliad Peller 已提交
4174
							wlvif->basic_rate_set);
4175

E
Eliad Peller 已提交
4176
		ret = wl1271_init_ap_rates(wl, wlvif);
4177
		if (ret < 0) {
4178
			wl1271_error("AP rate policy change failed %d", ret);
4179 4180
			goto out;
		}
4181

4182
		ret = wl1271_ap_init_templates(wl, vif);
4183 4184
		if (ret < 0)
			goto out;
4185

4186 4187 4188 4189 4190 4191 4192 4193
		/* No need to set probe resp template for mesh */
		if (!ieee80211_vif_is_mesh(vif)) {
			ret = wl1271_ap_set_probe_resp_tmpl(wl,
							    wlvif->basic_rate,
							    vif);
			if (ret < 0)
				goto out;
		}
4194 4195 4196 4197

		ret = wlcore_set_beacon_template(wl, vif, true);
		if (ret < 0)
			goto out;
4198
	}
4199

4200 4201 4202
	ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
	if (ret < 0)
		goto out;
4203

4204
	if (changed & BSS_CHANGED_BEACON_ENABLED) {
4205
		if (bss_conf->enable_beacon) {
4206
			if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
E
Eliad Peller 已提交
4207
				ret = wl12xx_cmd_role_start_ap(wl, wlvif);
4208 4209
				if (ret < 0)
					goto out;
4210

4211
				ret = wl1271_ap_init_hwenc(wl, wlvif);
4212 4213
				if (ret < 0)
					goto out;
4214

4215
				set_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
4216
				wl1271_debug(DEBUG_AP, "started AP");
4217
			}
4218
		} else {
4219
			if (test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
4220 4221 4222 4223 4224 4225 4226
				/*
				 * AP might be in ROC in case we have just
				 * sent auth reply. handle it.
				 */
				if (test_bit(wlvif->role_id, wl->roc_map))
					wl12xx_croc(wl, wlvif->role_id);

E
Eliad Peller 已提交
4227
				ret = wl12xx_cmd_role_stop_ap(wl, wlvif);
4228 4229
				if (ret < 0)
					goto out;
4230

4231
				clear_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
4232 4233
				clear_bit(WLVIF_FLAG_AP_PROBE_RESP_SET,
					  &wlvif->flags);
4234 4235 4236 4237
				wl1271_debug(DEBUG_AP, "stopped AP");
			}
		}
	}
4238

E
Eliad Peller 已提交
4239
	ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
4240 4241
	if (ret < 0)
		goto out;
4242 4243 4244

	/* Handle HT information change */
	if ((changed & BSS_CHANGED_HT) &&
4245
	    (bss_conf->chandef.width != NL80211_CHAN_WIDTH_20_NOHT)) {
E
Eliad Peller 已提交
4246
		ret = wl1271_acx_set_ht_information(wl, wlvif,
4247 4248 4249 4250 4251 4252 4253
					bss_conf->ht_operation_mode);
		if (ret < 0) {
			wl1271_warning("Set ht information failed %d", ret);
			goto out;
		}
	}

4254 4255 4256
out:
	return;
}
J
Juuso Oikarinen 已提交
4257

4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286
static int wlcore_set_bssid(struct wl1271 *wl, struct wl12xx_vif *wlvif,
			    struct ieee80211_bss_conf *bss_conf,
			    u32 sta_rate_set)
{
	u32 rates;
	int ret;

	wl1271_debug(DEBUG_MAC80211,
	     "changed_bssid: %pM, aid: %d, bcn_int: %d, brates: 0x%x sta_rate_set: 0x%x",
	     bss_conf->bssid, bss_conf->aid,
	     bss_conf->beacon_int,
	     bss_conf->basic_rates, sta_rate_set);

	wlvif->beacon_int = bss_conf->beacon_int;
	rates = bss_conf->basic_rates;
	wlvif->basic_rate_set =
		wl1271_tx_enabled_rates_get(wl, rates,
					    wlvif->band);
	wlvif->basic_rate =
		wl1271_tx_min_rate_get(wl,
				       wlvif->basic_rate_set);

	if (sta_rate_set)
		wlvif->rate_set =
			wl1271_tx_enabled_rates_get(wl,
						sta_rate_set,
						wlvif->band);

	/* we only support sched_scan while not connected */
4287
	if (wl->sched_vif == wlvif)
4288
		wl->ops->sched_scan_stop(wl, wlvif);
4289 4290 4291 4292 4293 4294 4295 4296 4297 4298 4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330

	ret = wl1271_acx_sta_rate_policies(wl, wlvif);
	if (ret < 0)
		return ret;

	ret = wl12xx_cmd_build_null_data(wl, wlvif);
	if (ret < 0)
		return ret;

	ret = wl1271_build_qos_null_data(wl, wl12xx_wlvif_to_vif(wlvif));
	if (ret < 0)
		return ret;

	wlcore_set_ssid(wl, wlvif);

	set_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);

	return 0;
}

static int wlcore_clear_bssid(struct wl1271 *wl, struct wl12xx_vif *wlvif)
{
	int ret;

	/* revert back to minimum rates for the current band */
	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);
	if (ret < 0)
		return ret;

	if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
	    test_bit(WLVIF_FLAG_IN_USE, &wlvif->flags)) {
		ret = wl12xx_cmd_role_stop_sta(wl, wlvif);
		if (ret < 0)
			return ret;
	}

	clear_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
	return 0;
}
4331 4332 4333 4334 4335 4336
/* 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 已提交
4337
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4338
	bool do_join = false;
E
Eliad Peller 已提交
4339
	bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
E
Eliad Peller 已提交
4340
	bool ibss_joined = false;
4341
	u32 sta_rate_set = 0;
4342
	int ret;
4343
	struct ieee80211_sta *sta;
4344 4345
	bool sta_exists = false;
	struct ieee80211_sta_ht_cap sta_ht_cap;
4346 4347 4348 4349 4350 4351

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

E
Eliad Peller 已提交
4354 4355
	if (changed & BSS_CHANGED_IBSS) {
		if (bss_conf->ibss_joined) {
4356
			set_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags);
E
Eliad Peller 已提交
4357 4358
			ibss_joined = true;
		} else {
4359 4360
			wlcore_unset_assoc(wl, wlvif);
			wl12xx_cmd_role_stop_sta(wl, wlvif);
E
Eliad Peller 已提交
4361 4362 4363 4364
		}
	}

	if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
4365 4366 4367
		do_join = true;

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

E
Eliad Peller 已提交
4371
	if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
4372 4373 4374 4375 4376 4377
		wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
			     bss_conf->enable_beacon ? "enabled" : "disabled");

		do_join = true;
	}

A
Arik Nemtsov 已提交
4378 4379 4380
	if (changed & BSS_CHANGED_IDLE && !is_ibss)
		wl1271_sta_handle_idle(wl, wlvif, bss_conf->idle);

4381
	if (changed & BSS_CHANGED_CQM) {
4382 4383 4384
		bool enable = false;
		if (bss_conf->cqm_rssi_thold)
			enable = true;
E
Eliad Peller 已提交
4385
		ret = wl1271_acx_rssi_snr_trigger(wl, wlvif, enable,
4386 4387 4388 4389
						  bss_conf->cqm_rssi_thold,
						  bss_conf->cqm_rssi_hyst);
		if (ret < 0)
			goto out;
4390
		wlvif->rssi_thold = bss_conf->cqm_rssi_thold;
4391 4392
	}

4393 4394
	if (changed & (BSS_CHANGED_BSSID | BSS_CHANGED_HT |
		       BSS_CHANGED_ASSOC)) {
4395 4396
		rcu_read_lock();
		sta = ieee80211_find_sta(vif, bss_conf->bssid);
4397 4398 4399 4400 4401 4402 4403 4404 4405 4406 4407 4408 4409
		if (sta) {
			u8 *rx_mask = sta->ht_cap.mcs.rx_mask;

			/* save the supp_rates of the ap */
			sta_rate_set = sta->supp_rates[wlvif->band];
			if (sta->ht_cap.ht_supported)
				sta_rate_set |=
					(rx_mask[0] << HW_HT_RATES_OFFSET) |
					(rx_mask[1] << HW_MIMO_RATES_OFFSET);
			sta_ht_cap = sta->ht_cap;
			sta_exists = true;
		}

4410
		rcu_read_unlock();
4411 4412
	}

4413 4414 4415 4416
	if (changed & BSS_CHANGED_BSSID) {
		if (!is_zero_ether_addr(bss_conf->bssid)) {
			ret = wlcore_set_bssid(wl, wlvif, bss_conf,
					       sta_rate_set);
L
Luciano Coelho 已提交
4417
			if (ret < 0)
4418
				goto out;
L
Luciano Coelho 已提交
4419

4420 4421
			/* Need to update the BSSID (for filtering etc) */
			do_join = true;
J
Juuso Oikarinen 已提交
4422
		} else {
4423
			ret = wlcore_clear_bssid(wl, wlvif);
4424
			if (ret < 0)
4425
				goto out;
L
Luciano Coelho 已提交
4426 4427 4428
		}
	}

4429 4430 4431 4432 4433 4434
	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 已提交
4435
			wlvif->basic_rate_set =
4436
				wl1271_tx_enabled_rates_get(wl, rates,
E
Eliad Peller 已提交
4437
							    wlvif->band);
E
Eliad Peller 已提交
4438
			wlvif->basic_rate =
E
Eliad Peller 已提交
4439 4440
				wl1271_tx_min_rate_get(wl,
						       wlvif->basic_rate_set);
4441

4442
			/* by default, use 11b + OFDM rates */
E
Eliad Peller 已提交
4443 4444
			wlvif->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
			ret = wl1271_acx_sta_rate_policies(wl, wlvif);
4445 4446 4447 4448 4449
			if (ret < 0)
				goto out;
		}
	}

4450 4451 4452 4453 4454 4455 4456
	if ((changed & BSS_CHANGED_BEACON_INFO) && bss_conf->dtim_period) {
		/* enable beacon filtering */
		ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true);
		if (ret < 0)
			goto out;
	}

E
Eliad Peller 已提交
4457
	ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
4458 4459
	if (ret < 0)
		goto out;
L
Luciano Coelho 已提交
4460

J
Juuso Oikarinen 已提交
4461
	if (do_join) {
4462
		ret = wlcore_join(wl, wlvif);
J
Juuso Oikarinen 已提交
4463 4464
		if (ret < 0) {
			wl1271_warning("cmd join failed %d", ret);
4465
			goto out;
J
Juuso Oikarinen 已提交
4466
		}
4467
	}
4468

4469 4470
	if (changed & BSS_CHANGED_ASSOC) {
		if (bss_conf->assoc) {
4471 4472
			ret = wlcore_set_assoc(wl, wlvif, bss_conf,
					       sta_rate_set);
4473 4474 4475
			if (ret < 0)
				goto out;

4476 4477
			if (test_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags))
				wl12xx_set_authorized(wl, wlvif);
4478 4479
		} else {
			wlcore_unset_assoc(wl, wlvif);
4480
		}
4481 4482
	}

4483 4484 4485 4486 4487 4488 4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500
	if (changed & BSS_CHANGED_PS) {
		if ((bss_conf->ps) &&
		    test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
		    !test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
			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);
4501
			if (ret < 0)
4502 4503 4504 4505 4506 4507 4508 4509 4510 4511
				wl1271_warning("enter %s ps failed %d",
					       ps_mode_str, ret);
		} else if (!bss_conf->ps &&
			   test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
			wl1271_debug(DEBUG_PSM, "auto ps disabled");

			ret = wl1271_ps_set_mode(wl, wlvif,
						 STATION_ACTIVE_MODE);
			if (ret < 0)
				wl1271_warning("exit auto ps failed %d", ret);
4512
		}
4513 4514
	}

4515
	/* Handle new association with HT. Do this after join. */
4516
	if (sta_exists) {
4517
		bool enabled =
4518
			bss_conf->chandef.width != NL80211_CHAN_WIDTH_20_NOHT;
4519

E
Eliad Peller 已提交
4520 4521 4522 4523 4524
		ret = wlcore_hw_set_peer_cap(wl,
					     &sta_ht_cap,
					     enabled,
					     wlvif->rate_set,
					     wlvif->sta.hlid);
4525 4526 4527 4528
		if (ret < 0) {
			wl1271_warning("Set ht cap failed %d", ret);
			goto out;

4529
		}
4530 4531 4532 4533

		if (enabled) {
			ret = wl1271_acx_set_ht_information(wl, wlvif,
						bss_conf->ht_operation_mode);
4534
			if (ret < 0) {
4535
				wl1271_warning("Set ht information failed %d",
4536 4537 4538 4539 4540 4541
					       ret);
				goto out;
			}
		}
	}

4542 4543 4544 4545 4546 4547 4548
	/* 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);

4549
		if (bss_conf->arp_addr_cnt == 1 && bss_conf->assoc) {
4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560 4561 4562 4563 4564 4565 4566 4567 4568 4569 4570 4571 4572 4573 4574 4575
			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;
	}

4576 4577 4578 4579 4580 4581 4582 4583 4584 4585
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 已提交
4586 4587
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
	bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
4588 4589
	int ret;

4590 4591
	wl1271_debug(DEBUG_MAC80211, "mac80211 bss info role %d changed 0x%x",
		     wlvif->role_id, (int)changed);
4592

4593 4594 4595 4596 4597
	/*
	 * make sure to cancel pending disconnections if our association
	 * state changed
	 */
	if (!is_ap && (changed & BSS_CHANGED_ASSOC))
4598
		cancel_delayed_work_sync(&wlvif->connection_loss_work);
4599

E
Eliad Peller 已提交
4600 4601 4602 4603
	if (is_ap && (changed & BSS_CHANGED_BEACON_ENABLED) &&
	    !bss_conf->enable_beacon)
		wl1271_tx_flush(wl);

4604 4605
	mutex_lock(&wl->mutex);

4606
	if (unlikely(wl->state != WLCORE_STATE_ON))
4607 4608
		goto out;

4609 4610 4611
	if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)))
		goto out;

4612
	ret = wl1271_ps_elp_wakeup(wl);
4613 4614 4615
	if (ret < 0)
		goto out;

A
Alex Gal 已提交
4616 4617 4618 4619 4620 4621 4622 4623 4624 4625
	if ((changed & BSS_CHANGED_TXPOWER) &&
	    bss_conf->txpower != wlvif->power_level) {

		ret = wl1271_acx_tx_power(wl, wlvif, bss_conf->txpower);
		if (ret < 0)
			goto out;

		wlvif->power_level = bss_conf->txpower;
	}

4626 4627 4628 4629 4630
	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 已提交
4631 4632 4633 4634 4635 4636
	wl1271_ps_elp_sleep(wl);

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

E
Eliad Peller 已提交
4637 4638 4639 4640
static int wlcore_op_add_chanctx(struct ieee80211_hw *hw,
				 struct ieee80211_chanctx_conf *ctx)
{
	wl1271_debug(DEBUG_MAC80211, "mac80211 add chanctx %d (type %d)",
4641 4642
		     ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
		     cfg80211_get_chandef_type(&ctx->def));
E
Eliad Peller 已提交
4643 4644 4645 4646 4647 4648 4649
	return 0;
}

static void wlcore_op_remove_chanctx(struct ieee80211_hw *hw,
				     struct ieee80211_chanctx_conf *ctx)
{
	wl1271_debug(DEBUG_MAC80211, "mac80211 remove chanctx %d (type %d)",
4650 4651
		     ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
		     cfg80211_get_chandef_type(&ctx->def));
E
Eliad Peller 已提交
4652 4653 4654 4655 4656 4657
}

static void wlcore_op_change_chanctx(struct ieee80211_hw *hw,
				     struct ieee80211_chanctx_conf *ctx,
				     u32 changed)
{
4658 4659 4660 4661 4662 4663
	struct wl1271 *wl = hw->priv;
	struct wl12xx_vif *wlvif;
	int ret;
	int channel = ieee80211_frequency_to_channel(
		ctx->def.chan->center_freq);

E
Eliad Peller 已提交
4664 4665
	wl1271_debug(DEBUG_MAC80211,
		     "mac80211 change chanctx %d (type %d) changed 0x%x",
4666 4667 4668 4669 4670 4671 4672 4673 4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684 4685 4686 4687 4688 4689 4690 4691 4692 4693 4694 4695 4696 4697
		     channel, cfg80211_get_chandef_type(&ctx->def), changed);

	mutex_lock(&wl->mutex);

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

	wl12xx_for_each_wlvif(wl, wlvif) {
		struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);

		rcu_read_lock();
		if (rcu_access_pointer(vif->chanctx_conf) != ctx) {
			rcu_read_unlock();
			continue;
		}
		rcu_read_unlock();

		/* start radar if needed */
		if (changed & IEEE80211_CHANCTX_CHANGE_RADAR &&
		    wlvif->bss_type == BSS_TYPE_AP_BSS &&
		    ctx->radar_enabled && !wlvif->radar_enabled &&
		    ctx->def.chan->dfs_state == NL80211_DFS_USABLE) {
			wl1271_debug(DEBUG_MAC80211, "Start radar detection");
			wlcore_hw_set_cac(wl, wlvif, true);
			wlvif->radar_enabled = true;
		}
	}

	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
E
Eliad Peller 已提交
4698 4699 4700 4701 4702 4703 4704 4705 4706
}

static int wlcore_op_assign_vif_chanctx(struct ieee80211_hw *hw,
					struct ieee80211_vif *vif,
					struct ieee80211_chanctx_conf *ctx)
{
	struct wl1271 *wl = hw->priv;
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
	int channel = ieee80211_frequency_to_channel(
4707
		ctx->def.chan->center_freq);
4708
	int ret = -EINVAL;
E
Eliad Peller 已提交
4709 4710

	wl1271_debug(DEBUG_MAC80211,
4711 4712 4713 4714
		     "mac80211 assign chanctx (role %d) %d (type %d) (radar %d dfs_state %d)",
		     wlvif->role_id, channel,
		     cfg80211_get_chandef_type(&ctx->def),
		     ctx->radar_enabled, ctx->def.chan->dfs_state);
E
Eliad Peller 已提交
4715 4716 4717

	mutex_lock(&wl->mutex);

4718 4719 4720 4721 4722 4723 4724 4725 4726 4727
	if (unlikely(wl->state != WLCORE_STATE_ON))
		goto out;

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

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

4728
	wlvif->band = ctx->def.chan->band;
E
Eliad Peller 已提交
4729
	wlvif->channel = channel;
4730
	wlvif->channel_type = cfg80211_get_chandef_type(&ctx->def);
E
Eliad Peller 已提交
4731 4732 4733 4734

	/* update default rates according to the band */
	wl1271_set_band_rate(wl, wlvif);

4735 4736 4737 4738 4739 4740 4741 4742 4743
	if (ctx->radar_enabled &&
	    ctx->def.chan->dfs_state == NL80211_DFS_USABLE) {
		wl1271_debug(DEBUG_MAC80211, "Start radar detection");
		wlcore_hw_set_cac(wl, wlvif, true);
		wlvif->radar_enabled = true;
	}

	wl1271_ps_elp_sleep(wl);
out:
E
Eliad Peller 已提交
4744 4745 4746 4747 4748 4749 4750 4751 4752 4753 4754
	mutex_unlock(&wl->mutex);

	return 0;
}

static void wlcore_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
					   struct ieee80211_vif *vif,
					   struct ieee80211_chanctx_conf *ctx)
{
	struct wl1271 *wl = hw->priv;
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4755
	int ret;
E
Eliad Peller 已提交
4756 4757 4758 4759

	wl1271_debug(DEBUG_MAC80211,
		     "mac80211 unassign chanctx (role %d) %d (type %d)",
		     wlvif->role_id,
4760 4761
		     ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
		     cfg80211_get_chandef_type(&ctx->def));
E
Eliad Peller 已提交
4762 4763

	wl1271_tx_flush(wl);
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

	mutex_lock(&wl->mutex);

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

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

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

	if (wlvif->radar_enabled) {
		wl1271_debug(DEBUG_MAC80211, "Stop radar detection");
		wlcore_hw_set_cac(wl, wlvif, false);
		wlvif->radar_enabled = false;
	}

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

static int __wlcore_switch_vif_chan(struct wl1271 *wl,
				    struct wl12xx_vif *wlvif,
				    struct ieee80211_chanctx_conf *new_ctx)
{
	int channel = ieee80211_frequency_to_channel(
		new_ctx->def.chan->center_freq);

	wl1271_debug(DEBUG_MAC80211,
		     "switch vif (role %d) %d -> %d chan_type: %d",
		     wlvif->role_id, wlvif->channel, channel,
		     cfg80211_get_chandef_type(&new_ctx->def));

	if (WARN_ON_ONCE(wlvif->bss_type != BSS_TYPE_AP_BSS))
		return 0;

4803 4804
	WARN_ON(!test_bit(WLVIF_FLAG_BEACON_DISABLED, &wlvif->flags));

4805 4806 4807 4808 4809 4810 4811 4812 4813 4814 4815 4816 4817 4818 4819 4820 4821 4822 4823 4824 4825 4826 4827 4828 4829 4830 4831 4832 4833 4834 4835 4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849 4850 4851 4852 4853 4854 4855 4856
	if (wlvif->radar_enabled) {
		wl1271_debug(DEBUG_MAC80211, "Stop radar detection");
		wlcore_hw_set_cac(wl, wlvif, false);
		wlvif->radar_enabled = false;
	}

	wlvif->band = new_ctx->def.chan->band;
	wlvif->channel = channel;
	wlvif->channel_type = cfg80211_get_chandef_type(&new_ctx->def);

	/* start radar if needed */
	if (new_ctx->radar_enabled) {
		wl1271_debug(DEBUG_MAC80211, "Start radar detection");
		wlcore_hw_set_cac(wl, wlvif, true);
		wlvif->radar_enabled = true;
	}

	return 0;
}

static int
wlcore_op_switch_vif_chanctx(struct ieee80211_hw *hw,
			     struct ieee80211_vif_chanctx_switch *vifs,
			     int n_vifs,
			     enum ieee80211_chanctx_switch_mode mode)
{
	struct wl1271 *wl = hw->priv;
	int i, ret;

	wl1271_debug(DEBUG_MAC80211,
		     "mac80211 switch chanctx n_vifs %d mode %d",
		     n_vifs, mode);

	mutex_lock(&wl->mutex);

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

	for (i = 0; i < n_vifs; i++) {
		struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vifs[i].vif);

		ret = __wlcore_switch_vif_chan(wl, wlvif, vifs[i].new_ctx);
		if (ret)
			goto out_sleep;
	}
out_sleep:
	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);

	return 0;
E
Eliad Peller 已提交
4857 4858
}

4859 4860
static int wl1271_op_conf_tx(struct ieee80211_hw *hw,
			     struct ieee80211_vif *vif, u16 queue,
K
Kalle Valo 已提交
4861 4862 4863
			     const struct ieee80211_tx_queue_params *params)
{
	struct wl1271 *wl = hw->priv;
E
Eliad Peller 已提交
4864
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
K
Kalle Valo 已提交
4865
	u8 ps_scheme;
4866
	int ret = 0;
K
Kalle Valo 已提交
4867

E
Eliad Peller 已提交
4868 4869 4870
	if (wlcore_is_p2p_mgmt(wlvif))
		return 0;

K
Kalle Valo 已提交
4871 4872 4873 4874
	mutex_lock(&wl->mutex);

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

K
Kalle Valo 已提交
4875 4876 4877 4878 4879
	if (params->uapsd)
		ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
	else
		ps_scheme = CONF_PS_SCHEME_LEGACY;

4880
	if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
4881
		goto out;
4882

4883 4884 4885
	ret = wl1271_ps_elp_wakeup(wl);
	if (ret < 0)
		goto out;
4886

4887 4888 4889 4890
	/*
	 * the txop is confed in units of 32us by the mac80211,
	 * we need us
	 */
E
Eliad Peller 已提交
4891
	ret = wl1271_acx_ac_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
4892 4893 4894 4895 4896
				params->cw_min, params->cw_max,
				params->aifs, params->txop << 5);
	if (ret < 0)
		goto out_sleep;

E
Eliad Peller 已提交
4897
	ret = wl1271_acx_tid_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
4898 4899 4900 4901
				 CONF_CHANNEL_TYPE_EDCF,
				 wl1271_tx_get_queue(queue),
				 ps_scheme, CONF_ACK_POLICY_LEGACY,
				 0, 0);
K
Kalle Valo 已提交
4902 4903

out_sleep:
4904
	wl1271_ps_elp_sleep(wl);
K
Kalle Valo 已提交
4905 4906 4907 4908 4909 4910 4911

out:
	mutex_unlock(&wl->mutex);

	return ret;
}

4912 4913
static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw,
			     struct ieee80211_vif *vif)
J
Juuso Oikarinen 已提交
4914 4915 4916
{

	struct wl1271 *wl = hw->priv;
4917
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
J
Juuso Oikarinen 已提交
4918 4919 4920 4921 4922 4923 4924
	u64 mactime = ULLONG_MAX;
	int ret;

	wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");

	mutex_lock(&wl->mutex);

4925
	if (unlikely(wl->state != WLCORE_STATE_ON))
4926 4927
		goto out;

4928
	ret = wl1271_ps_elp_wakeup(wl);
J
Juuso Oikarinen 已提交
4929 4930 4931
	if (ret < 0)
		goto out;

4932
	ret = wl12xx_acx_tsf_info(wl, wlvif, &mactime);
J
Juuso Oikarinen 已提交
4933 4934 4935 4936 4937 4938 4939 4940 4941 4942
	if (ret < 0)
		goto out_sleep;

out_sleep:
	wl1271_ps_elp_sleep(wl);

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

4944 4945 4946 4947
static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
				struct survey_info *survey)
{
	struct ieee80211_conf *conf = &hw->conf;
4948

4949 4950
	if (idx != 0)
		return -ENOENT;
4951

4952
	survey->channel = conf->chandef.chan;
4953
	survey->filled = 0;
4954 4955 4956
	return 0;
}

4957
static int wl1271_allocate_sta(struct wl1271 *wl,
4958 4959
			     struct wl12xx_vif *wlvif,
			     struct ieee80211_sta *sta)
4960 4961
{
	struct wl1271_station *wl_sta;
4962
	int ret;
4963

4964

4965
	if (wl->active_sta_count >= wl->max_ap_stations) {
4966 4967 4968 4969 4970
		wl1271_warning("could not allocate HLID - too much stations");
		return -EBUSY;
	}

	wl_sta = (struct wl1271_station *)sta->drv_priv;
4971 4972 4973 4974 4975 4976
	ret = wl12xx_allocate_link(wl, wlvif, &wl_sta->hlid);
	if (ret < 0) {
		wl1271_warning("could not allocate HLID - too many links");
		return -EBUSY;
	}

4977 4978 4979
	/* use the previous security seq, if this is a recovery/resume */
	wl->links[wl_sta->hlid].total_freed_pkts = wl_sta->total_freed_pkts;

4980
	set_bit(wl_sta->hlid, wlvif->ap.sta_hlid_map);
4981
	memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
4982
	wl->active_sta_count++;
4983 4984 4985
	return 0;
}

4986
void wl1271_free_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 hlid)
4987
{
4988
	if (!test_bit(hlid, wlvif->ap.sta_hlid_map))
4989 4990
		return;

4991
	clear_bit(hlid, wlvif->ap.sta_hlid_map);
4992
	__clear_bit(hlid, &wl->ap_ps_map);
4993
	__clear_bit(hlid, &wl->ap_fw_ps_map);
4994 4995 4996 4997 4998

	/*
	 * save the last used PN in the private part of iee80211_sta,
	 * in case of recovery/suspend
	 */
4999
	wlcore_save_freed_pkts_addr(wl, wlvif, hlid, wl->links[hlid].addr);
5000

5001
	wl12xx_free_link(wl, wlvif, &hlid);
5002
	wl->active_sta_count--;
A
Arik Nemtsov 已提交
5003 5004 5005 5006 5007 5008 5009

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

5012 5013 5014
static int wl12xx_sta_add(struct wl1271 *wl,
			  struct wl12xx_vif *wlvif,
			  struct ieee80211_sta *sta)
5015
{
5016
	struct wl1271_station *wl_sta;
5017 5018 5019 5020 5021
	int ret = 0;
	u8 hlid;

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

5022
	ret = wl1271_allocate_sta(wl, wlvif, sta);
5023
	if (ret < 0)
5024
		return ret;
5025

5026 5027 5028
	wl_sta = (struct wl1271_station *)sta->drv_priv;
	hlid = wl_sta->hlid;

E
Eliad Peller 已提交
5029
	ret = wl12xx_cmd_add_peer(wl, wlvif, sta, hlid);
5030
	if (ret < 0)
5031
		wl1271_free_sta(wl, wlvif, hlid);
5032

5033 5034
	return ret;
}
5035

5036 5037 5038 5039 5040 5041
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;
5042

5043 5044 5045 5046 5047 5048
	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;
5049

5050
	ret = wl12xx_cmd_remove_peer(wl, wlvif, wl_sta->hlid);
5051
	if (ret < 0)
5052
		return ret;
5053

5054
	wl1271_free_sta(wl, wlvif, wl_sta->hlid);
5055 5056 5057
	return ret;
}

5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070
static void wlcore_roc_if_possible(struct wl1271 *wl,
				   struct wl12xx_vif *wlvif)
{
	if (find_first_bit(wl->roc_map,
			   WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES)
		return;

	if (WARN_ON(wlvif->role_id == WL12XX_INVALID_ROLE_ID))
		return;

	wl12xx_roc(wl, wlvif, wlvif->role_id, wlvif->band, wlvif->channel);
}

5071 5072 5073 5074 5075 5076 5077 5078
/*
 * when wl_sta is NULL, we treat this call as if coming from a
 * pending auth reply.
 * wl->mutex must be taken and the FW must be awake when the call
 * takes place.
 */
void wlcore_update_inconn_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif,
			      struct wl1271_station *wl_sta, bool in_conn)
5079
{
5080 5081
	if (in_conn) {
		if (WARN_ON(wl_sta && wl_sta->in_connection))
5082
			return;
5083 5084 5085

		if (!wlvif->ap_pending_auth_reply &&
		    !wlvif->inconn_count)
5086
			wlcore_roc_if_possible(wl, wlvif);
5087 5088 5089 5090 5091 5092 5093

		if (wl_sta) {
			wl_sta->in_connection = true;
			wlvif->inconn_count++;
		} else {
			wlvif->ap_pending_auth_reply = true;
		}
5094
	} else {
5095
		if (wl_sta && !wl_sta->in_connection)
5096 5097
			return;

5098
		if (WARN_ON(!wl_sta && !wlvif->ap_pending_auth_reply))
5099 5100
			return;

5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113
		if (WARN_ON(wl_sta && !wlvif->inconn_count))
			return;

		if (wl_sta) {
			wl_sta->in_connection = false;
			wlvif->inconn_count--;
		} else {
			wlvif->ap_pending_auth_reply = false;
		}

		if (!wlvif->inconn_count && !wlvif->ap_pending_auth_reply &&
		    test_bit(wlvif->role_id, wl->roc_map))
			wl12xx_croc(wl, wlvif->role_id);
5114 5115 5116
	}
}

5117 5118 5119 5120 5121
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)
5122 5123
{
	struct wl1271_station *wl_sta;
5124 5125 5126
	bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
	bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
	int ret;
5127

5128
	wl_sta = (struct wl1271_station *)sta->drv_priv;
5129

5130 5131 5132
	/* Add station (AP mode) */
	if (is_ap &&
	    old_state == IEEE80211_STA_NOTEXIST &&
5133 5134 5135 5136
	    new_state == IEEE80211_STA_NONE) {
		ret = wl12xx_sta_add(wl, wlvif, sta);
		if (ret)
			return ret;
5137 5138

		wlcore_update_inconn_sta(wl, wlvif, wl_sta, true);
5139
	}
5140 5141 5142 5143 5144 5145 5146

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

		wlcore_update_inconn_sta(wl, wlvif, wl_sta, false);
5149
	}
5150

5151 5152 5153
	/* Authorize station (AP mode) */
	if (is_ap &&
	    new_state == IEEE80211_STA_AUTHORIZED) {
5154
		ret = wl12xx_cmd_set_peer_state(wl, wlvif, wl_sta->hlid);
5155 5156
		if (ret < 0)
			return ret;
5157

5158 5159 5160 5161 5162
		/* reconfigure rates */
		ret = wl12xx_cmd_add_peer(wl, wlvif, sta, wl_sta->hlid);
		if (ret < 0)
			return ret;

5163
		ret = wl1271_acx_set_ht_capabilities(wl, &sta->ht_cap, true,
5164
						     wl_sta->hlid);
5165 5166
		if (ret)
			return ret;
5167 5168

		wlcore_update_inconn_sta(wl, wlvif, wl_sta, false);
5169
	}
5170

5171 5172 5173 5174
	/* Authorize station */
	if (is_sta &&
	    new_state == IEEE80211_STA_AUTHORIZED) {
		set_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
5175 5176 5177
		ret = wl12xx_set_authorized(wl, wlvif);
		if (ret)
			return ret;
5178 5179 5180 5181 5182 5183
	}

	if (is_sta &&
	    old_state == IEEE80211_STA_AUTHORIZED &&
	    new_state == IEEE80211_STA_ASSOC) {
		clear_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
5184
		clear_bit(WLVIF_FLAG_STA_STATE_SENT, &wlvif->flags);
5185 5186
	}

5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201
	/* save seq number on disassoc (suspend) */
	if (is_sta &&
	    old_state == IEEE80211_STA_ASSOC &&
	    new_state == IEEE80211_STA_AUTH) {
		wlcore_save_freed_pkts(wl, wlvif, wlvif->sta.hlid, sta);
		wlvif->total_freed_pkts = 0;
	}

	/* restore seq number on assoc (resume) */
	if (is_sta &&
	    old_state == IEEE80211_STA_AUTH &&
	    new_state == IEEE80211_STA_ASSOC) {
		wlvif->total_freed_pkts = wl_sta->total_freed_pkts;
	}

5202 5203 5204 5205 5206 5207
	/* clear ROCs on failure or authorization */
	if (is_sta &&
	    (new_state == IEEE80211_STA_AUTHORIZED ||
	     new_state == IEEE80211_STA_NOTEXIST)) {
		if (test_bit(wlvif->role_id, wl->roc_map))
			wl12xx_croc(wl, wlvif->role_id);
5208 5209
	}

5210 5211 5212 5213 5214 5215 5216 5217 5218 5219
	if (is_sta &&
	    old_state == IEEE80211_STA_NOTEXIST &&
	    new_state == IEEE80211_STA_NONE) {
		if (find_first_bit(wl->roc_map,
				   WL12XX_MAX_ROLES) >= WL12XX_MAX_ROLES) {
			WARN_ON(wlvif->role_id == WL12XX_INVALID_ROLE_ID);
			wl12xx_roc(wl, wlvif, wlvif->role_id,
				   wlvif->band, wlvif->channel);
		}
	}
5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231 5232 5233 5234 5235 5236 5237
	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);

5238
	if (unlikely(wl->state != WLCORE_STATE_ON)) {
5239
		ret = -EBUSY;
5240
		goto out;
5241
	}
5242

5243
	ret = wl1271_ps_elp_wakeup(wl);
5244 5245 5246
	if (ret < 0)
		goto out;

5247
	ret = wl12xx_update_sta_state(wl, wlvif, sta, old_state, new_state);
5248 5249 5250 5251

	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
5252 5253
	if (new_state < old_state)
		return 0;
5254 5255 5256
	return ret;
}

5257 5258
static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
				  struct ieee80211_vif *vif,
5259
				  struct ieee80211_ampdu_params *params)
L
Levi, Shahar 已提交
5260 5261
{
	struct wl1271 *wl = hw->priv;
E
Eliad Peller 已提交
5262
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
L
Levi, Shahar 已提交
5263
	int ret;
5264
	u8 hlid, *ba_bitmap;
5265 5266 5267 5268
	struct ieee80211_sta *sta = params->sta;
	enum ieee80211_ampdu_mlme_action action = params->action;
	u16 tid = params->tid;
	u16 *ssn = &params->ssn;
5269 5270 5271 5272 5273 5274 5275

	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 已提交
5276 5277 5278

	mutex_lock(&wl->mutex);

5279
	if (unlikely(wl->state != WLCORE_STATE_ON)) {
L
Levi, Shahar 已提交
5280 5281 5282 5283
		ret = -EAGAIN;
		goto out;
	}

E
Eliad Peller 已提交
5284
	if (wlvif->bss_type == BSS_TYPE_STA_BSS) {
E
Eliad Peller 已提交
5285
		hlid = wlvif->sta.hlid;
E
Eliad Peller 已提交
5286
	} else if (wlvif->bss_type == BSS_TYPE_AP_BSS) {
5287 5288 5289 5290 5291 5292 5293 5294 5295
		struct wl1271_station *wl_sta;

		wl_sta = (struct wl1271_station *)sta->drv_priv;
		hlid = wl_sta->hlid;
	} else {
		ret = -EINVAL;
		goto out;
	}

5296 5297
	ba_bitmap = &wl->links[hlid].ba_bitmap;

5298
	ret = wl1271_ps_elp_wakeup(wl);
L
Levi, Shahar 已提交
5299 5300 5301
	if (ret < 0)
		goto out;

5302 5303 5304
	wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
		     tid, action);

L
Levi, Shahar 已提交
5305 5306
	switch (action) {
	case IEEE80211_AMPDU_RX_START:
E
Eliad Peller 已提交
5307
		if (!wlvif->ba_support || !wlvif->ba_allowed) {
L
Levi, Shahar 已提交
5308
			ret = -ENOTSUPP;
5309 5310 5311
			break;
		}

5312
		if (wl->ba_rx_session_count >= wl->ba_rx_session_count_max) {
5313 5314 5315 5316 5317 5318 5319 5320 5321 5322 5323 5324 5325
			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,
5326 5327 5328
				hlid,
				params->buf_size);

5329 5330 5331
		if (!ret) {
			*ba_bitmap |= BIT(tid);
			wl->ba_rx_session_count++;
L
Levi, Shahar 已提交
5332 5333 5334 5335
		}
		break;

	case IEEE80211_AMPDU_RX_STOP:
5336
		if (!(*ba_bitmap & BIT(tid))) {
5337 5338 5339 5340 5341 5342
			/*
			 * this happens on reconfig - so only output a debug
			 * message for now, and don't fail the function.
			 */
			wl1271_debug(DEBUG_MAC80211,
				     "no active RX BA session on tid: %d",
5343
				     tid);
5344
			ret = 0;
5345 5346 5347 5348
			break;
		}

		ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
5349
							 hlid, 0);
5350 5351 5352 5353
		if (!ret) {
			*ba_bitmap &= ~BIT(tid);
			wl->ba_rx_session_count--;
		}
L
Levi, Shahar 已提交
5354 5355 5356 5357 5358 5359 5360
		break;

	/*
	 * The BA initiator session management in FW independently.
	 * Falling break here on purpose for all TX APDU commands.
	 */
	case IEEE80211_AMPDU_TX_START:
5361 5362 5363
	case IEEE80211_AMPDU_TX_STOP_CONT:
	case IEEE80211_AMPDU_TX_STOP_FLUSH:
	case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
L
Levi, Shahar 已提交
5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380
	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;
}

5381 5382 5383 5384
static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw,
				   struct ieee80211_vif *vif,
				   const struct cfg80211_bitrate_mask *mask)
{
5385
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5386
	struct wl1271 *wl = hw->priv;
5387
	int i, ret = 0;
5388 5389 5390 5391 5392 5393 5394

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

5395
	for (i = 0; i < WLCORE_NUM_BANDS; i++)
5396
		wlvif->bitrate_masks[i] =
5397 5398 5399
			wl1271_tx_enabled_rates_get(wl,
						    mask->control[i].legacy,
						    i);
5400

5401
	if (unlikely(wl->state != WLCORE_STATE_ON))
5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418
		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:
5419 5420
	mutex_unlock(&wl->mutex);

5421
	return ret;
5422 5423
}

5424
static void wl12xx_op_channel_switch(struct ieee80211_hw *hw,
5425
				     struct ieee80211_vif *vif,
5426 5427 5428
				     struct ieee80211_channel_switch *ch_switch)
{
	struct wl1271 *wl = hw->priv;
5429
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5430 5431 5432 5433
	int ret;

	wl1271_debug(DEBUG_MAC80211, "mac80211 channel switch");

5434 5435
	wl1271_tx_flush(wl);

5436 5437
	mutex_lock(&wl->mutex);

5438
	if (unlikely(wl->state == WLCORE_STATE_OFF)) {
5439
		if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
5440 5441
			ieee80211_chswitch_done(vif, false);
		goto out;
5442 5443
	} else if (unlikely(wl->state != WLCORE_STATE_ON)) {
		goto out;
5444 5445 5446 5447 5448 5449
	}

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

5450
	/* TODO: change mac80211 to pass vif as param */
5451

5452 5453
	if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
		unsigned long delay_usec;
5454

5455
		ret = wl->ops->channel_switch(wl, wlvif, ch_switch);
5456 5457
		if (ret)
			goto out_sleep;
5458

5459 5460 5461 5462
		set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags);

		/* indicate failure 5 seconds after channel switch time */
		delay_usec = ieee80211_tu_to_usec(wlvif->beacon_int) *
5463
			ch_switch->count;
5464
		ieee80211_queue_delayed_work(hw, &wlvif->channel_switch_work,
5465 5466
					     usecs_to_jiffies(delay_usec) +
					     msecs_to_jiffies(5000));
5467
	}
5468

5469
out_sleep:
5470 5471 5472 5473 5474 5475
	wl1271_ps_elp_sleep(wl);

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

E
Eliad Peller 已提交
5476 5477 5478 5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549 5550 5551 5552
static const void *wlcore_get_beacon_ie(struct wl1271 *wl,
					struct wl12xx_vif *wlvif,
					u8 eid)
{
	int ieoffset = offsetof(struct ieee80211_mgmt, u.beacon.variable);
	struct sk_buff *beacon =
		ieee80211_beacon_get(wl->hw, wl12xx_wlvif_to_vif(wlvif));

	if (!beacon)
		return NULL;

	return cfg80211_find_ie(eid,
				beacon->data + ieoffset,
				beacon->len - ieoffset);
}

static int wlcore_get_csa_count(struct wl1271 *wl, struct wl12xx_vif *wlvif,
				u8 *csa_count)
{
	const u8 *ie;
	const struct ieee80211_channel_sw_ie *ie_csa;

	ie = wlcore_get_beacon_ie(wl, wlvif, WLAN_EID_CHANNEL_SWITCH);
	if (!ie)
		return -EINVAL;

	ie_csa = (struct ieee80211_channel_sw_ie *)&ie[2];
	*csa_count = ie_csa->count;

	return 0;
}

static void wlcore_op_channel_switch_beacon(struct ieee80211_hw *hw,
					    struct ieee80211_vif *vif,
					    struct cfg80211_chan_def *chandef)
{
	struct wl1271 *wl = hw->priv;
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
	struct ieee80211_channel_switch ch_switch = {
		.block_tx = true,
		.chandef = *chandef,
	};
	int ret;

	wl1271_debug(DEBUG_MAC80211,
		     "mac80211 channel switch beacon (role %d)",
		     wlvif->role_id);

	ret = wlcore_get_csa_count(wl, wlvif, &ch_switch.count);
	if (ret < 0) {
		wl1271_error("error getting beacon (for CSA counter)");
		return;
	}

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state != WLCORE_STATE_ON)) {
		ret = -EBUSY;
		goto out;
	}

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

	ret = wl->ops->channel_switch(wl, wlvif, &ch_switch);
	if (ret)
		goto out_sleep;

	set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags);

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

5553 5554
static void wlcore_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
			    u32 queues, bool drop)
E
Eliad Peller 已提交
5555 5556 5557 5558 5559 5560
{
	struct wl1271 *wl = hw->priv;

	wl1271_tx_flush(wl);
}

5561 5562 5563
static int wlcore_op_remain_on_channel(struct ieee80211_hw *hw,
				       struct ieee80211_vif *vif,
				       struct ieee80211_channel *chan,
5564 5565
				       int duration,
				       enum ieee80211_roc_type type)
5566 5567 5568
{
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
	struct wl1271 *wl = hw->priv;
5569
	int channel, active_roc, ret = 0;
5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581

	channel = ieee80211_frequency_to_channel(chan->center_freq);

	wl1271_debug(DEBUG_MAC80211, "mac80211 roc %d (%d)",
		     channel, wlvif->role_id);

	mutex_lock(&wl->mutex);

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

	/* return EBUSY if we can't ROC right now */
5582 5583 5584
	active_roc = find_first_bit(wl->roc_map, WL12XX_MAX_ROLES);
	if (wl->roc_vif || active_roc < WL12XX_MAX_ROLES) {
		wl1271_warning("active roc on role %d", active_roc);
5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602 5603 5604 5605 5606 5607 5608 5609 5610 5611 5612 5613 5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661
		ret = -EBUSY;
		goto out;
	}

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

	ret = wl12xx_start_dev(wl, wlvif, chan->band, channel);
	if (ret < 0)
		goto out_sleep;

	wl->roc_vif = vif;
	ieee80211_queue_delayed_work(hw, &wl->roc_complete_work,
				     msecs_to_jiffies(duration));
out_sleep:
	wl1271_ps_elp_sleep(wl);
out:
	mutex_unlock(&wl->mutex);
	return ret;
}

static int __wlcore_roc_completed(struct wl1271 *wl)
{
	struct wl12xx_vif *wlvif;
	int ret;

	/* already completed */
	if (unlikely(!wl->roc_vif))
		return 0;

	wlvif = wl12xx_vif_to_data(wl->roc_vif);

	if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
		return -EBUSY;

	ret = wl12xx_stop_dev(wl, wlvif);
	if (ret < 0)
		return ret;

	wl->roc_vif = NULL;

	return 0;
}

static int wlcore_roc_completed(struct wl1271 *wl)
{
	int ret;

	wl1271_debug(DEBUG_MAC80211, "roc complete");

	mutex_lock(&wl->mutex);

	if (unlikely(wl->state != WLCORE_STATE_ON)) {
		ret = -EBUSY;
		goto out;
	}

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

	ret = __wlcore_roc_completed(wl);

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

	return ret;
}

static void wlcore_roc_complete_work(struct work_struct *work)
{
	struct delayed_work *dwork;
	struct wl1271 *wl;
	int ret;

G
Geliang Tang 已提交
5662
	dwork = to_delayed_work(work);
5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688
	wl = container_of(dwork, struct wl1271, roc_complete_work);

	ret = wlcore_roc_completed(wl);
	if (!ret)
		ieee80211_remain_on_channel_expired(wl->hw);
}

static int wlcore_op_cancel_remain_on_channel(struct ieee80211_hw *hw)
{
	struct wl1271 *wl = hw->priv;

	wl1271_debug(DEBUG_MAC80211, "mac80211 croc");

	/* TODO: per-vif */
	wl1271_tx_flush(wl);

	/*
	 * we can't just flush_work here, because it might deadlock
	 * (as we might get called from the same workqueue)
	 */
	cancel_delayed_work_sync(&wl->roc_complete_work);
	wlcore_roc_completed(wl);

	return 0;
}

5689 5690 5691 5692 5693 5694 5695
static void wlcore_op_sta_rc_update(struct ieee80211_hw *hw,
				    struct ieee80211_vif *vif,
				    struct ieee80211_sta *sta,
				    u32 changed)
{
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);

5696 5697 5698 5699 5700 5701 5702
	wl1271_debug(DEBUG_MAC80211, "mac80211 sta_rc_update");

	if (!(changed & IEEE80211_RC_BW_CHANGED))
		return;

	/* this callback is atomic, so schedule a new work */
	wlvif->rc_update_bw = sta->bandwidth;
5703
	memcpy(&wlvif->rc_ht_cap, &sta->ht_cap, sizeof(sta->ht_cap));
5704
	ieee80211_queue_work(hw, &wlvif->rc_update_work);
5705 5706
}

5707 5708 5709 5710
static void wlcore_op_sta_statistics(struct ieee80211_hw *hw,
				     struct ieee80211_vif *vif,
				     struct ieee80211_sta *sta,
				     struct station_info *sinfo)
5711 5712 5713
{
	struct wl1271 *wl = hw->priv;
	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5714 5715
	s8 rssi_dbm;
	int ret;
5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727

	wl1271_debug(DEBUG_MAC80211, "mac80211 get_rssi");

	mutex_lock(&wl->mutex);

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

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

5728
	ret = wlcore_acx_average_rssi(wl, wlvif, &rssi_dbm);
5729 5730 5731
	if (ret < 0)
		goto out_sleep;

5732
	sinfo->filled |= BIT(NL80211_STA_INFO_SIGNAL);
5733 5734
	sinfo->signal = rssi_dbm;

5735 5736 5737 5738 5739 5740 5741
out_sleep:
	wl1271_ps_elp_sleep(wl);

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

5742 5743
static u32 wlcore_op_get_expected_throughput(struct ieee80211_hw *hw,
					     struct ieee80211_sta *sta)
5744 5745
{
	struct wl1271_station *wl_sta = (struct wl1271_station *)sta->drv_priv;
5746
	struct wl1271 *wl = hw->priv;
5747 5748 5749 5750 5751 5752
	u8 hlid = wl_sta->hlid;

	/* return in units of Kbps */
	return (wl->links[hlid].fw_rate_mbps * 1000);
}

5753 5754 5755 5756 5757 5758 5759
static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
{
	struct wl1271 *wl = hw->priv;
	bool ret = false;

	mutex_lock(&wl->mutex);

5760
	if (unlikely(wl->state != WLCORE_STATE_ON))
5761 5762 5763
		goto out;

	/* packets are considered pending if in the TX queue or the FW */
5764
	ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
5765 5766 5767 5768 5769 5770
out:
	mutex_unlock(&wl->mutex);

	return ret;
}

L
Luciano Coelho 已提交
5771 5772 5773
/* can't be const, mac80211 writes to this */
static struct ieee80211_rate wl1271_rates[] = {
	{ .bitrate = 10,
5774 5775
	  .hw_value = CONF_HW_BIT_RATE_1MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
L
Luciano Coelho 已提交
5776
	{ .bitrate = 20,
5777 5778
	  .hw_value = CONF_HW_BIT_RATE_2MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
L
Luciano Coelho 已提交
5779 5780
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 55,
5781 5782
	  .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
L
Luciano Coelho 已提交
5783 5784
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 110,
5785 5786
	  .hw_value = CONF_HW_BIT_RATE_11MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
L
Luciano Coelho 已提交
5787 5788
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
	{ .bitrate = 60,
5789 5790
	  .hw_value = CONF_HW_BIT_RATE_6MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
L
Luciano Coelho 已提交
5791
	{ .bitrate = 90,
5792 5793
	  .hw_value = CONF_HW_BIT_RATE_9MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
L
Luciano Coelho 已提交
5794
	{ .bitrate = 120,
5795 5796
	  .hw_value = CONF_HW_BIT_RATE_12MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
L
Luciano Coelho 已提交
5797
	{ .bitrate = 180,
5798 5799
	  .hw_value = CONF_HW_BIT_RATE_18MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
L
Luciano Coelho 已提交
5800
	{ .bitrate = 240,
5801 5802
	  .hw_value = CONF_HW_BIT_RATE_24MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
L
Luciano Coelho 已提交
5803
	{ .bitrate = 360,
5804 5805
	 .hw_value = CONF_HW_BIT_RATE_36MBPS,
	 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
L
Luciano Coelho 已提交
5806
	{ .bitrate = 480,
5807 5808
	  .hw_value = CONF_HW_BIT_RATE_48MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
L
Luciano Coelho 已提交
5809
	{ .bitrate = 540,
5810 5811
	  .hw_value = CONF_HW_BIT_RATE_54MBPS,
	  .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
L
Luciano Coelho 已提交
5812 5813
};

5814
/* can't be const, mac80211 writes to this */
L
Luciano Coelho 已提交
5815
static struct ieee80211_channel wl1271_channels[] = {
5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829
	{ .hw_value = 1, .center_freq = 2412, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 2, .center_freq = 2417, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 3, .center_freq = 2422, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 4, .center_freq = 2427, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 5, .center_freq = 2432, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 6, .center_freq = 2437, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 7, .center_freq = 2442, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 8, .center_freq = 2447, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 9, .center_freq = 2452, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 10, .center_freq = 2457, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 11, .center_freq = 2462, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 12, .center_freq = 2467, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 13, .center_freq = 2472, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 14, .center_freq = 2484, .max_power = WLCORE_MAX_TXPWR },
L
Luciano Coelho 已提交
5830 5831 5832 5833 5834 5835 5836 5837 5838 5839
};

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

5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867
/* 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, },
};

5868
/* 5 GHz band channels for WL1273 */
5869
static struct ieee80211_channel wl1271_channels_5ghz[] = {
5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900
	{ .hw_value = 8, .center_freq = 5040, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 12, .center_freq = 5060, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 16, .center_freq = 5080, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 34, .center_freq = 5170, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 36, .center_freq = 5180, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 38, .center_freq = 5190, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 40, .center_freq = 5200, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 42, .center_freq = 5210, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 44, .center_freq = 5220, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 46, .center_freq = 5230, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 48, .center_freq = 5240, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 52, .center_freq = 5260, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 56, .center_freq = 5280, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 60, .center_freq = 5300, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 64, .center_freq = 5320, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 100, .center_freq = 5500, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 104, .center_freq = 5520, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 108, .center_freq = 5540, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 112, .center_freq = 5560, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 116, .center_freq = 5580, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 120, .center_freq = 5600, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 124, .center_freq = 5620, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 128, .center_freq = 5640, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 132, .center_freq = 5660, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 136, .center_freq = 5680, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 140, .center_freq = 5700, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 149, .center_freq = 5745, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 153, .center_freq = 5765, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 157, .center_freq = 5785, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 161, .center_freq = 5805, .max_power = WLCORE_MAX_TXPWR },
	{ .hw_value = 165, .center_freq = 5825, .max_power = WLCORE_MAX_TXPWR },
5901 5902 5903 5904 5905 5906 5907
};

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),
5908 5909
};

L
Luciano Coelho 已提交
5910 5911
static const struct ieee80211_ops wl1271_ops = {
	.start = wl1271_op_start,
5912
	.stop = wlcore_op_stop,
L
Luciano Coelho 已提交
5913 5914
	.add_interface = wl1271_op_add_interface,
	.remove_interface = wl1271_op_remove_interface,
E
Eliad Peller 已提交
5915
	.change_interface = wl12xx_op_change_interface,
5916
#ifdef CONFIG_PM
5917 5918
	.suspend = wl1271_op_suspend,
	.resume = wl1271_op_resume,
5919
#endif
L
Luciano Coelho 已提交
5920
	.config = wl1271_op_config,
5921
	.prepare_multicast = wl1271_op_prepare_multicast,
L
Luciano Coelho 已提交
5922 5923
	.configure_filter = wl1271_op_configure_filter,
	.tx = wl1271_op_tx,
5924
	.set_key = wlcore_op_set_key,
L
Luciano Coelho 已提交
5925
	.hw_scan = wl1271_op_hw_scan,
5926
	.cancel_hw_scan = wl1271_op_cancel_hw_scan,
5927 5928
	.sched_scan_start = wl1271_op_sched_scan_start,
	.sched_scan_stop = wl1271_op_sched_scan_stop,
L
Luciano Coelho 已提交
5929
	.bss_info_changed = wl1271_op_bss_info_changed,
5930
	.set_frag_threshold = wl1271_op_set_frag_threshold,
L
Luciano Coelho 已提交
5931
	.set_rts_threshold = wl1271_op_set_rts_threshold,
K
Kalle Valo 已提交
5932
	.conf_tx = wl1271_op_conf_tx,
J
Juuso Oikarinen 已提交
5933
	.get_tsf = wl1271_op_get_tsf,
5934
	.get_survey = wl1271_op_get_survey,
5935
	.sta_state = wl12xx_op_sta_state,
L
Levi, Shahar 已提交
5936
	.ampdu_action = wl1271_op_ampdu_action,
5937
	.tx_frames_pending = wl1271_tx_frames_pending,
5938
	.set_bitrate_mask = wl12xx_set_bitrate_mask,
5939
	.set_default_unicast_key = wl1271_op_set_default_key_idx,
5940
	.channel_switch = wl12xx_op_channel_switch,
E
Eliad Peller 已提交
5941
	.channel_switch_beacon = wlcore_op_channel_switch_beacon,
E
Eliad Peller 已提交
5942
	.flush = wlcore_op_flush,
5943 5944
	.remain_on_channel = wlcore_op_remain_on_channel,
	.cancel_remain_on_channel = wlcore_op_cancel_remain_on_channel,
E
Eliad Peller 已提交
5945 5946 5947 5948 5949
	.add_chanctx = wlcore_op_add_chanctx,
	.remove_chanctx = wlcore_op_remove_chanctx,
	.change_chanctx = wlcore_op_change_chanctx,
	.assign_vif_chanctx = wlcore_op_assign_vif_chanctx,
	.unassign_vif_chanctx = wlcore_op_unassign_vif_chanctx,
5950
	.switch_vif_chanctx = wlcore_op_switch_vif_chanctx,
5951
	.sta_rc_update = wlcore_op_sta_rc_update,
5952
	.sta_statistics = wlcore_op_sta_statistics,
5953
	.get_expected_throughput = wlcore_op_get_expected_throughput,
K
Kalle Valo 已提交
5954
	CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
L
Luciano Coelho 已提交
5955 5956
};

5957

5958
u8 wlcore_rate_to_idx(struct wl1271 *wl, u8 rate, enum nl80211_band band)
5959 5960 5961
{
	u8 idx;

5962
	BUG_ON(band >= 2);
5963

5964
	if (unlikely(rate >= wl->hw_tx_rate_tbl_size)) {
5965 5966 5967 5968
		wl1271_error("Illegal RX rate from HW: %d", rate);
		return 0;
	}

5969
	idx = wl->band_rate_to_idx[band][rate];
5970 5971 5972 5973 5974 5975 5976 5977
	if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
		wl1271_error("Unsupported RX rate from HW: %d", rate);
		return 0;
	}

	return idx;
}

5978
static void wl12xx_derive_mac_addresses(struct wl1271 *wl, u32 oui, u32 nic)
5979 5980 5981
{
	int i;

5982 5983
	wl1271_debug(DEBUG_PROBE, "base address: oui %06x nic %06x",
		     oui, nic);
5984

5985
	if (nic + WLCORE_NUM_MAC_ADDRESSES - wl->num_mac_addr > 0xffffff)
5986 5987
		wl1271_warning("NIC part of the MAC address wraps around!");

5988
	for (i = 0; i < wl->num_mac_addr; i++) {
5989 5990 5991 5992 5993 5994 5995 5996 5997
		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++;
	}

5998 5999 6000 6001 6002 6003 6004 6005 6006 6007 6008 6009
	/* we may be one address short at the most */
	WARN_ON(wl->num_mac_addr + 1 < WLCORE_NUM_MAC_ADDRESSES);

	/*
	 * turn on the LAA bit in the first address and use it as
	 * the last address.
	 */
	if (wl->num_mac_addr < WLCORE_NUM_MAC_ADDRESSES) {
		int idx = WLCORE_NUM_MAC_ADDRESSES - 1;
		memcpy(&wl->addresses[idx], &wl->addresses[0],
		       sizeof(wl->addresses[0]));
		/* LAA bit */
E
Eliad Peller 已提交
6010
		wl->addresses[idx].addr[0] |= BIT(1);
6011 6012 6013
	}

	wl->hw->wiphy->n_addresses = WLCORE_NUM_MAC_ADDRESSES;
6014 6015 6016
	wl->hw->wiphy->addresses = wl->addresses;
}

6017 6018 6019 6020
static int wl12xx_get_hw_info(struct wl1271 *wl)
{
	int ret;

6021 6022 6023
	ret = wlcore_read_reg(wl, REG_CHIP_ID_B, &wl->chip.id);
	if (ret < 0)
		goto out;
6024

6025 6026
	wl->fuse_oui_addr = 0;
	wl->fuse_nic_addr = 0;
6027

6028 6029 6030
	ret = wl->ops->get_pg_ver(wl, &wl->hw_pg_ver);
	if (ret < 0)
		goto out;
6031

6032
	if (wl->ops->get_mac)
6033
		ret = wl->ops->get_mac(wl);
6034

6035 6036 6037 6038
out:
	return ret;
}

F
Felipe Balbi 已提交
6039
static int wl1271_register_hw(struct wl1271 *wl)
L
Luciano Coelho 已提交
6040 6041
{
	int ret;
6042
	u32 oui_addr = 0, nic_addr = 0;
6043 6044
	struct platform_device *pdev = wl->pdev;
	struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev);
L
Luciano Coelho 已提交
6045 6046 6047 6048

	if (wl->mac80211_registered)
		return 0;

6049
	if (wl->nvs_len >= 12) {
6050 6051 6052 6053 6054
		/* 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;
6055

6056 6057 6058 6059 6060 6061 6062 6063 6064 6065 6066
		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;
6067 6068
	}

6069 6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086 6087 6088 6089
	if (oui_addr == 0xdeadbe && nic_addr == 0xef0000) {
		wl1271_warning("Detected unconfigured mac address in nvs, derive from fuse instead.\n");
		if (!strcmp(pdev_data->family->name, "wl18xx")) {
			wl1271_warning("This default nvs file can be removed from the file system\n");
		} else {
			wl1271_warning("Your device performance is not optimized.\n");
			wl1271_warning("Please use the calibrator tool to configure your device.\n");
		}

		if (wl->fuse_oui_addr == 0 && wl->fuse_nic_addr == 0) {
			wl1271_warning("Fuse mac address is zero. using random mac\n");
			/* Use TI oui and a random nic */
			oui_addr = WLCORE_TI_OUI_ADDRESS;
			nic_addr = get_random_int();
		} else {
			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;
		}
	}

6090
	wl12xx_derive_mac_addresses(wl, oui_addr, nic_addr);
L
Luciano Coelho 已提交
6091 6092 6093 6094

	ret = ieee80211_register_hw(wl->hw);
	if (ret < 0) {
		wl1271_error("unable to register mac80211 hw: %d", ret);
6095
		goto out;
L
Luciano Coelho 已提交
6096 6097 6098 6099
	}

	wl->mac80211_registered = true;

6100 6101
	wl1271_debugfs_init(wl);

L
Luciano Coelho 已提交
6102 6103
	wl1271_notice("loaded");

6104 6105
out:
	return ret;
L
Luciano Coelho 已提交
6106 6107
}

F
Felipe Balbi 已提交
6108
static void wl1271_unregister_hw(struct wl1271 *wl)
6109
{
6110
	if (wl->plt)
6111
		wl1271_plt_stop(wl);
6112

6113 6114 6115 6116 6117
	ieee80211_unregister_hw(wl->hw);
	wl->mac80211_registered = false;

}

F
Felipe Balbi 已提交
6118
static int wl1271_init_ieee80211(struct wl1271 *wl)
L
Luciano Coelho 已提交
6119
{
6120
	int i;
6121 6122 6123 6124 6125 6126 6127 6128
	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,
	};

6129 6130 6131 6132 6133
	/* The tx descriptor buffer */
	wl->hw->extra_tx_headroom = sizeof(struct wl1271_tx_hw_descr);

	if (wl->quirks & WLCORE_QUIRK_TKIP_HEADER_SPACE)
		wl->hw->extra_tx_headroom += WL1271_EXTRA_SPACE_TKIP;
L
Luciano Coelho 已提交
6134 6135 6136

	/* unit us */
	/* FIXME: find a proper value */
6137
	wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
L
Luciano Coelho 已提交
6138

6139 6140 6141 6142 6143 6144 6145 6146 6147 6148 6149 6150 6151
	ieee80211_hw_set(wl->hw, SUPPORT_FAST_XMIT);
	ieee80211_hw_set(wl->hw, CHANCTX_STA_CSA);
	ieee80211_hw_set(wl->hw, QUEUE_CONTROL);
	ieee80211_hw_set(wl->hw, TX_AMPDU_SETUP_IN_HW);
	ieee80211_hw_set(wl->hw, AMPDU_AGGREGATION);
	ieee80211_hw_set(wl->hw, AP_LINK_PS);
	ieee80211_hw_set(wl->hw, SPECTRUM_MGMT);
	ieee80211_hw_set(wl->hw, REPORTS_TX_ACK_STATUS);
	ieee80211_hw_set(wl->hw, CONNECTION_MONITOR);
	ieee80211_hw_set(wl->hw, HAS_RATE_CONTROL);
	ieee80211_hw_set(wl->hw, SUPPORTS_DYNAMIC_PS);
	ieee80211_hw_set(wl->hw, SIGNAL_DBM);
	ieee80211_hw_set(wl->hw, SUPPORTS_PS);
6152
	ieee80211_hw_set(wl->hw, SUPPORTS_TX_FRAG);
L
Luciano Coelho 已提交
6153

6154 6155 6156
	wl->hw->wiphy->cipher_suites = cipher_suites;
	wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);

6157
	wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
E
Eliad Peller 已提交
6158 6159 6160
					 BIT(NL80211_IFTYPE_AP) |
					 BIT(NL80211_IFTYPE_P2P_DEVICE) |
					 BIT(NL80211_IFTYPE_P2P_CLIENT) |
6161 6162 6163
#ifdef CONFIG_MAC80211_MESH
					 BIT(NL80211_IFTYPE_MESH_POINT) |
#endif
E
Eliad Peller 已提交
6164
					 BIT(NL80211_IFTYPE_P2P_GO);
6165

L
Luciano Coelho 已提交
6166
	wl->hw->wiphy->max_scan_ssids = 1;
6167 6168
	wl->hw->wiphy->max_sched_scan_ssids = 16;
	wl->hw->wiphy->max_match_sets = 16;
6169 6170 6171 6172 6173
	/*
	 * 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
	 */
6174
	wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
6175
			sizeof(struct ieee80211_header);
6176

6177
	wl->hw->wiphy->max_sched_scan_reqs = 1;
6178
	wl->hw->wiphy->max_sched_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
6179 6180
		sizeof(struct ieee80211_header);

6181
	wl->hw->wiphy->max_remain_on_channel_duration = 30000;
6182

6183
	wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD |
6184
				WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
E
Eliad Peller 已提交
6185
				WIPHY_FLAG_HAS_CHANNEL_SWITCH;
6186

J
James Minor 已提交
6187 6188
	wl->hw->wiphy->features |= NL80211_FEATURE_AP_SCAN;

6189 6190 6191 6192
	/* 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);
6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208
	/*
	* clear channel flags from the previous usage
	* and restore max_power & max_antenna_gain values.
	*/
	for (i = 0; i < ARRAY_SIZE(wl1271_channels); i++) {
		wl1271_band_2ghz.channels[i].flags = 0;
		wl1271_band_2ghz.channels[i].max_power = WLCORE_MAX_TXPWR;
		wl1271_band_2ghz.channels[i].max_antenna_gain = 0;
	}

	for (i = 0; i < ARRAY_SIZE(wl1271_channels_5ghz); i++) {
		wl1271_band_5ghz.channels[i].flags = 0;
		wl1271_band_5ghz.channels[i].max_power = WLCORE_MAX_TXPWR;
		wl1271_band_5ghz.channels[i].max_antenna_gain = 0;
	}

6209 6210 6211 6212
	/*
	 * We keep local copies of the band structs because we need to
	 * modify them on a per-device basis.
	 */
6213
	memcpy(&wl->bands[NL80211_BAND_2GHZ], &wl1271_band_2ghz,
6214
	       sizeof(wl1271_band_2ghz));
6215 6216
	memcpy(&wl->bands[NL80211_BAND_2GHZ].ht_cap,
	       &wl->ht_cap[NL80211_BAND_2GHZ],
E
Eliad Peller 已提交
6217
	       sizeof(*wl->ht_cap));
6218
	memcpy(&wl->bands[NL80211_BAND_5GHZ], &wl1271_band_5ghz,
6219
	       sizeof(wl1271_band_5ghz));
6220 6221
	memcpy(&wl->bands[NL80211_BAND_5GHZ].ht_cap,
	       &wl->ht_cap[NL80211_BAND_5GHZ],
E
Eliad Peller 已提交
6222
	       sizeof(*wl->ht_cap));
6223

6224 6225 6226 6227
	wl->hw->wiphy->bands[NL80211_BAND_2GHZ] =
		&wl->bands[NL80211_BAND_2GHZ];
	wl->hw->wiphy->bands[NL80211_BAND_5GHZ] =
		&wl->bands[NL80211_BAND_5GHZ];
6228

6229 6230 6231 6232 6233 6234 6235 6236
	/*
	 * allow 4 queues per mac address we support +
	 * 1 cab queue per mac + one global offchannel Tx queue
	 */
	wl->hw->queues = (NUM_TX_QUEUES + 1) * WLCORE_NUM_MAC_ADDRESSES + 1;

	/* the last queue is the offchannel queue */
	wl->hw->offchannel_tx_hw_queue = wl->hw->queues - 1;
J
Juuso Oikarinen 已提交
6237
	wl->hw->max_rates = 1;
K
Kalle Valo 已提交
6238

6239 6240
	wl->hw->wiphy->reg_notifier = wl1271_reg_notify;

6241 6242 6243 6244 6245 6246 6247
	/* 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;

6248
	/* allowed interface combinations */
6249 6250
	wl->hw->wiphy->iface_combinations = wl->iface_combinations;
	wl->hw->wiphy->n_iface_combinations = wl->n_iface_combinations;
6251

E
Eliad Peller 已提交
6252 6253 6254
	/* register vendor commands */
	wlcore_set_vendor_commands(wl->hw->wiphy);

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

6257
	wl->hw->sta_data_size = sizeof(struct wl1271_station);
E
Eliad Peller 已提交
6258
	wl->hw->vif_data_size = sizeof(struct wl12xx_vif);
6259

6260
	wl->hw->max_rx_aggregation_subframes = wl->conf.ht.rx_ba_win_size;
6261

L
Luciano Coelho 已提交
6262 6263 6264
	return 0;
}

6265 6266
struct ieee80211_hw *wlcore_alloc_hw(size_t priv_size, u32 aggr_buf_size,
				     u32 mbox_size)
L
Luciano Coelho 已提交
6267 6268 6269
{
	struct ieee80211_hw *hw;
	struct wl1271 *wl;
6270
	int i, j, ret;
6271
	unsigned int order;
L
Luciano Coelho 已提交
6272 6273 6274 6275

	hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
	if (!hw) {
		wl1271_error("could not alloc ieee80211_hw");
6276
		ret = -ENOMEM;
6277 6278 6279
		goto err_hw_alloc;
	}

L
Luciano Coelho 已提交
6280 6281 6282
	wl = hw->priv;
	memset(wl, 0, sizeof(*wl));

6283 6284 6285 6286 6287 6288 6289
	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 已提交
6290
	INIT_LIST_HEAD(&wl->wlvif_list);
6291

L
Luciano Coelho 已提交
6292 6293
	wl->hw = hw;

6294 6295 6296 6297
	/*
	 * wl->num_links is not configured yet, so just use WLCORE_MAX_LINKS.
	 * we don't allocate any additional resource here, so that's fine.
	 */
6298
	for (i = 0; i < NUM_TX_QUEUES; i++)
6299
		for (j = 0; j < WLCORE_MAX_LINKS; j++)
6300 6301
			skb_queue_head_init(&wl->links[j].tx_queue[i]);

6302 6303 6304
	skb_queue_head_init(&wl->deferred_rx_queue);
	skb_queue_head_init(&wl->deferred_tx_queue);

6305
	INIT_DELAYED_WORK(&wl->elp_work, wl1271_elp_work);
6306
	INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
6307 6308 6309
	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);
6310
	INIT_DELAYED_WORK(&wl->roc_complete_work, wlcore_roc_complete_work);
A
Arik Nemtsov 已提交
6311
	INIT_DELAYED_WORK(&wl->tx_watchdog_work, wl12xx_tx_watchdog_work);
6312

6313 6314 6315 6316 6317 6318
	wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
	if (!wl->freezable_wq) {
		ret = -ENOMEM;
		goto err_hw;
	}

6319
	wl->channel = 0;
L
Luciano Coelho 已提交
6320 6321
	wl->rx_counter = 0;
	wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
6322
	wl->band = NL80211_BAND_2GHZ;
6323
	wl->channel_type = NL80211_CHAN_NO_HT;
6324
	wl->flags = 0;
6325
	wl->sg_enabled = true;
6326
	wl->sleep_auth = WL1271_PSM_ILLEGAL;
6327
	wl->recovery_count = 0;
6328
	wl->hw_pg_ver = -1;
6329 6330
	wl->ap_ps_map = 0;
	wl->ap_fw_ps_map = 0;
6331
	wl->quirks = 0;
E
Eliad Peller 已提交
6332
	wl->system_hlid = WL12XX_SYSTEM_HLID;
6333
	wl->active_sta_count = 0;
6334
	wl->active_link_count = 0;
6335
	wl->fwlog_size = 0;
L
Luciano Coelho 已提交
6336

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

6340
	memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
6341
	for (i = 0; i < wl->num_tx_desc; i++)
L
Luciano Coelho 已提交
6342 6343 6344 6345
		wl->tx_frames[i] = NULL;

	spin_lock_init(&wl->wl_lock);

6346
	wl->state = WLCORE_STATE_OFF;
6347
	wl->fw_type = WL12XX_FW_TYPE_NONE;
L
Luciano Coelho 已提交
6348
	mutex_init(&wl->mutex);
A
Arik Nemtsov 已提交
6349
	mutex_init(&wl->flush_mutex);
6350
	init_completion(&wl->nvs_loading_complete);
L
Luciano Coelho 已提交
6351

6352
	order = get_order(aggr_buf_size);
6353 6354 6355
	wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
	if (!wl->aggr_buf) {
		ret = -ENOMEM;
6356
		goto err_wq;
6357
	}
6358
	wl->aggr_buf_size = aggr_buf_size;
6359

6360 6361 6362 6363 6364 6365
	wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
	if (!wl->dummy_packet) {
		ret = -ENOMEM;
		goto err_aggr;
	}

6366 6367 6368 6369 6370 6371 6372
	/* Allocate one page for the FW log */
	wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
	if (!wl->fwlog) {
		ret = -ENOMEM;
		goto err_dummy_packet;
	}

6373 6374
	wl->mbox_size = mbox_size;
	wl->mbox = kmalloc(wl->mbox_size, GFP_KERNEL | GFP_DMA);
6375 6376 6377 6378 6379
	if (!wl->mbox) {
		ret = -ENOMEM;
		goto err_fwlog;
	}

6380 6381 6382 6383 6384 6385
	wl->buffer_32 = kmalloc(sizeof(*wl->buffer_32), GFP_KERNEL);
	if (!wl->buffer_32) {
		ret = -ENOMEM;
		goto err_mbox;
	}

6386
	return hw;
6387

6388 6389 6390
err_mbox:
	kfree(wl->mbox);

6391 6392 6393
err_fwlog:
	free_page((unsigned long)wl->fwlog);

6394 6395 6396
err_dummy_packet:
	dev_kfree_skb(wl->dummy_packet);

6397 6398 6399
err_aggr:
	free_pages((unsigned long)wl->aggr_buf, order);

6400 6401 6402
err_wq:
	destroy_workqueue(wl->freezable_wq);

6403
err_hw:
6404
	wl1271_debugfs_exit(wl);
6405 6406 6407
	kfree(wl->priv);

err_priv_alloc:
6408 6409 6410
	ieee80211_free_hw(hw);

err_hw_alloc:
6411 6412

	return ERR_PTR(ret);
6413
}
6414
EXPORT_SYMBOL_GPL(wlcore_alloc_hw);
6415

6416
int wlcore_free_hw(struct wl1271 *wl)
6417
{
6418 6419 6420 6421 6422
	/* Unblock any fwlog readers */
	mutex_lock(&wl->mutex);
	wl->fwlog_size = -1;
	mutex_unlock(&wl->mutex);

6423
	wlcore_sysfs_free(wl);
6424

6425
	kfree(wl->buffer_32);
E
Eliad Peller 已提交
6426
	kfree(wl->mbox);
6427
	free_page((unsigned long)wl->fwlog);
6428
	dev_kfree_skb(wl->dummy_packet);
6429
	free_pages((unsigned long)wl->aggr_buf, get_order(wl->aggr_buf_size));
6430 6431 6432 6433 6434

	wl1271_debugfs_exit(wl);

	vfree(wl->fw);
	wl->fw = NULL;
6435
	wl->fw_type = WL12XX_FW_TYPE_NONE;
6436 6437 6438
	kfree(wl->nvs);
	wl->nvs = NULL;

6439 6440
	kfree(wl->raw_fw_status);
	kfree(wl->fw_status);
6441
	kfree(wl->tx_res_if);
6442
	destroy_workqueue(wl->freezable_wq);
6443

6444
	kfree(wl->priv);
6445 6446 6447 6448
	ieee80211_free_hw(wl->hw);

	return 0;
}
6449
EXPORT_SYMBOL_GPL(wlcore_free_hw);
6450

6451 6452 6453 6454 6455 6456 6457 6458 6459
#ifdef CONFIG_PM
static const struct wiphy_wowlan_support wlcore_wowlan_support = {
	.flags = WIPHY_WOWLAN_ANY,
	.n_patterns = WL1271_MAX_RX_FILTERS,
	.pattern_min_len = 1,
	.pattern_max_len = WL1271_RX_FILTER_MAX_PATTERN_SIZE,
};
#endif

6460 6461 6462 6463 6464
static irqreturn_t wlcore_hardirq(int irq, void *cookie)
{
	return IRQ_WAKE_THREAD;
}

6465
static void wlcore_nvs_cb(const struct firmware *fw, void *context)
6466
{
6467 6468
	struct wl1271 *wl = context;
	struct platform_device *pdev = wl->pdev;
6469
	struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev);
6470 6471
	struct resource *res;

6472
	int ret;
6473
	irq_handler_t hardirq_fn = NULL;
6474

6475 6476 6477 6478 6479 6480 6481
	if (fw) {
		wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
		if (!wl->nvs) {
			wl1271_error("Could not allocate nvs data");
			goto out;
		}
		wl->nvs_len = fw->size;
6482
	} else if (pdev_data->family->nvs_name) {
6483
		wl1271_debug(DEBUG_BOOT, "Could not get nvs file %s",
6484 6485 6486 6487
			     pdev_data->family->nvs_name);
		wl->nvs = NULL;
		wl->nvs_len = 0;
	} else {
6488 6489
		wl->nvs = NULL;
		wl->nvs_len = 0;
6490 6491
	}

I
Ido Yariv 已提交
6492 6493
	ret = wl->ops->setup(wl);
	if (ret < 0)
6494
		goto out_free_nvs;
I
Ido Yariv 已提交
6495

6496 6497
	BUG_ON(wl->num_tx_desc > WLCORE_MAX_TX_DESCRIPTORS);

6498 6499 6500
	/* adjust some runtime configuration parameters */
	wlcore_adjust_conf(wl);

6501 6502 6503 6504 6505 6506 6507 6508
	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (!res) {
		wl1271_error("Could not get IRQ resource");
		goto out_free_nvs;
	}

	wl->irq = res->start;
	wl->irq_flags = res->flags & IRQF_TRIGGER_MASK;
6509
	wl->if_ops = pdev_data->if_ops;
6510

6511
	if (wl->irq_flags & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING))
6512
		hardirq_fn = wlcore_hardirq;
6513 6514
	else
		wl->irq_flags |= IRQF_ONESHOT;
6515

6516 6517 6518 6519 6520 6521 6522 6523 6524 6525 6526
	ret = wl12xx_set_power_on(wl);
	if (ret < 0)
		goto out_free_nvs;

	ret = wl12xx_get_hw_info(wl);
	if (ret < 0) {
		wl1271_error("couldn't get hw info");
		wl1271_power_off(wl);
		goto out_free_nvs;
	}

6527
	ret = request_threaded_irq(wl->irq, hardirq_fn, wlcore_irq,
6528
				   wl->irq_flags, pdev->name, wl);
6529
	if (ret < 0) {
6530 6531
		wl1271_error("interrupt configuration failed");
		wl1271_power_off(wl);
6532
		goto out_free_nvs;
6533 6534
	}

6535
#ifdef CONFIG_PM
6536 6537 6538 6539
	ret = enable_irq_wake(wl->irq);
	if (!ret) {
		wl->irq_wake_enabled = true;
		device_init_wakeup(wl->dev, 1);
6540
		if (pdev_data->pwr_in_suspend)
6541
			wl->hw->wiphy->wowlan = &wlcore_wowlan_support;
6542
	}
6543
#endif
6544
	disable_irq(wl->irq);
6545
	wl1271_power_off(wl);
6546 6547 6548

	ret = wl->ops->identify_chip(wl);
	if (ret < 0)
6549
		goto out_irq;
6550

6551 6552 6553 6554 6555 6556 6557 6558
	ret = wl1271_init_ieee80211(wl);
	if (ret)
		goto out_irq;

	ret = wl1271_register_hw(wl);
	if (ret)
		goto out_irq;

6559 6560
	ret = wlcore_sysfs_init(wl);
	if (ret)
6561
		goto out_unreg;
F
Felipe Balbi 已提交
6562

6563
	wl->initialized = true;
6564
	goto out;
6565

6566 6567 6568
out_unreg:
	wl1271_unregister_hw(wl);

6569 6570 6571
out_irq:
	free_irq(wl->irq, wl);

6572 6573 6574
out_free_nvs:
	kfree(wl->nvs);

6575
out:
6576 6577 6578 6579
	release_firmware(fw);
	complete_all(&wl->nvs_loading_complete);
}

6580
int wlcore_probe(struct wl1271 *wl, struct platform_device *pdev)
6581
{
6582 6583 6584
	struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev);
	const char *nvs_name;
	int ret = 0;
6585

6586
	if (!wl->ops || !wl->ptable || !pdev_data)
6587 6588 6589 6590 6591 6592
		return -EINVAL;

	wl->dev = &pdev->dev;
	wl->pdev = pdev;
	platform_set_drvdata(pdev, wl);

6593 6594 6595 6596 6597 6598 6599 6600 6601 6602 6603 6604
	if (pdev_data->family && pdev_data->family->nvs_name) {
		nvs_name = pdev_data->family->nvs_name;
		ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_HOTPLUG,
					      nvs_name, &pdev->dev, GFP_KERNEL,
					      wl, wlcore_nvs_cb);
		if (ret < 0) {
			wl1271_error("request_firmware_nowait failed for %s: %d",
				     nvs_name, ret);
			complete_all(&wl->nvs_loading_complete);
		}
	} else {
		wlcore_nvs_cb(NULL, wl);
6605 6606
	}

6607
	return ret;
6608
}
6609
EXPORT_SYMBOL_GPL(wlcore_probe);
6610

6611
int wlcore_remove(struct platform_device *pdev)
6612
{
6613
	struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev);
6614 6615
	struct wl1271 *wl = platform_get_drvdata(pdev);

6616 6617
	if (pdev_data->family && pdev_data->family->nvs_name)
		wait_for_completion(&wl->nvs_loading_complete);
6618 6619 6620
	if (!wl->initialized)
		return 0;

6621 6622 6623 6624 6625 6626
	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);
6627
	wlcore_free_hw(wl);
6628

6629 6630
	return 0;
}
6631
EXPORT_SYMBOL_GPL(wlcore_remove);
6632

6633
u32 wl12xx_debug_level = DEBUG_NONE;
6634
EXPORT_SYMBOL_GPL(wl12xx_debug_level);
6635
module_param_named(debug_level, wl12xx_debug_level, uint, S_IRUSR | S_IWUSR);
6636 6637
MODULE_PARM_DESC(debug_level, "wl12xx debugging level");

6638
module_param_named(fwlog, fwlog_param, charp, 0);
6639
MODULE_PARM_DESC(fwlog,
S
Shahar Patury 已提交
6640
		 "FW logger options: continuous, dbgpins or disable");
6641

I
Ido Reis 已提交
6642 6643 6644
module_param(fwlog_mem_blocks, int, S_IRUSR | S_IWUSR);
MODULE_PARM_DESC(fwlog_mem_blocks, "fwlog mem_blocks");

6645
module_param(bug_on_recovery, int, S_IRUSR | S_IWUSR);
6646 6647
MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");

6648
module_param(no_recovery, int, S_IRUSR | S_IWUSR);
6649 6650
MODULE_PARM_DESC(no_recovery, "Prevent HW recovery. FW will remain stuck.");

6651
MODULE_LICENSE("GPL");
6652
MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
6653
MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");