1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * This file is part of wlcore
   4 *
   5 * Copyright (C) 2008-2010 Nokia Corporation
   6 * Copyright (C) 2011-2013 Texas Instruments Inc.
   7 */
   8
   9#include <linux/module.h>
  10#include <linux/firmware.h>
  11#include <linux/etherdevice.h>
  12#include <linux/vmalloc.h>
  13#include <linux/interrupt.h>
  14#include <linux/irq.h>
  15#include <linux/pm_runtime.h>
  16#include <linux/pm_wakeirq.h>
  17
  18#include "wlcore.h"
  19#include "debug.h"
  20#include "wl12xx_80211.h"
  21#include "io.h"
  22#include "tx.h"
  23#include "ps.h"
  24#include "init.h"
  25#include "debugfs.h"
  26#include "testmode.h"
  27#include "vendor_cmd.h"
  28#include "scan.h"
  29#include "hw_ops.h"
  30#include "sysfs.h"
  31
  32#define WL1271_BOOT_RETRIES 3
 
  33#define WL1271_WAKEUP_TIMEOUT 500
  34
  35static char *fwlog_param;
  36static int fwlog_mem_blocks = -1;
  37static int bug_on_recovery = -1;
  38static int no_recovery     = -1;
  39
  40static void __wl1271_op_remove_interface(struct wl1271 *wl,
  41					 struct ieee80211_vif *vif,
  42					 bool reset_tx_queues);
  43static void wlcore_op_stop_locked(struct wl1271 *wl);
  44static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif);
  45
  46static int wl12xx_set_authorized(struct wl1271 *wl, struct wl12xx_vif *wlvif)
  47{
  48	int ret;
  49
  50	if (WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS))
  51		return -EINVAL;
  52
  53	if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
  54		return 0;
  55
  56	if (test_and_set_bit(WLVIF_FLAG_STA_STATE_SENT, &wlvif->flags))
  57		return 0;
  58
  59	ret = wl12xx_cmd_set_peer_state(wl, wlvif, wlvif->sta.hlid);
  60	if (ret < 0)
  61		return ret;
  62
  63	wl1271_info("Association completed.");
  64	return 0;
  65}
  66
  67static void wl1271_reg_notify(struct wiphy *wiphy,
  68			      struct regulatory_request *request)
  69{
  70	struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
  71	struct wl1271 *wl = hw->priv;
  72
  73	/* copy the current dfs region */
  74	if (request)
  75		wl->dfs_region = request->dfs_region;
  76
  77	wlcore_regdomain_config(wl);
  78}
  79
  80static int wl1271_set_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif,
  81				   bool enable)
  82{
  83	int ret = 0;
  84
  85	/* we should hold wl->mutex */
  86	ret = wl1271_acx_ps_rx_streaming(wl, wlvif, enable);
  87	if (ret < 0)
  88		goto out;
  89
  90	if (enable)
  91		set_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
  92	else
  93		clear_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags);
  94out:
  95	return ret;
  96}
  97
  98/*
  99 * this function is being called when the rx_streaming interval
 100 * has beed changed or rx_streaming should be disabled
 101 */
 102int wl1271_recalc_rx_streaming(struct wl1271 *wl, struct wl12xx_vif *wlvif)
 103{
 104	int ret = 0;
 105	int period = wl->conf.rx_streaming.interval;
 106
 107	/* don't reconfigure if rx_streaming is disabled */
 108	if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
 109		goto out;
 110
 111	/* reconfigure/disable according to new streaming_period */
 112	if (period &&
 113	    test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
 114	    (wl->conf.rx_streaming.always ||
 115	     test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
 116		ret = wl1271_set_rx_streaming(wl, wlvif, true);
 117	else {
 118		ret = wl1271_set_rx_streaming(wl, wlvif, false);
 119		/* don't cancel_work_sync since we might deadlock */
 120		del_timer_sync(&wlvif->rx_streaming_timer);
 121	}
 122out:
 123	return ret;
 124}
 125
 126static void wl1271_rx_streaming_enable_work(struct work_struct *work)
 127{
 128	int ret;
 129	struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
 130						rx_streaming_enable_work);
 131	struct wl1271 *wl = wlvif->wl;
 132
 133	mutex_lock(&wl->mutex);
 134
 135	if (test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags) ||
 136	    !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) ||
 137	    (!wl->conf.rx_streaming.always &&
 138	     !test_bit(WL1271_FLAG_SOFT_GEMINI, &wl->flags)))
 139		goto out;
 140
 141	if (!wl->conf.rx_streaming.interval)
 142		goto out;
 143
 144	ret = pm_runtime_resume_and_get(wl->dev);
 145	if (ret < 0)
 
 146		goto out;
 
 147
 148	ret = wl1271_set_rx_streaming(wl, wlvif, true);
 149	if (ret < 0)
 150		goto out_sleep;
 151
 152	/* stop it after some time of inactivity */
 153	mod_timer(&wlvif->rx_streaming_timer,
 154		  jiffies + msecs_to_jiffies(wl->conf.rx_streaming.duration));
 155
 156out_sleep:
 157	pm_runtime_mark_last_busy(wl->dev);
 158	pm_runtime_put_autosuspend(wl->dev);
 159out:
 160	mutex_unlock(&wl->mutex);
 161}
 162
 163static void wl1271_rx_streaming_disable_work(struct work_struct *work)
 164{
 165	int ret;
 166	struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
 167						rx_streaming_disable_work);
 168	struct wl1271 *wl = wlvif->wl;
 169
 170	mutex_lock(&wl->mutex);
 171
 172	if (!test_bit(WLVIF_FLAG_RX_STREAMING_STARTED, &wlvif->flags))
 173		goto out;
 174
 175	ret = pm_runtime_resume_and_get(wl->dev);
 176	if (ret < 0)
 
 177		goto out;
 
 178
 179	ret = wl1271_set_rx_streaming(wl, wlvif, false);
 180	if (ret)
 181		goto out_sleep;
 182
 183out_sleep:
 184	pm_runtime_mark_last_busy(wl->dev);
 185	pm_runtime_put_autosuspend(wl->dev);
 186out:
 187	mutex_unlock(&wl->mutex);
 188}
 189
 190static void wl1271_rx_streaming_timer(struct timer_list *t)
 191{
 192	struct wl12xx_vif *wlvif = from_timer(wlvif, t, rx_streaming_timer);
 193	struct wl1271 *wl = wlvif->wl;
 194	ieee80211_queue_work(wl->hw, &wlvif->rx_streaming_disable_work);
 195}
 196
 197/* wl->mutex must be taken */
 198void wl12xx_rearm_tx_watchdog_locked(struct wl1271 *wl)
 199{
 200	/* if the watchdog is not armed, don't do anything */
 201	if (wl->tx_allocated_blocks == 0)
 202		return;
 203
 204	cancel_delayed_work(&wl->tx_watchdog_work);
 205	ieee80211_queue_delayed_work(wl->hw, &wl->tx_watchdog_work,
 206		msecs_to_jiffies(wl->conf.tx.tx_watchdog_timeout));
 207}
 208
 209static void wlcore_rc_update_work(struct work_struct *work)
 210{
 211	int ret;
 212	struct wl12xx_vif *wlvif = container_of(work, struct wl12xx_vif,
 213						rc_update_work);
 214	struct wl1271 *wl = wlvif->wl;
 215	struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
 216
 217	mutex_lock(&wl->mutex);
 218
 219	if (unlikely(wl->state != WLCORE_STATE_ON))
 220		goto out;
 221
 222	ret = pm_runtime_resume_and_get(wl->dev);
 223	if (ret < 0)
 
 224		goto out;
 
 225
 226	if (ieee80211_vif_is_mesh(vif)) {
 227		ret = wl1271_acx_set_ht_capabilities(wl, &wlvif->rc_ht_cap,
 228						     true, wlvif->sta.hlid);
 229		if (ret < 0)
 230			goto out_sleep;
 231	} else {
 232		wlcore_hw_sta_rc_update(wl, wlvif);
 233	}
 234
 235out_sleep:
 236	pm_runtime_mark_last_busy(wl->dev);
 237	pm_runtime_put_autosuspend(wl->dev);
 238out:
 239	mutex_unlock(&wl->mutex);
 240}
 241
 242static void wl12xx_tx_watchdog_work(struct work_struct *work)
 243{
 244	struct delayed_work *dwork;
 245	struct wl1271 *wl;
 246
 247	dwork = to_delayed_work(work);
 248	wl = container_of(dwork, struct wl1271, tx_watchdog_work);
 249
 250	mutex_lock(&wl->mutex);
 251
 252	if (unlikely(wl->state != WLCORE_STATE_ON))
 253		goto out;
 254
 255	/* Tx went out in the meantime - everything is ok */
 256	if (unlikely(wl->tx_allocated_blocks == 0))
 257		goto out;
 258
 259	/*
 260	 * if a ROC is in progress, we might not have any Tx for a long
 261	 * time (e.g. pending Tx on the non-ROC channels)
 262	 */
 263	if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
 264		wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to ROC",
 265			     wl->conf.tx.tx_watchdog_timeout);
 266		wl12xx_rearm_tx_watchdog_locked(wl);
 267		goto out;
 268	}
 269
 270	/*
 271	 * if a scan is in progress, we might not have any Tx for a long
 272	 * time
 273	 */
 274	if (wl->scan.state != WL1271_SCAN_STATE_IDLE) {
 275		wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms due to scan",
 276			     wl->conf.tx.tx_watchdog_timeout);
 277		wl12xx_rearm_tx_watchdog_locked(wl);
 278		goto out;
 279	}
 280
 281	/*
 282	* AP might cache a frame for a long time for a sleeping station,
 283	* so rearm the timer if there's an AP interface with stations. If
 284	* Tx is genuinely stuck we will most hopefully discover it when all
 285	* stations are removed due to inactivity.
 286	*/
 287	if (wl->active_sta_count) {
 288		wl1271_debug(DEBUG_TX, "No Tx (in FW) for %d ms. AP has "
 289			     " %d stations",
 290			      wl->conf.tx.tx_watchdog_timeout,
 291			      wl->active_sta_count);
 292		wl12xx_rearm_tx_watchdog_locked(wl);
 293		goto out;
 294	}
 295
 296	wl1271_error("Tx stuck (in FW) for %d ms. Starting recovery",
 297		     wl->conf.tx.tx_watchdog_timeout);
 298	wl12xx_queue_recovery_work(wl);
 299
 300out:
 301	mutex_unlock(&wl->mutex);
 302}
 303
 304static void wlcore_adjust_conf(struct wl1271 *wl)
 305{
 306
 307	if (fwlog_param) {
 308		if (!strcmp(fwlog_param, "continuous")) {
 309			wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
 310			wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_HOST;
 311		} else if (!strcmp(fwlog_param, "dbgpins")) {
 312			wl->conf.fwlog.mode = WL12XX_FWLOG_CONTINUOUS;
 313			wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_DBG_PINS;
 314		} else if (!strcmp(fwlog_param, "disable")) {
 315			wl->conf.fwlog.mem_blocks = 0;
 316			wl->conf.fwlog.output = WL12XX_FWLOG_OUTPUT_NONE;
 317		} else {
 318			wl1271_error("Unknown fwlog parameter %s", fwlog_param);
 319		}
 320	}
 321
 322	if (bug_on_recovery != -1)
 323		wl->conf.recovery.bug_on_recovery = (u8) bug_on_recovery;
 324
 325	if (no_recovery != -1)
 326		wl->conf.recovery.no_recovery = (u8) no_recovery;
 327}
 328
 329static void wl12xx_irq_ps_regulate_link(struct wl1271 *wl,
 330					struct wl12xx_vif *wlvif,
 331					u8 hlid, u8 tx_pkts)
 332{
 333	bool fw_ps;
 334
 335	fw_ps = test_bit(hlid, &wl->ap_fw_ps_map);
 336
 337	/*
 338	 * Wake up from high level PS if the STA is asleep with too little
 339	 * packets in FW or if the STA is awake.
 340	 */
 341	if (!fw_ps || tx_pkts < WL1271_PS_STA_MAX_PACKETS)
 342		wl12xx_ps_link_end(wl, wlvif, hlid);
 343
 344	/*
 345	 * Start high-level PS if the STA is asleep with enough blocks in FW.
 346	 * Make an exception if this is the only connected link. In this
 347	 * case FW-memory congestion is less of a problem.
 348	 * Note that a single connected STA means 2*ap_count + 1 active links,
 349	 * since we must account for the global and broadcast AP links
 350	 * for each AP. The "fw_ps" check assures us the other link is a STA
 351	 * connected to the AP. Otherwise the FW would not set the PSM bit.
 352	 */
 353	else if (wl->active_link_count > (wl->ap_count*2 + 1) && fw_ps &&
 354		 tx_pkts >= WL1271_PS_STA_MAX_PACKETS)
 355		wl12xx_ps_link_start(wl, wlvif, hlid, true);
 356}
 357
 358static void wl12xx_irq_update_links_status(struct wl1271 *wl,
 359					   struct wl12xx_vif *wlvif,
 360					   struct wl_fw_status *status)
 361{
 362	unsigned long cur_fw_ps_map;
 363	u8 hlid;
 364
 365	cur_fw_ps_map = status->link_ps_bitmap;
 366	if (wl->ap_fw_ps_map != cur_fw_ps_map) {
 367		wl1271_debug(DEBUG_PSM,
 368			     "link ps prev 0x%lx cur 0x%lx changed 0x%lx",
 369			     wl->ap_fw_ps_map, cur_fw_ps_map,
 370			     wl->ap_fw_ps_map ^ cur_fw_ps_map);
 371
 372		wl->ap_fw_ps_map = cur_fw_ps_map;
 373	}
 374
 375	for_each_set_bit(hlid, wlvif->ap.sta_hlid_map, wl->num_links)
 376		wl12xx_irq_ps_regulate_link(wl, wlvif, hlid,
 377					    wl->links[hlid].allocated_pkts);
 378}
 379
 380static int wlcore_fw_status(struct wl1271 *wl, struct wl_fw_status *status)
 381{
 382	struct wl12xx_vif *wlvif;
 383	u32 old_tx_blk_count = wl->tx_blocks_available;
 384	int avail, freed_blocks;
 385	int i;
 386	int ret;
 387	struct wl1271_link *lnk;
 388
 389	ret = wlcore_raw_read_data(wl, REG_RAW_FW_STATUS_ADDR,
 390				   wl->raw_fw_status,
 391				   wl->fw_status_len, false);
 392	if (ret < 0)
 393		return ret;
 394
 395	wlcore_hw_convert_fw_status(wl, wl->raw_fw_status, wl->fw_status);
 396
 397	wl1271_debug(DEBUG_IRQ, "intr: 0x%x (fw_rx_counter = %d, "
 398		     "drv_rx_counter = %d, tx_results_counter = %d)",
 399		     status->intr,
 400		     status->fw_rx_counter,
 401		     status->drv_rx_counter,
 402		     status->tx_results_counter);
 403
 404	for (i = 0; i < NUM_TX_QUEUES; i++) {
 405		/* prevent wrap-around in freed-packets counter */
 406		wl->tx_allocated_pkts[i] -=
 407				(status->counters.tx_released_pkts[i] -
 408				wl->tx_pkts_freed[i]) & 0xff;
 409
 410		wl->tx_pkts_freed[i] = status->counters.tx_released_pkts[i];
 411	}
 412
 413
 414	for_each_set_bit(i, wl->links_map, wl->num_links) {
 415		u8 diff;
 416		lnk = &wl->links[i];
 417
 418		/* prevent wrap-around in freed-packets counter */
 419		diff = (status->counters.tx_lnk_free_pkts[i] -
 420		       lnk->prev_freed_pkts) & 0xff;
 421
 422		if (diff == 0)
 423			continue;
 424
 425		lnk->allocated_pkts -= diff;
 426		lnk->prev_freed_pkts = status->counters.tx_lnk_free_pkts[i];
 427
 428		/* accumulate the prev_freed_pkts counter */
 429		lnk->total_freed_pkts += diff;
 430	}
 431
 432	/* prevent wrap-around in total blocks counter */
 433	if (likely(wl->tx_blocks_freed <= status->total_released_blks))
 434		freed_blocks = status->total_released_blks -
 435			       wl->tx_blocks_freed;
 436	else
 437		freed_blocks = 0x100000000LL - wl->tx_blocks_freed +
 438			       status->total_released_blks;
 439
 440	wl->tx_blocks_freed = status->total_released_blks;
 441
 442	wl->tx_allocated_blocks -= freed_blocks;
 443
 444	/*
 445	 * If the FW freed some blocks:
 446	 * If we still have allocated blocks - re-arm the timer, Tx is
 447	 * not stuck. Otherwise, cancel the timer (no Tx currently).
 448	 */
 449	if (freed_blocks) {
 450		if (wl->tx_allocated_blocks)
 451			wl12xx_rearm_tx_watchdog_locked(wl);
 452		else
 453			cancel_delayed_work(&wl->tx_watchdog_work);
 454	}
 455
 456	avail = status->tx_total - wl->tx_allocated_blocks;
 457
 458	/*
 459	 * The FW might change the total number of TX memblocks before
 460	 * we get a notification about blocks being released. Thus, the
 461	 * available blocks calculation might yield a temporary result
 462	 * which is lower than the actual available blocks. Keeping in
 463	 * mind that only blocks that were allocated can be moved from
 464	 * TX to RX, tx_blocks_available should never decrease here.
 465	 */
 466	wl->tx_blocks_available = max((int)wl->tx_blocks_available,
 467				      avail);
 468
 469	/* if more blocks are available now, tx work can be scheduled */
 470	if (wl->tx_blocks_available > old_tx_blk_count)
 471		clear_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags);
 472
 473	/* for AP update num of allocated TX blocks per link and ps status */
 474	wl12xx_for_each_wlvif_ap(wl, wlvif) {
 475		wl12xx_irq_update_links_status(wl, wlvif, status);
 476	}
 477
 478	/* update the host-chipset time offset */
 479	wl->time_offset = (ktime_get_boottime_ns() >> 10) -
 480		(s64)(status->fw_localtime);
 481
 482	wl->fw_fast_lnk_map = status->link_fast_bitmap;
 483
 484	return 0;
 485}
 486
 487static void wl1271_flush_deferred_work(struct wl1271 *wl)
 488{
 489	struct sk_buff *skb;
 490
 491	/* Pass all received frames to the network stack */
 492	while ((skb = skb_dequeue(&wl->deferred_rx_queue)))
 493		ieee80211_rx_ni(wl->hw, skb);
 494
 495	/* Return sent skbs to the network stack */
 496	while ((skb = skb_dequeue(&wl->deferred_tx_queue)))
 497		ieee80211_tx_status_ni(wl->hw, skb);
 498}
 499
 500static void wl1271_netstack_work(struct work_struct *work)
 501{
 502	struct wl1271 *wl =
 503		container_of(work, struct wl1271, netstack_work);
 504
 505	do {
 506		wl1271_flush_deferred_work(wl);
 507	} while (skb_queue_len(&wl->deferred_rx_queue));
 508}
 509
 510#define WL1271_IRQ_MAX_LOOPS 256
 511
 512static int wlcore_irq_locked(struct wl1271 *wl)
 513{
 514	int ret = 0;
 515	u32 intr;
 516	int loopcount = WL1271_IRQ_MAX_LOOPS;
 517	bool run_tx_queue = true;
 518	bool done = false;
 519	unsigned int defer_count;
 520	unsigned long flags;
 521
 522	/*
 523	 * In case edge triggered interrupt must be used, we cannot iterate
 524	 * more than once without introducing race conditions with the hardirq.
 525	 */
 526	if (wl->irq_flags & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING))
 527		loopcount = 1;
 528
 529	wl1271_debug(DEBUG_IRQ, "IRQ work");
 530
 531	if (unlikely(wl->state != WLCORE_STATE_ON))
 532		goto out;
 533
 534	ret = pm_runtime_resume_and_get(wl->dev);
 535	if (ret < 0)
 
 536		goto out;
 
 537
 538	while (!done && loopcount--) {
 539		smp_mb__after_atomic();
 540
 541		ret = wlcore_fw_status(wl, wl->fw_status);
 542		if (ret < 0)
 543			goto err_ret;
 544
 545		wlcore_hw_tx_immediate_compl(wl);
 546
 547		intr = wl->fw_status->intr;
 548		intr &= WLCORE_ALL_INTR_MASK;
 549		if (!intr) {
 550			done = true;
 551			continue;
 552		}
 553
 554		if (unlikely(intr & WL1271_ACX_INTR_WATCHDOG)) {
 555			wl1271_error("HW watchdog interrupt received! starting recovery.");
 556			wl->watchdog_recovery = true;
 557			ret = -EIO;
 558
 559			/* restarting the chip. ignore any other interrupt. */
 560			goto err_ret;
 561		}
 562
 563		if (unlikely(intr & WL1271_ACX_SW_INTR_WATCHDOG)) {
 564			wl1271_error("SW watchdog interrupt received! "
 565				     "starting recovery.");
 566			wl->watchdog_recovery = true;
 567			ret = -EIO;
 568
 569			/* restarting the chip. ignore any other interrupt. */
 570			goto err_ret;
 571		}
 572
 573		if (likely(intr & WL1271_ACX_INTR_DATA)) {
 574			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_DATA");
 575
 576			ret = wlcore_rx(wl, wl->fw_status);
 577			if (ret < 0)
 578				goto err_ret;
 579
 580			/* Check if any tx blocks were freed */
 581			if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags)) {
 582				if (spin_trylock_irqsave(&wl->wl_lock, flags)) {
 583					if (!wl1271_tx_total_queue_count(wl))
 584						run_tx_queue = false;
 585					spin_unlock_irqrestore(&wl->wl_lock, flags);
 586				}
 587
 588				/*
 589				 * In order to avoid starvation of the TX path,
 590				 * call the work function directly.
 591				 */
 592				if (run_tx_queue) {
 593					ret = wlcore_tx_work_locked(wl);
 594					if (ret < 0)
 595						goto err_ret;
 596				}
 597			}
 598
 599			/* check for tx results */
 600			ret = wlcore_hw_tx_delayed_compl(wl);
 601			if (ret < 0)
 602				goto err_ret;
 603
 604			/* Make sure the deferred queues don't get too long */
 605			defer_count = skb_queue_len(&wl->deferred_tx_queue) +
 606				      skb_queue_len(&wl->deferred_rx_queue);
 607			if (defer_count > WL1271_DEFERRED_QUEUE_LIMIT)
 608				wl1271_flush_deferred_work(wl);
 609		}
 610
 611		if (intr & WL1271_ACX_INTR_EVENT_A) {
 612			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_A");
 613			ret = wl1271_event_handle(wl, 0);
 614			if (ret < 0)
 615				goto err_ret;
 616		}
 617
 618		if (intr & WL1271_ACX_INTR_EVENT_B) {
 619			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_EVENT_B");
 620			ret = wl1271_event_handle(wl, 1);
 621			if (ret < 0)
 622				goto err_ret;
 623		}
 624
 625		if (intr & WL1271_ACX_INTR_INIT_COMPLETE)
 626			wl1271_debug(DEBUG_IRQ,
 627				     "WL1271_ACX_INTR_INIT_COMPLETE");
 628
 629		if (intr & WL1271_ACX_INTR_HW_AVAILABLE)
 630			wl1271_debug(DEBUG_IRQ, "WL1271_ACX_INTR_HW_AVAILABLE");
 631	}
 632
 633err_ret:
 634	pm_runtime_mark_last_busy(wl->dev);
 635	pm_runtime_put_autosuspend(wl->dev);
 636
 637out:
 638	return ret;
 639}
 640
 641static irqreturn_t wlcore_irq(int irq, void *cookie)
 642{
 643	int ret;
 644	unsigned long flags;
 645	struct wl1271 *wl = cookie;
 646	bool queue_tx_work = true;
 647
 648	set_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
 649
 650	/* complete the ELP completion */
 651	if (test_bit(WL1271_FLAG_IN_ELP, &wl->flags)) {
 652		spin_lock_irqsave(&wl->wl_lock, flags);
 653		if (wl->elp_compl)
 654			complete(wl->elp_compl);
 655		spin_unlock_irqrestore(&wl->wl_lock, flags);
 656	}
 657
 658	if (test_bit(WL1271_FLAG_SUSPENDED, &wl->flags)) {
 659		/* don't enqueue a work right now. mark it as pending */
 660		set_bit(WL1271_FLAG_PENDING_WORK, &wl->flags);
 661		wl1271_debug(DEBUG_IRQ, "should not enqueue work");
 662		spin_lock_irqsave(&wl->wl_lock, flags);
 663		disable_irq_nosync(wl->irq);
 664		pm_wakeup_event(wl->dev, 0);
 665		spin_unlock_irqrestore(&wl->wl_lock, flags);
 666		goto out_handled;
 667	}
 668
 669	/* TX might be handled here, avoid redundant work */
 670	set_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
 671	cancel_work_sync(&wl->tx_work);
 672
 673	mutex_lock(&wl->mutex);
 674
 675	ret = wlcore_irq_locked(wl);
 676	if (ret)
 677		wl12xx_queue_recovery_work(wl);
 678
 679	/* In case TX was not handled in wlcore_irq_locked(), queue TX work */
 680	clear_bit(WL1271_FLAG_TX_PENDING, &wl->flags);
 681	if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags)) {
 682		if (spin_trylock_irqsave(&wl->wl_lock, flags)) {
 683			if (!wl1271_tx_total_queue_count(wl))
 684				queue_tx_work = false;
 685			spin_unlock_irqrestore(&wl->wl_lock, flags);
 686		}
 687		if (queue_tx_work)
 688			ieee80211_queue_work(wl->hw, &wl->tx_work);
 689	}
 690
 691	mutex_unlock(&wl->mutex);
 692
 693out_handled:
 694	clear_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags);
 695
 696	return IRQ_HANDLED;
 697}
 698
 699struct vif_counter_data {
 700	u8 counter;
 701
 702	struct ieee80211_vif *cur_vif;
 703	bool cur_vif_running;
 704};
 705
 706static void wl12xx_vif_count_iter(void *data, u8 *mac,
 707				  struct ieee80211_vif *vif)
 708{
 709	struct vif_counter_data *counter = data;
 710
 711	counter->counter++;
 712	if (counter->cur_vif == vif)
 713		counter->cur_vif_running = true;
 714}
 715
 716/* caller must not hold wl->mutex, as it might deadlock */
 717static void wl12xx_get_vif_count(struct ieee80211_hw *hw,
 718			       struct ieee80211_vif *cur_vif,
 719			       struct vif_counter_data *data)
 720{
 721	memset(data, 0, sizeof(*data));
 722	data->cur_vif = cur_vif;
 723
 724	ieee80211_iterate_active_interfaces(hw, IEEE80211_IFACE_ITER_RESUME_ALL,
 725					    wl12xx_vif_count_iter, data);
 726}
 727
 728static int wl12xx_fetch_firmware(struct wl1271 *wl, bool plt)
 729{
 730	const struct firmware *fw;
 731	const char *fw_name;
 732	enum wl12xx_fw_type fw_type;
 733	int ret;
 734
 735	if (plt) {
 736		fw_type = WL12XX_FW_TYPE_PLT;
 737		fw_name = wl->plt_fw_name;
 738	} else {
 739		/*
 740		 * we can't call wl12xx_get_vif_count() here because
 741		 * wl->mutex is taken, so use the cached last_vif_count value
 742		 */
 743		if (wl->last_vif_count > 1 && wl->mr_fw_name) {
 744			fw_type = WL12XX_FW_TYPE_MULTI;
 745			fw_name = wl->mr_fw_name;
 746		} else {
 747			fw_type = WL12XX_FW_TYPE_NORMAL;
 748			fw_name = wl->sr_fw_name;
 749		}
 750	}
 751
 752	if (wl->fw_type == fw_type)
 753		return 0;
 754
 755	wl1271_debug(DEBUG_BOOT, "booting firmware %s", fw_name);
 756
 757	ret = request_firmware(&fw, fw_name, wl->dev);
 758
 759	if (ret < 0) {
 760		wl1271_error("could not get firmware %s: %d", fw_name, ret);
 761		return ret;
 762	}
 763
 764	if (fw->size % 4) {
 765		wl1271_error("firmware size is not multiple of 32 bits: %zu",
 766			     fw->size);
 767		ret = -EILSEQ;
 768		goto out;
 769	}
 770
 771	vfree(wl->fw);
 772	wl->fw_type = WL12XX_FW_TYPE_NONE;
 773	wl->fw_len = fw->size;
 774	wl->fw = vmalloc(wl->fw_len);
 775
 776	if (!wl->fw) {
 777		wl1271_error("could not allocate memory for the firmware");
 778		ret = -ENOMEM;
 779		goto out;
 780	}
 781
 782	memcpy(wl->fw, fw->data, wl->fw_len);
 783	ret = 0;
 784	wl->fw_type = fw_type;
 785out:
 786	release_firmware(fw);
 787
 788	return ret;
 789}
 790
 791void wl12xx_queue_recovery_work(struct wl1271 *wl)
 792{
 793	/* Avoid a recursive recovery */
 794	if (wl->state == WLCORE_STATE_ON) {
 795		WARN_ON(!test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY,
 796				  &wl->flags));
 797
 798		wl->state = WLCORE_STATE_RESTARTING;
 799		set_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
 800		ieee80211_queue_work(wl->hw, &wl->recovery_work);
 801	}
 802}
 803
 804size_t wl12xx_copy_fwlog(struct wl1271 *wl, u8 *memblock, size_t maxlen)
 805{
 806	size_t len;
 807
 808	/* Make sure we have enough room */
 809	len = min_t(size_t, maxlen, PAGE_SIZE - wl->fwlog_size);
 810
 811	/* Fill the FW log file, consumed by the sysfs fwlog entry */
 812	memcpy(wl->fwlog + wl->fwlog_size, memblock, len);
 813	wl->fwlog_size += len;
 814
 815	return len;
 816}
 817
 818static void wl12xx_read_fwlog_panic(struct wl1271 *wl)
 819{
 820	u32 end_of_log = 0;
 821	int error;
 822
 823	if (wl->quirks & WLCORE_QUIRK_FWLOG_NOT_IMPLEMENTED)
 824		return;
 825
 826	wl1271_info("Reading FW panic log");
 827
 828	/*
 829	 * Make sure the chip is awake and the logger isn't active.
 830	 * Do not send a stop fwlog command if the fw is hanged or if
 831	 * dbgpins are used (due to some fw bug).
 832	 */
 833	error = pm_runtime_resume_and_get(wl->dev);
 834	if (error < 0)
 
 835		return;
 
 836	if (!wl->watchdog_recovery &&
 837	    wl->conf.fwlog.output != WL12XX_FWLOG_OUTPUT_DBG_PINS)
 838		wl12xx_cmd_stop_fwlog(wl);
 839
 840	/* Traverse the memory blocks linked list */
 841	do {
 842		end_of_log = wlcore_event_fw_logger(wl);
 843		if (end_of_log == 0) {
 844			msleep(100);
 845			end_of_log = wlcore_event_fw_logger(wl);
 846		}
 847	} while (end_of_log != 0);
 848}
 849
 850static void wlcore_save_freed_pkts(struct wl1271 *wl, struct wl12xx_vif *wlvif,
 851				   u8 hlid, struct ieee80211_sta *sta)
 852{
 853	struct wl1271_station *wl_sta;
 854	u32 sqn_recovery_padding = WL1271_TX_SQN_POST_RECOVERY_PADDING;
 855
 856	wl_sta = (void *)sta->drv_priv;
 857	wl_sta->total_freed_pkts = wl->links[hlid].total_freed_pkts;
 858
 859	/*
 860	 * increment the initial seq number on recovery to account for
 861	 * transmitted packets that we haven't yet got in the FW status
 862	 */
 863	if (wlvif->encryption_type == KEY_GEM)
 864		sqn_recovery_padding = WL1271_TX_SQN_POST_RECOVERY_PADDING_GEM;
 865
 866	if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
 867		wl_sta->total_freed_pkts += sqn_recovery_padding;
 868}
 869
 870static void wlcore_save_freed_pkts_addr(struct wl1271 *wl,
 871					struct wl12xx_vif *wlvif,
 872					u8 hlid, const u8 *addr)
 873{
 874	struct ieee80211_sta *sta;
 875	struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
 876
 877	if (WARN_ON(hlid == WL12XX_INVALID_LINK_ID ||
 878		    is_zero_ether_addr(addr)))
 879		return;
 880
 881	rcu_read_lock();
 882	sta = ieee80211_find_sta(vif, addr);
 883	if (sta)
 884		wlcore_save_freed_pkts(wl, wlvif, hlid, sta);
 885	rcu_read_unlock();
 886}
 887
 888static void wlcore_print_recovery(struct wl1271 *wl)
 889{
 890	u32 pc = 0;
 891	u32 hint_sts = 0;
 892	int ret;
 893
 894	wl1271_info("Hardware recovery in progress. FW ver: %s",
 895		    wl->chip.fw_ver_str);
 896
 897	/* change partitions momentarily so we can read the FW pc */
 898	ret = wlcore_set_partition(wl, &wl->ptable[PART_BOOT]);
 899	if (ret < 0)
 900		return;
 901
 902	ret = wlcore_read_reg(wl, REG_PC_ON_RECOVERY, &pc);
 903	if (ret < 0)
 904		return;
 905
 906	ret = wlcore_read_reg(wl, REG_INTERRUPT_NO_CLEAR, &hint_sts);
 907	if (ret < 0)
 908		return;
 909
 910	wl1271_info("pc: 0x%x, hint_sts: 0x%08x count: %d",
 911				pc, hint_sts, ++wl->recovery_count);
 912
 913	wlcore_set_partition(wl, &wl->ptable[PART_WORK]);
 914}
 915
 916
 917static void wl1271_recovery_work(struct work_struct *work)
 918{
 919	struct wl1271 *wl =
 920		container_of(work, struct wl1271, recovery_work);
 921	struct wl12xx_vif *wlvif;
 922	struct ieee80211_vif *vif;
 923	int error;
 924
 925	mutex_lock(&wl->mutex);
 926
 927	if (wl->state == WLCORE_STATE_OFF || wl->plt)
 928		goto out_unlock;
 929
 930	error = pm_runtime_resume_and_get(wl->dev);
 931	if (error < 0)
 932		wl1271_warning("Enable for recovery failed");
 
 
 933	wlcore_disable_interrupts_nosync(wl);
 934
 935	if (!test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags)) {
 936		if (wl->conf.fwlog.output == WL12XX_FWLOG_OUTPUT_HOST)
 937			wl12xx_read_fwlog_panic(wl);
 938		wlcore_print_recovery(wl);
 939	}
 940
 941	BUG_ON(wl->conf.recovery.bug_on_recovery &&
 942	       !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags));
 943
 944	clear_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
 945
 946	if (wl->conf.recovery.no_recovery) {
 947		wl1271_info("No recovery (chosen on module load). Fw will remain stuck.");
 948		goto out_unlock;
 949	}
 950
 951	/* Prevent spurious TX during FW restart */
 952	wlcore_stop_queues(wl, WLCORE_QUEUE_STOP_REASON_FW_RESTART);
 953
 954	/* reboot the chipset */
 955	while (!list_empty(&wl->wlvif_list)) {
 956		wlvif = list_first_entry(&wl->wlvif_list,
 957				       struct wl12xx_vif, list);
 958		vif = wl12xx_wlvif_to_vif(wlvif);
 959
 960		if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
 961		    test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
 962			wlcore_save_freed_pkts_addr(wl, wlvif, wlvif->sta.hlid,
 963						    vif->bss_conf.bssid);
 964		}
 965
 966		__wl1271_op_remove_interface(wl, vif, false);
 967	}
 968
 969	wlcore_op_stop_locked(wl);
 970	pm_runtime_mark_last_busy(wl->dev);
 971	pm_runtime_put_autosuspend(wl->dev);
 972
 973	ieee80211_restart_hw(wl->hw);
 974
 975	/*
 976	 * Its safe to enable TX now - the queues are stopped after a request
 977	 * to restart the HW.
 978	 */
 979	wlcore_wake_queues(wl, WLCORE_QUEUE_STOP_REASON_FW_RESTART);
 980
 981out_unlock:
 982	wl->watchdog_recovery = false;
 983	clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags);
 984	mutex_unlock(&wl->mutex);
 985}
 986
 987static int wlcore_fw_wakeup(struct wl1271 *wl)
 988{
 989	return wlcore_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG, ELPCTRL_WAKE_UP);
 990}
 991
 992static int wl1271_setup(struct wl1271 *wl)
 993{
 994	wl->raw_fw_status = kzalloc(wl->fw_status_len, GFP_KERNEL);
 995	if (!wl->raw_fw_status)
 996		goto err;
 997
 998	wl->fw_status = kzalloc(sizeof(*wl->fw_status), GFP_KERNEL);
 999	if (!wl->fw_status)
1000		goto err;
1001
1002	wl->tx_res_if = kzalloc(sizeof(*wl->tx_res_if), GFP_KERNEL);
1003	if (!wl->tx_res_if)
1004		goto err;
1005
1006	return 0;
1007err:
1008	kfree(wl->fw_status);
1009	kfree(wl->raw_fw_status);
1010	return -ENOMEM;
1011}
1012
1013static int wl12xx_set_power_on(struct wl1271 *wl)
1014{
1015	int ret;
1016
1017	msleep(WL1271_PRE_POWER_ON_SLEEP);
1018	ret = wl1271_power_on(wl);
1019	if (ret < 0)
1020		goto out;
1021	msleep(WL1271_POWER_ON_SLEEP);
1022	wl1271_io_reset(wl);
1023	wl1271_io_init(wl);
1024
1025	ret = wlcore_set_partition(wl, &wl->ptable[PART_BOOT]);
1026	if (ret < 0)
1027		goto fail;
1028
1029	/* ELP module wake up */
1030	ret = wlcore_fw_wakeup(wl);
1031	if (ret < 0)
1032		goto fail;
1033
1034out:
1035	return ret;
1036
1037fail:
1038	wl1271_power_off(wl);
1039	return ret;
1040}
1041
1042static int wl12xx_chip_wakeup(struct wl1271 *wl, bool plt)
1043{
1044	int ret = 0;
1045
1046	ret = wl12xx_set_power_on(wl);
1047	if (ret < 0)
1048		goto out;
1049
1050	/*
1051	 * For wl127x based devices we could use the default block
1052	 * size (512 bytes), but due to a bug in the sdio driver, we
1053	 * need to set it explicitly after the chip is powered on.  To
1054	 * simplify the code and since the performance impact is
1055	 * negligible, we use the same block size for all different
1056	 * chip types.
1057	 *
1058	 * Check if the bus supports blocksize alignment and, if it
1059	 * doesn't, make sure we don't have the quirk.
1060	 */
1061	if (!wl1271_set_block_size(wl))
1062		wl->quirks &= ~WLCORE_QUIRK_TX_BLOCKSIZE_ALIGN;
1063
1064	/* TODO: make sure the lower driver has set things up correctly */
1065
1066	ret = wl1271_setup(wl);
1067	if (ret < 0)
1068		goto out;
1069
1070	ret = wl12xx_fetch_firmware(wl, plt);
1071	if (ret < 0) {
1072		kfree(wl->fw_status);
1073		kfree(wl->raw_fw_status);
1074		kfree(wl->tx_res_if);
1075	}
1076
1077out:
1078	return ret;
1079}
1080
1081int wl1271_plt_start(struct wl1271 *wl, const enum plt_mode plt_mode)
1082{
1083	int retries = WL1271_BOOT_RETRIES;
1084	struct wiphy *wiphy = wl->hw->wiphy;
1085
1086	static const char* const PLT_MODE[] = {
1087		"PLT_OFF",
1088		"PLT_ON",
1089		"PLT_FEM_DETECT",
1090		"PLT_CHIP_AWAKE"
1091	};
1092
1093	int ret;
1094
1095	mutex_lock(&wl->mutex);
1096
1097	wl1271_notice("power up");
1098
1099	if (wl->state != WLCORE_STATE_OFF) {
1100		wl1271_error("cannot go into PLT state because not "
1101			     "in off state: %d", wl->state);
1102		ret = -EBUSY;
1103		goto out;
1104	}
1105
1106	/* Indicate to lower levels that we are now in PLT mode */
1107	wl->plt = true;
1108	wl->plt_mode = plt_mode;
1109
1110	while (retries) {
1111		retries--;
1112		ret = wl12xx_chip_wakeup(wl, true);
1113		if (ret < 0)
1114			goto power_off;
1115
1116		if (plt_mode != PLT_CHIP_AWAKE) {
1117			ret = wl->ops->plt_init(wl);
1118			if (ret < 0)
1119				goto power_off;
1120		}
1121
1122		wl->state = WLCORE_STATE_ON;
1123		wl1271_notice("firmware booted in PLT mode %s (%s)",
1124			      PLT_MODE[plt_mode],
1125			      wl->chip.fw_ver_str);
1126
1127		/* update hw/fw version info in wiphy struct */
1128		wiphy->hw_version = wl->chip.id;
1129		strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
1130			sizeof(wiphy->fw_version));
1131
1132		goto out;
1133
1134power_off:
1135		wl1271_power_off(wl);
1136	}
1137
1138	wl->plt = false;
1139	wl->plt_mode = PLT_OFF;
1140
1141	wl1271_error("firmware boot in PLT mode failed despite %d retries",
1142		     WL1271_BOOT_RETRIES);
1143out:
1144	mutex_unlock(&wl->mutex);
1145
1146	return ret;
1147}
1148
1149int wl1271_plt_stop(struct wl1271 *wl)
1150{
1151	int ret = 0;
1152
1153	wl1271_notice("power down");
1154
1155	/*
1156	 * Interrupts must be disabled before setting the state to OFF.
1157	 * Otherwise, the interrupt handler might be called and exit without
1158	 * reading the interrupt status.
1159	 */
1160	wlcore_disable_interrupts(wl);
1161	mutex_lock(&wl->mutex);
1162	if (!wl->plt) {
1163		mutex_unlock(&wl->mutex);
1164
1165		/*
1166		 * This will not necessarily enable interrupts as interrupts
1167		 * may have been disabled when op_stop was called. It will,
1168		 * however, balance the above call to disable_interrupts().
1169		 */
1170		wlcore_enable_interrupts(wl);
1171
1172		wl1271_error("cannot power down because not in PLT "
1173			     "state: %d", wl->state);
1174		ret = -EBUSY;
1175		goto out;
1176	}
1177
1178	mutex_unlock(&wl->mutex);
1179
1180	wl1271_flush_deferred_work(wl);
1181	cancel_work_sync(&wl->netstack_work);
1182	cancel_work_sync(&wl->recovery_work);
1183	cancel_delayed_work_sync(&wl->tx_watchdog_work);
1184
1185	mutex_lock(&wl->mutex);
1186	wl1271_power_off(wl);
1187	wl->flags = 0;
1188	wl->sleep_auth = WL1271_PSM_ILLEGAL;
1189	wl->state = WLCORE_STATE_OFF;
1190	wl->plt = false;
1191	wl->plt_mode = PLT_OFF;
1192	wl->rx_counter = 0;
1193	mutex_unlock(&wl->mutex);
1194
1195out:
1196	return ret;
1197}
1198
1199static void wl1271_op_tx(struct ieee80211_hw *hw,
1200			 struct ieee80211_tx_control *control,
1201			 struct sk_buff *skb)
1202{
1203	struct wl1271 *wl = hw->priv;
1204	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1205	struct ieee80211_vif *vif = info->control.vif;
1206	struct wl12xx_vif *wlvif = NULL;
1207	unsigned long flags;
1208	int q, mapping;
1209	u8 hlid;
1210
1211	if (!vif) {
1212		wl1271_debug(DEBUG_TX, "DROP skb with no vif");
1213		ieee80211_free_txskb(hw, skb);
1214		return;
1215	}
1216
1217	wlvif = wl12xx_vif_to_data(vif);
1218	mapping = skb_get_queue_mapping(skb);
1219	q = wl1271_tx_get_queue(mapping);
1220
1221	hlid = wl12xx_tx_get_hlid(wl, wlvif, skb, control->sta);
1222
1223	spin_lock_irqsave(&wl->wl_lock, flags);
1224
1225	/*
1226	 * drop the packet if the link is invalid or the queue is stopped
1227	 * for any reason but watermark. Watermark is a "soft"-stop so we
1228	 * allow these packets through.
1229	 */
1230	if (hlid == WL12XX_INVALID_LINK_ID ||
1231	    (!test_bit(hlid, wlvif->links_map)) ||
1232	     (wlcore_is_queue_stopped_locked(wl, wlvif, q) &&
1233	      !wlcore_is_queue_stopped_by_reason_locked(wl, wlvif, q,
1234			WLCORE_QUEUE_STOP_REASON_WATERMARK))) {
1235		wl1271_debug(DEBUG_TX, "DROP skb hlid %d q %d", hlid, q);
1236		ieee80211_free_txskb(hw, skb);
1237		goto out;
1238	}
1239
1240	wl1271_debug(DEBUG_TX, "queue skb hlid %d q %d len %d",
1241		     hlid, q, skb->len);
1242	skb_queue_tail(&wl->links[hlid].tx_queue[q], skb);
1243
1244	wl->tx_queue_count[q]++;
1245	wlvif->tx_queue_count[q]++;
1246
1247	/*
1248	 * The workqueue is slow to process the tx_queue and we need stop
1249	 * the queue here, otherwise the queue will get too long.
1250	 */
1251	if (wlvif->tx_queue_count[q] >= WL1271_TX_QUEUE_HIGH_WATERMARK &&
1252	    !wlcore_is_queue_stopped_by_reason_locked(wl, wlvif, q,
1253					WLCORE_QUEUE_STOP_REASON_WATERMARK)) {
1254		wl1271_debug(DEBUG_TX, "op_tx: stopping queues for q %d", q);
1255		wlcore_stop_queue_locked(wl, wlvif, q,
1256					 WLCORE_QUEUE_STOP_REASON_WATERMARK);
1257	}
1258
1259	/*
1260	 * The chip specific setup must run before the first TX packet -
1261	 * before that, the tx_work will not be initialized!
1262	 */
1263
1264	if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags) &&
1265	    !test_bit(WL1271_FLAG_TX_PENDING, &wl->flags))
1266		ieee80211_queue_work(wl->hw, &wl->tx_work);
1267
1268out:
1269	spin_unlock_irqrestore(&wl->wl_lock, flags);
1270}
1271
1272int wl1271_tx_dummy_packet(struct wl1271 *wl)
1273{
1274	unsigned long flags;
1275	int q;
1276
1277	/* no need to queue a new dummy packet if one is already pending */
1278	if (test_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags))
1279		return 0;
1280
1281	q = wl1271_tx_get_queue(skb_get_queue_mapping(wl->dummy_packet));
1282
1283	spin_lock_irqsave(&wl->wl_lock, flags);
1284	set_bit(WL1271_FLAG_DUMMY_PACKET_PENDING, &wl->flags);
1285	wl->tx_queue_count[q]++;
1286	spin_unlock_irqrestore(&wl->wl_lock, flags);
1287
1288	/* The FW is low on RX memory blocks, so send the dummy packet asap */
1289	if (!test_bit(WL1271_FLAG_FW_TX_BUSY, &wl->flags))
1290		return wlcore_tx_work_locked(wl);
1291
1292	/*
1293	 * If the FW TX is busy, TX work will be scheduled by the threaded
1294	 * interrupt handler function
1295	 */
1296	return 0;
1297}
1298
1299/*
1300 * The size of the dummy packet should be at least 1400 bytes. However, in
1301 * order to minimize the number of bus transactions, aligning it to 512 bytes
1302 * boundaries could be beneficial, performance wise
1303 */
1304#define TOTAL_TX_DUMMY_PACKET_SIZE (ALIGN(1400, 512))
1305
1306static struct sk_buff *wl12xx_alloc_dummy_packet(struct wl1271 *wl)
1307{
1308	struct sk_buff *skb;
1309	struct ieee80211_hdr_3addr *hdr;
1310	unsigned int dummy_packet_size;
1311
1312	dummy_packet_size = TOTAL_TX_DUMMY_PACKET_SIZE -
1313			    sizeof(struct wl1271_tx_hw_descr) - sizeof(*hdr);
1314
1315	skb = dev_alloc_skb(TOTAL_TX_DUMMY_PACKET_SIZE);
1316	if (!skb) {
1317		wl1271_warning("Failed to allocate a dummy packet skb");
1318		return NULL;
1319	}
1320
1321	skb_reserve(skb, sizeof(struct wl1271_tx_hw_descr));
1322
1323	hdr = skb_put_zero(skb, sizeof(*hdr));
1324	hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_DATA |
1325					 IEEE80211_STYPE_NULLFUNC |
1326					 IEEE80211_FCTL_TODS);
1327
1328	skb_put_zero(skb, dummy_packet_size);
1329
1330	/* Dummy packets require the TID to be management */
1331	skb->priority = WL1271_TID_MGMT;
1332
1333	/* Initialize all fields that might be used */
1334	skb_set_queue_mapping(skb, 0);
1335	memset(IEEE80211_SKB_CB(skb), 0, sizeof(struct ieee80211_tx_info));
1336
1337	return skb;
1338}
1339
1340
1341static int
1342wl1271_validate_wowlan_pattern(struct cfg80211_pkt_pattern *p)
1343{
1344	int num_fields = 0, in_field = 0, fields_size = 0;
1345	int i, pattern_len = 0;
1346
1347	if (!p->mask) {
1348		wl1271_warning("No mask in WoWLAN pattern");
1349		return -EINVAL;
1350	}
1351
1352	/*
1353	 * The pattern is broken up into segments of bytes at different offsets
1354	 * that need to be checked by the FW filter. Each segment is called
1355	 * a field in the FW API. We verify that the total number of fields
1356	 * required for this pattern won't exceed FW limits (8)
1357	 * as well as the total fields buffer won't exceed the FW limit.
1358	 * Note that if there's a pattern which crosses Ethernet/IP header
1359	 * boundary a new field is required.
1360	 */
1361	for (i = 0; i < p->pattern_len; i++) {
1362		if (test_bit(i, (unsigned long *)p->mask)) {
1363			if (!in_field) {
1364				in_field = 1;
1365				pattern_len = 1;
1366			} else {
1367				if (i == WL1271_RX_FILTER_ETH_HEADER_SIZE) {
1368					num_fields++;
1369					fields_size += pattern_len +
1370						RX_FILTER_FIELD_OVERHEAD;
1371					pattern_len = 1;
1372				} else
1373					pattern_len++;
1374			}
1375		} else {
1376			if (in_field) {
1377				in_field = 0;
1378				fields_size += pattern_len +
1379					RX_FILTER_FIELD_OVERHEAD;
1380				num_fields++;
1381			}
1382		}
1383	}
1384
1385	if (in_field) {
1386		fields_size += pattern_len + RX_FILTER_FIELD_OVERHEAD;
1387		num_fields++;
1388	}
1389
1390	if (num_fields > WL1271_RX_FILTER_MAX_FIELDS) {
1391		wl1271_warning("RX Filter too complex. Too many segments");
1392		return -EINVAL;
1393	}
1394
1395	if (fields_size > WL1271_RX_FILTER_MAX_FIELDS_SIZE) {
1396		wl1271_warning("RX filter pattern is too big");
1397		return -E2BIG;
1398	}
1399
1400	return 0;
1401}
1402
1403struct wl12xx_rx_filter *wl1271_rx_filter_alloc(void)
1404{
1405	return kzalloc(sizeof(struct wl12xx_rx_filter), GFP_KERNEL);
1406}
1407
1408void wl1271_rx_filter_free(struct wl12xx_rx_filter *filter)
1409{
1410	int i;
1411
1412	if (filter == NULL)
1413		return;
1414
1415	for (i = 0; i < filter->num_fields; i++)
1416		kfree(filter->fields[i].pattern);
1417
1418	kfree(filter);
1419}
1420
1421int wl1271_rx_filter_alloc_field(struct wl12xx_rx_filter *filter,
1422				 u16 offset, u8 flags,
1423				 const u8 *pattern, u8 len)
1424{
1425	struct wl12xx_rx_filter_field *field;
1426
1427	if (filter->num_fields == WL1271_RX_FILTER_MAX_FIELDS) {
1428		wl1271_warning("Max fields per RX filter. can't alloc another");
1429		return -EINVAL;
1430	}
1431
1432	field = &filter->fields[filter->num_fields];
1433
1434	field->pattern = kmemdup(pattern, len, GFP_KERNEL);
1435	if (!field->pattern) {
1436		wl1271_warning("Failed to allocate RX filter pattern");
1437		return -ENOMEM;
1438	}
1439
1440	filter->num_fields++;
1441
1442	field->offset = cpu_to_le16(offset);
1443	field->flags = flags;
1444	field->len = len;
1445
1446	return 0;
1447}
1448
1449int wl1271_rx_filter_get_fields_size(struct wl12xx_rx_filter *filter)
1450{
1451	int i, fields_size = 0;
1452
1453	for (i = 0; i < filter->num_fields; i++)
1454		fields_size += filter->fields[i].len +
1455			sizeof(struct wl12xx_rx_filter_field) -
1456			sizeof(u8 *);
1457
1458	return fields_size;
1459}
1460
1461void wl1271_rx_filter_flatten_fields(struct wl12xx_rx_filter *filter,
1462				    u8 *buf)
1463{
1464	int i;
1465	struct wl12xx_rx_filter_field *field;
1466
1467	for (i = 0; i < filter->num_fields; i++) {
1468		field = (struct wl12xx_rx_filter_field *)buf;
1469
1470		field->offset = filter->fields[i].offset;
1471		field->flags = filter->fields[i].flags;
1472		field->len = filter->fields[i].len;
1473
1474		memcpy(&field->pattern, filter->fields[i].pattern, field->len);
1475		buf += sizeof(struct wl12xx_rx_filter_field) -
1476			sizeof(u8 *) + field->len;
1477	}
1478}
1479
1480/*
1481 * Allocates an RX filter returned through f
1482 * which needs to be freed using rx_filter_free()
1483 */
1484static int
1485wl1271_convert_wowlan_pattern_to_rx_filter(struct cfg80211_pkt_pattern *p,
1486					   struct wl12xx_rx_filter **f)
1487{
1488	int i, j, ret = 0;
1489	struct wl12xx_rx_filter *filter;
1490	u16 offset;
1491	u8 flags, len;
1492
1493	filter = wl1271_rx_filter_alloc();
1494	if (!filter) {
1495		wl1271_warning("Failed to alloc rx filter");
1496		ret = -ENOMEM;
1497		goto err;
1498	}
1499
1500	i = 0;
1501	while (i < p->pattern_len) {
1502		if (!test_bit(i, (unsigned long *)p->mask)) {
1503			i++;
1504			continue;
1505		}
1506
1507		for (j = i; j < p->pattern_len; j++) {
1508			if (!test_bit(j, (unsigned long *)p->mask))
1509				break;
1510
1511			if (i < WL1271_RX_FILTER_ETH_HEADER_SIZE &&
1512			    j >= WL1271_RX_FILTER_ETH_HEADER_SIZE)
1513				break;
1514		}
1515
1516		if (i < WL1271_RX_FILTER_ETH_HEADER_SIZE) {
1517			offset = i;
1518			flags = WL1271_RX_FILTER_FLAG_ETHERNET_HEADER;
1519		} else {
1520			offset = i - WL1271_RX_FILTER_ETH_HEADER_SIZE;
1521			flags = WL1271_RX_FILTER_FLAG_IP_HEADER;
1522		}
1523
1524		len = j - i;
1525
1526		ret = wl1271_rx_filter_alloc_field(filter,
1527						   offset,
1528						   flags,
1529						   &p->pattern[i], len);
1530		if (ret)
1531			goto err;
1532
1533		i = j;
1534	}
1535
1536	filter->action = FILTER_SIGNAL;
1537
1538	*f = filter;
1539	return 0;
1540
1541err:
1542	wl1271_rx_filter_free(filter);
1543	*f = NULL;
1544
1545	return ret;
1546}
1547
1548static int wl1271_configure_wowlan(struct wl1271 *wl,
1549				   struct cfg80211_wowlan *wow)
1550{
1551	int i, ret;
1552
1553	if (!wow || wow->any || !wow->n_patterns) {
1554		ret = wl1271_acx_default_rx_filter_enable(wl, 0,
1555							  FILTER_SIGNAL);
1556		if (ret)
1557			goto out;
1558
1559		ret = wl1271_rx_filter_clear_all(wl);
1560		if (ret)
1561			goto out;
1562
1563		return 0;
1564	}
1565
1566	if (WARN_ON(wow->n_patterns > WL1271_MAX_RX_FILTERS))
1567		return -EINVAL;
1568
1569	/* Validate all incoming patterns before clearing current FW state */
1570	for (i = 0; i < wow->n_patterns; i++) {
1571		ret = wl1271_validate_wowlan_pattern(&wow->patterns[i]);
1572		if (ret) {
1573			wl1271_warning("Bad wowlan pattern %d", i);
1574			return ret;
1575		}
1576	}
1577
1578	ret = wl1271_acx_default_rx_filter_enable(wl, 0, FILTER_SIGNAL);
1579	if (ret)
1580		goto out;
1581
1582	ret = wl1271_rx_filter_clear_all(wl);
1583	if (ret)
1584		goto out;
1585
1586	/* Translate WoWLAN patterns into filters */
1587	for (i = 0; i < wow->n_patterns; i++) {
1588		struct cfg80211_pkt_pattern *p;
1589		struct wl12xx_rx_filter *filter = NULL;
1590
1591		p = &wow->patterns[i];
1592
1593		ret = wl1271_convert_wowlan_pattern_to_rx_filter(p, &filter);
1594		if (ret) {
1595			wl1271_warning("Failed to create an RX filter from "
1596				       "wowlan pattern %d", i);
1597			goto out;
1598		}
1599
1600		ret = wl1271_rx_filter_enable(wl, i, 1, filter);
1601
1602		wl1271_rx_filter_free(filter);
1603		if (ret)
1604			goto out;
1605	}
1606
1607	ret = wl1271_acx_default_rx_filter_enable(wl, 1, FILTER_DROP);
1608
1609out:
1610	return ret;
1611}
1612
1613static int wl1271_configure_suspend_sta(struct wl1271 *wl,
1614					struct wl12xx_vif *wlvif,
1615					struct cfg80211_wowlan *wow)
1616{
1617	int ret = 0;
1618
1619	if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
1620		goto out;
1621
1622	ret = wl1271_configure_wowlan(wl, wow);
1623	if (ret < 0)
1624		goto out;
1625
1626	if ((wl->conf.conn.suspend_wake_up_event ==
1627	     wl->conf.conn.wake_up_event) &&
1628	    (wl->conf.conn.suspend_listen_interval ==
1629	     wl->conf.conn.listen_interval))
1630		goto out;
1631
1632	ret = wl1271_acx_wake_up_conditions(wl, wlvif,
1633				    wl->conf.conn.suspend_wake_up_event,
1634				    wl->conf.conn.suspend_listen_interval);
1635
1636	if (ret < 0)
1637		wl1271_error("suspend: set wake up conditions failed: %d", ret);
1638out:
1639	return ret;
1640
1641}
1642
1643static int wl1271_configure_suspend_ap(struct wl1271 *wl,
1644					struct wl12xx_vif *wlvif,
1645					struct cfg80211_wowlan *wow)
1646{
1647	int ret = 0;
1648
1649	if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags))
1650		goto out;
1651
1652	ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true);
1653	if (ret < 0)
1654		goto out;
1655
1656	ret = wl1271_configure_wowlan(wl, wow);
1657	if (ret < 0)
1658		goto out;
1659
1660out:
1661	return ret;
1662
1663}
1664
1665static int wl1271_configure_suspend(struct wl1271 *wl,
1666				    struct wl12xx_vif *wlvif,
1667				    struct cfg80211_wowlan *wow)
1668{
1669	if (wlvif->bss_type == BSS_TYPE_STA_BSS)
1670		return wl1271_configure_suspend_sta(wl, wlvif, wow);
1671	if (wlvif->bss_type == BSS_TYPE_AP_BSS)
1672		return wl1271_configure_suspend_ap(wl, wlvif, wow);
1673	return 0;
1674}
1675
1676static void wl1271_configure_resume(struct wl1271 *wl, struct wl12xx_vif *wlvif)
1677{
1678	int ret = 0;
1679	bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
1680	bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
1681
1682	if ((!is_ap) && (!is_sta))
1683		return;
1684
1685	if ((is_sta && !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) ||
1686	    (is_ap && !test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)))
1687		return;
1688
1689	wl1271_configure_wowlan(wl, NULL);
1690
1691	if (is_sta) {
1692		if ((wl->conf.conn.suspend_wake_up_event ==
1693		     wl->conf.conn.wake_up_event) &&
1694		    (wl->conf.conn.suspend_listen_interval ==
1695		     wl->conf.conn.listen_interval))
1696			return;
1697
1698		ret = wl1271_acx_wake_up_conditions(wl, wlvif,
1699				    wl->conf.conn.wake_up_event,
1700				    wl->conf.conn.listen_interval);
1701
1702		if (ret < 0)
1703			wl1271_error("resume: wake up conditions failed: %d",
1704				     ret);
1705
1706	} else if (is_ap) {
1707		ret = wl1271_acx_beacon_filter_opt(wl, wlvif, false);
1708	}
1709}
1710
1711static int __maybe_unused wl1271_op_suspend(struct ieee80211_hw *hw,
1712					    struct cfg80211_wowlan *wow)
1713{
1714	struct wl1271 *wl = hw->priv;
1715	struct wl12xx_vif *wlvif;
1716	unsigned long flags;
1717	int ret;
1718
1719	wl1271_debug(DEBUG_MAC80211, "mac80211 suspend wow=%d", !!wow);
1720	WARN_ON(!wow);
1721
1722	/* we want to perform the recovery before suspending */
1723	if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
1724		wl1271_warning("postponing suspend to perform recovery");
1725		return -EBUSY;
1726	}
1727
1728	wl1271_tx_flush(wl);
1729
1730	mutex_lock(&wl->mutex);
1731
1732	ret = pm_runtime_resume_and_get(wl->dev);
1733	if (ret < 0) {
 
1734		mutex_unlock(&wl->mutex);
1735		return ret;
1736	}
1737
1738	wl->wow_enabled = true;
1739	wl12xx_for_each_wlvif(wl, wlvif) {
1740		if (wlcore_is_p2p_mgmt(wlvif))
1741			continue;
1742
1743		ret = wl1271_configure_suspend(wl, wlvif, wow);
1744		if (ret < 0) {
1745			goto out_sleep;
1746		}
1747	}
1748
1749	/* disable fast link flow control notifications from FW */
1750	ret = wlcore_hw_interrupt_notify(wl, false);
1751	if (ret < 0)
1752		goto out_sleep;
1753
1754	/* if filtering is enabled, configure the FW to drop all RX BA frames */
1755	ret = wlcore_hw_rx_ba_filter(wl,
1756				     !!wl->conf.conn.suspend_rx_ba_activity);
1757	if (ret < 0)
1758		goto out_sleep;
1759
1760out_sleep:
1761	pm_runtime_put_noidle(wl->dev);
1762	mutex_unlock(&wl->mutex);
1763
1764	if (ret < 0) {
1765		wl1271_warning("couldn't prepare device to suspend");
1766		return ret;
1767	}
1768
1769	/* flush any remaining work */
1770	wl1271_debug(DEBUG_MAC80211, "flushing remaining works");
1771
1772	flush_work(&wl->tx_work);
1773
1774	/*
1775	 * Cancel the watchdog even if above tx_flush failed. We will detect
1776	 * it on resume anyway.
1777	 */
1778	cancel_delayed_work(&wl->tx_watchdog_work);
1779
1780	/*
1781	 * set suspended flag to avoid triggering a new threaded_irq
1782	 * work.
1783	 */
1784	spin_lock_irqsave(&wl->wl_lock, flags);
1785	set_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1786	spin_unlock_irqrestore(&wl->wl_lock, flags);
1787
1788	return pm_runtime_force_suspend(wl->dev);
1789}
1790
1791static int __maybe_unused wl1271_op_resume(struct ieee80211_hw *hw)
1792{
1793	struct wl1271 *wl = hw->priv;
1794	struct wl12xx_vif *wlvif;
1795	unsigned long flags;
1796	bool run_irq_work = false, pending_recovery;
1797	int ret;
1798
1799	wl1271_debug(DEBUG_MAC80211, "mac80211 resume wow=%d",
1800		     wl->wow_enabled);
1801	WARN_ON(!wl->wow_enabled);
1802
1803	ret = pm_runtime_force_resume(wl->dev);
1804	if (ret < 0) {
1805		wl1271_error("ELP wakeup failure!");
1806		goto out_sleep;
1807	}
1808
1809	/*
1810	 * re-enable irq_work enqueuing, and call irq_work directly if
1811	 * there is a pending work.
1812	 */
1813	spin_lock_irqsave(&wl->wl_lock, flags);
1814	clear_bit(WL1271_FLAG_SUSPENDED, &wl->flags);
1815	if (test_and_clear_bit(WL1271_FLAG_PENDING_WORK, &wl->flags))
1816		run_irq_work = true;
1817	spin_unlock_irqrestore(&wl->wl_lock, flags);
1818
1819	mutex_lock(&wl->mutex);
1820
1821	/* test the recovery flag before calling any SDIO functions */
1822	pending_recovery = test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS,
1823				    &wl->flags);
1824
1825	if (run_irq_work) {
1826		wl1271_debug(DEBUG_MAC80211,
1827			     "run postponed irq_work directly");
1828
1829		/* don't talk to the HW if recovery is pending */
1830		if (!pending_recovery) {
1831			ret = wlcore_irq_locked(wl);
1832			if (ret)
1833				wl12xx_queue_recovery_work(wl);
1834		}
1835
1836		wlcore_enable_interrupts(wl);
1837	}
1838
1839	if (pending_recovery) {
1840		wl1271_warning("queuing forgotten recovery on resume");
1841		ieee80211_queue_work(wl->hw, &wl->recovery_work);
1842		goto out_sleep;
1843	}
1844
1845	ret = pm_runtime_resume_and_get(wl->dev);
1846	if (ret < 0)
 
1847		goto out;
 
1848
1849	wl12xx_for_each_wlvif(wl, wlvif) {
1850		if (wlcore_is_p2p_mgmt(wlvif))
1851			continue;
1852
1853		wl1271_configure_resume(wl, wlvif);
1854	}
1855
1856	ret = wlcore_hw_interrupt_notify(wl, true);
1857	if (ret < 0)
1858		goto out_sleep;
1859
1860	/* if filtering is enabled, configure the FW to drop all RX BA frames */
1861	ret = wlcore_hw_rx_ba_filter(wl, false);
1862	if (ret < 0)
1863		goto out_sleep;
1864
1865out_sleep:
1866	pm_runtime_mark_last_busy(wl->dev);
1867	pm_runtime_put_autosuspend(wl->dev);
1868
1869out:
1870	wl->wow_enabled = false;
1871
1872	/*
1873	 * Set a flag to re-init the watchdog on the first Tx after resume.
1874	 * That way we avoid possible conditions where Tx-complete interrupts
1875	 * fail to arrive and we perform a spurious recovery.
1876	 */
1877	set_bit(WL1271_FLAG_REINIT_TX_WDOG, &wl->flags);
1878	mutex_unlock(&wl->mutex);
1879
1880	return 0;
1881}
1882
1883static int wl1271_op_start(struct ieee80211_hw *hw)
1884{
1885	wl1271_debug(DEBUG_MAC80211, "mac80211 start");
1886
1887	/*
1888	 * We have to delay the booting of the hardware because
1889	 * we need to know the local MAC address before downloading and
1890	 * initializing the firmware. The MAC address cannot be changed
1891	 * after boot, and without the proper MAC address, the firmware
1892	 * will not function properly.
1893	 *
1894	 * The MAC address is first known when the corresponding interface
1895	 * is added. That is where we will initialize the hardware.
1896	 */
1897
1898	return 0;
1899}
1900
1901static void wlcore_op_stop_locked(struct wl1271 *wl)
1902{
1903	int i;
1904
1905	if (wl->state == WLCORE_STATE_OFF) {
1906		if (test_and_clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS,
1907					&wl->flags))
1908			wlcore_enable_interrupts(wl);
1909
1910		return;
1911	}
1912
1913	/*
1914	 * this must be before the cancel_work calls below, so that the work
1915	 * functions don't perform further work.
1916	 */
1917	wl->state = WLCORE_STATE_OFF;
1918
1919	/*
1920	 * Use the nosync variant to disable interrupts, so the mutex could be
1921	 * held while doing so without deadlocking.
1922	 */
1923	wlcore_disable_interrupts_nosync(wl);
1924
1925	mutex_unlock(&wl->mutex);
1926
1927	wlcore_synchronize_interrupts(wl);
1928	if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
1929		cancel_work_sync(&wl->recovery_work);
1930	wl1271_flush_deferred_work(wl);
1931	cancel_delayed_work_sync(&wl->scan_complete_work);
1932	cancel_work_sync(&wl->netstack_work);
1933	cancel_work_sync(&wl->tx_work);
1934	cancel_delayed_work_sync(&wl->tx_watchdog_work);
1935
1936	/* let's notify MAC80211 about the remaining pending TX frames */
1937	mutex_lock(&wl->mutex);
1938	wl12xx_tx_reset(wl);
1939
1940	wl1271_power_off(wl);
1941	/*
1942	 * In case a recovery was scheduled, interrupts were disabled to avoid
1943	 * an interrupt storm. Now that the power is down, it is safe to
1944	 * re-enable interrupts to balance the disable depth
1945	 */
1946	if (test_and_clear_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags))
1947		wlcore_enable_interrupts(wl);
1948
1949	wl->band = NL80211_BAND_2GHZ;
1950
1951	wl->rx_counter = 0;
1952	wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
1953	wl->channel_type = NL80211_CHAN_NO_HT;
1954	wl->tx_blocks_available = 0;
1955	wl->tx_allocated_blocks = 0;
1956	wl->tx_results_count = 0;
1957	wl->tx_packets_count = 0;
1958	wl->time_offset = 0;
1959	wl->ap_fw_ps_map = 0;
1960	wl->ap_ps_map = 0;
1961	wl->sleep_auth = WL1271_PSM_ILLEGAL;
1962	memset(wl->roles_map, 0, sizeof(wl->roles_map));
1963	memset(wl->links_map, 0, sizeof(wl->links_map));
1964	memset(wl->roc_map, 0, sizeof(wl->roc_map));
1965	memset(wl->session_ids, 0, sizeof(wl->session_ids));
1966	memset(wl->rx_filter_enabled, 0, sizeof(wl->rx_filter_enabled));
1967	wl->active_sta_count = 0;
1968	wl->active_link_count = 0;
1969
1970	/* The system link is always allocated */
1971	wl->links[WL12XX_SYSTEM_HLID].allocated_pkts = 0;
1972	wl->links[WL12XX_SYSTEM_HLID].prev_freed_pkts = 0;
1973	__set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
1974
1975	/*
1976	 * this is performed after the cancel_work calls and the associated
1977	 * mutex_lock, so that wl1271_op_add_interface does not accidentally
1978	 * get executed before all these vars have been reset.
1979	 */
1980	wl->flags = 0;
1981
1982	wl->tx_blocks_freed = 0;
1983
1984	for (i = 0; i < NUM_TX_QUEUES; i++) {
1985		wl->tx_pkts_freed[i] = 0;
1986		wl->tx_allocated_pkts[i] = 0;
1987	}
1988
1989	wl1271_debugfs_reset(wl);
1990
1991	kfree(wl->raw_fw_status);
1992	wl->raw_fw_status = NULL;
1993	kfree(wl->fw_status);
1994	wl->fw_status = NULL;
1995	kfree(wl->tx_res_if);
1996	wl->tx_res_if = NULL;
1997	kfree(wl->target_mem_map);
1998	wl->target_mem_map = NULL;
1999
2000	/*
2001	 * FW channels must be re-calibrated after recovery,
2002	 * save current Reg-Domain channel configuration and clear it.
2003	 */
2004	memcpy(wl->reg_ch_conf_pending, wl->reg_ch_conf_last,
2005	       sizeof(wl->reg_ch_conf_pending));
2006	memset(wl->reg_ch_conf_last, 0, sizeof(wl->reg_ch_conf_last));
2007}
2008
2009static void wlcore_op_stop(struct ieee80211_hw *hw)
2010{
2011	struct wl1271 *wl = hw->priv;
2012
2013	wl1271_debug(DEBUG_MAC80211, "mac80211 stop");
2014
2015	mutex_lock(&wl->mutex);
2016
2017	wlcore_op_stop_locked(wl);
2018
2019	mutex_unlock(&wl->mutex);
2020}
2021
2022static void wlcore_channel_switch_work(struct work_struct *work)
2023{
2024	struct delayed_work *dwork;
2025	struct wl1271 *wl;
2026	struct ieee80211_vif *vif;
2027	struct wl12xx_vif *wlvif;
2028	int ret;
2029
2030	dwork = to_delayed_work(work);
2031	wlvif = container_of(dwork, struct wl12xx_vif, channel_switch_work);
2032	wl = wlvif->wl;
2033
2034	wl1271_info("channel switch failed (role_id: %d).", wlvif->role_id);
2035
2036	mutex_lock(&wl->mutex);
2037
2038	if (unlikely(wl->state != WLCORE_STATE_ON))
2039		goto out;
2040
2041	/* check the channel switch is still ongoing */
2042	if (!test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags))
2043		goto out;
2044
2045	vif = wl12xx_wlvif_to_vif(wlvif);
2046	ieee80211_chswitch_done(vif, false);
2047
2048	ret = pm_runtime_resume_and_get(wl->dev);
2049	if (ret < 0)
 
2050		goto out;
 
2051
2052	wl12xx_cmd_stop_channel_switch(wl, wlvif);
2053
2054	pm_runtime_mark_last_busy(wl->dev);
2055	pm_runtime_put_autosuspend(wl->dev);
2056out:
2057	mutex_unlock(&wl->mutex);
2058}
2059
2060static void wlcore_connection_loss_work(struct work_struct *work)
2061{
2062	struct delayed_work *dwork;
2063	struct wl1271 *wl;
2064	struct ieee80211_vif *vif;
2065	struct wl12xx_vif *wlvif;
2066
2067	dwork = to_delayed_work(work);
2068	wlvif = container_of(dwork, struct wl12xx_vif, connection_loss_work);
2069	wl = wlvif->wl;
2070
2071	wl1271_info("Connection loss work (role_id: %d).", wlvif->role_id);
2072
2073	mutex_lock(&wl->mutex);
2074
2075	if (unlikely(wl->state != WLCORE_STATE_ON))
2076		goto out;
2077
2078	/* Call mac80211 connection loss */
2079	if (!test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2080		goto out;
2081
2082	vif = wl12xx_wlvif_to_vif(wlvif);
2083	ieee80211_connection_loss(vif);
2084out:
2085	mutex_unlock(&wl->mutex);
2086}
2087
2088static void wlcore_pending_auth_complete_work(struct work_struct *work)
2089{
2090	struct delayed_work *dwork;
2091	struct wl1271 *wl;
2092	struct wl12xx_vif *wlvif;
2093	unsigned long time_spare;
2094	int ret;
2095
2096	dwork = to_delayed_work(work);
2097	wlvif = container_of(dwork, struct wl12xx_vif,
2098			     pending_auth_complete_work);
2099	wl = wlvif->wl;
2100
2101	mutex_lock(&wl->mutex);
2102
2103	if (unlikely(wl->state != WLCORE_STATE_ON))
2104		goto out;
2105
2106	/*
2107	 * Make sure a second really passed since the last auth reply. Maybe
2108	 * a second auth reply arrived while we were stuck on the mutex.
2109	 * Check for a little less than the timeout to protect from scheduler
2110	 * irregularities.
2111	 */
2112	time_spare = jiffies +
2113			msecs_to_jiffies(WLCORE_PEND_AUTH_ROC_TIMEOUT - 50);
2114	if (!time_after(time_spare, wlvif->pending_auth_reply_time))
2115		goto out;
2116
2117	ret = pm_runtime_resume_and_get(wl->dev);
2118	if (ret < 0)
 
2119		goto out;
 
2120
2121	/* cancel the ROC if active */
2122	wlcore_update_inconn_sta(wl, wlvif, NULL, false);
2123
2124	pm_runtime_mark_last_busy(wl->dev);
2125	pm_runtime_put_autosuspend(wl->dev);
2126out:
2127	mutex_unlock(&wl->mutex);
2128}
2129
2130static int wl12xx_allocate_rate_policy(struct wl1271 *wl, u8 *idx)
2131{
2132	u8 policy = find_first_zero_bit(wl->rate_policies_map,
2133					WL12XX_MAX_RATE_POLICIES);
2134	if (policy >= WL12XX_MAX_RATE_POLICIES)
2135		return -EBUSY;
2136
2137	__set_bit(policy, wl->rate_policies_map);
2138	*idx = policy;
2139	return 0;
2140}
2141
2142static void wl12xx_free_rate_policy(struct wl1271 *wl, u8 *idx)
2143{
2144	if (WARN_ON(*idx >= WL12XX_MAX_RATE_POLICIES))
2145		return;
2146
2147	__clear_bit(*idx, wl->rate_policies_map);
2148	*idx = WL12XX_MAX_RATE_POLICIES;
2149}
2150
2151static int wlcore_allocate_klv_template(struct wl1271 *wl, u8 *idx)
2152{
2153	u8 policy = find_first_zero_bit(wl->klv_templates_map,
2154					WLCORE_MAX_KLV_TEMPLATES);
2155	if (policy >= WLCORE_MAX_KLV_TEMPLATES)
2156		return -EBUSY;
2157
2158	__set_bit(policy, wl->klv_templates_map);
2159	*idx = policy;
2160	return 0;
2161}
2162
2163static void wlcore_free_klv_template(struct wl1271 *wl, u8 *idx)
2164{
2165	if (WARN_ON(*idx >= WLCORE_MAX_KLV_TEMPLATES))
2166		return;
2167
2168	__clear_bit(*idx, wl->klv_templates_map);
2169	*idx = WLCORE_MAX_KLV_TEMPLATES;
2170}
2171
2172static u8 wl12xx_get_role_type(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2173{
2174	struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2175
2176	switch (wlvif->bss_type) {
2177	case BSS_TYPE_AP_BSS:
2178		if (wlvif->p2p)
2179			return WL1271_ROLE_P2P_GO;
2180		else if (ieee80211_vif_is_mesh(vif))
2181			return WL1271_ROLE_MESH_POINT;
2182		else
2183			return WL1271_ROLE_AP;
2184
2185	case BSS_TYPE_STA_BSS:
2186		if (wlvif->p2p)
2187			return WL1271_ROLE_P2P_CL;
2188		else
2189			return WL1271_ROLE_STA;
2190
2191	case BSS_TYPE_IBSS:
2192		return WL1271_ROLE_IBSS;
2193
2194	default:
2195		wl1271_error("invalid bss_type: %d", wlvif->bss_type);
2196	}
2197	return WL12XX_INVALID_ROLE_TYPE;
2198}
2199
2200static int wl12xx_init_vif_data(struct wl1271 *wl, struct ieee80211_vif *vif)
2201{
2202	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2203	int i;
2204
2205	/* clear everything but the persistent data */
2206	memset(wlvif, 0, offsetof(struct wl12xx_vif, persistent));
2207
2208	switch (ieee80211_vif_type_p2p(vif)) {
2209	case NL80211_IFTYPE_P2P_CLIENT:
2210		wlvif->p2p = 1;
2211		fallthrough;
2212	case NL80211_IFTYPE_STATION:
2213	case NL80211_IFTYPE_P2P_DEVICE:
2214		wlvif->bss_type = BSS_TYPE_STA_BSS;
2215		break;
2216	case NL80211_IFTYPE_ADHOC:
2217		wlvif->bss_type = BSS_TYPE_IBSS;
2218		break;
2219	case NL80211_IFTYPE_P2P_GO:
2220		wlvif->p2p = 1;
2221		fallthrough;
2222	case NL80211_IFTYPE_AP:
2223	case NL80211_IFTYPE_MESH_POINT:
2224		wlvif->bss_type = BSS_TYPE_AP_BSS;
2225		break;
2226	default:
2227		wlvif->bss_type = MAX_BSS_TYPE;
2228		return -EOPNOTSUPP;
2229	}
2230
2231	wlvif->role_id = WL12XX_INVALID_ROLE_ID;
2232	wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
2233	wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
2234
2235	if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2236	    wlvif->bss_type == BSS_TYPE_IBSS) {
2237		/* init sta/ibss data */
2238		wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
2239		wl12xx_allocate_rate_policy(wl, &wlvif->sta.basic_rate_idx);
2240		wl12xx_allocate_rate_policy(wl, &wlvif->sta.ap_rate_idx);
2241		wl12xx_allocate_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
2242		wlcore_allocate_klv_template(wl, &wlvif->sta.klv_template_id);
2243		wlvif->basic_rate_set = CONF_TX_RATE_MASK_BASIC;
2244		wlvif->basic_rate = CONF_TX_RATE_MASK_BASIC;
2245		wlvif->rate_set = CONF_TX_RATE_MASK_BASIC;
2246	} else {
2247		/* init ap data */
2248		wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
2249		wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
2250		wl12xx_allocate_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
2251		wl12xx_allocate_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
2252		for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
2253			wl12xx_allocate_rate_policy(wl,
2254						&wlvif->ap.ucast_rate_idx[i]);
2255		wlvif->basic_rate_set = CONF_TX_ENABLED_RATES;
2256		/*
2257		 * TODO: check if basic_rate shouldn't be
2258		 * wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
2259		 * instead (the same thing for STA above).
2260		*/
2261		wlvif->basic_rate = CONF_TX_ENABLED_RATES;
2262		/* TODO: this seems to be used only for STA, check it */
2263		wlvif->rate_set = CONF_TX_ENABLED_RATES;
2264	}
2265
2266	wlvif->bitrate_masks[NL80211_BAND_2GHZ] = wl->conf.tx.basic_rate;
2267	wlvif->bitrate_masks[NL80211_BAND_5GHZ] = wl->conf.tx.basic_rate_5;
2268	wlvif->beacon_int = WL1271_DEFAULT_BEACON_INT;
2269
2270	/*
2271	 * mac80211 configures some values globally, while we treat them
2272	 * per-interface. thus, on init, we have to copy them from wl
2273	 */
2274	wlvif->band = wl->band;
2275	wlvif->channel = wl->channel;
2276	wlvif->power_level = wl->power_level;
2277	wlvif->channel_type = wl->channel_type;
2278
2279	INIT_WORK(&wlvif->rx_streaming_enable_work,
2280		  wl1271_rx_streaming_enable_work);
2281	INIT_WORK(&wlvif->rx_streaming_disable_work,
2282		  wl1271_rx_streaming_disable_work);
2283	INIT_WORK(&wlvif->rc_update_work, wlcore_rc_update_work);
2284	INIT_DELAYED_WORK(&wlvif->channel_switch_work,
2285			  wlcore_channel_switch_work);
2286	INIT_DELAYED_WORK(&wlvif->connection_loss_work,
2287			  wlcore_connection_loss_work);
2288	INIT_DELAYED_WORK(&wlvif->pending_auth_complete_work,
2289			  wlcore_pending_auth_complete_work);
2290	INIT_LIST_HEAD(&wlvif->list);
2291
2292	timer_setup(&wlvif->rx_streaming_timer, wl1271_rx_streaming_timer, 0);
2293	return 0;
2294}
2295
2296static int wl12xx_init_fw(struct wl1271 *wl)
2297{
2298	int retries = WL1271_BOOT_RETRIES;
2299	bool booted = false;
2300	struct wiphy *wiphy = wl->hw->wiphy;
2301	int ret;
2302
2303	while (retries) {
2304		retries--;
2305		ret = wl12xx_chip_wakeup(wl, false);
2306		if (ret < 0)
2307			goto power_off;
2308
2309		ret = wl->ops->boot(wl);
2310		if (ret < 0)
2311			goto power_off;
2312
2313		ret = wl1271_hw_init(wl);
2314		if (ret < 0)
2315			goto irq_disable;
2316
2317		booted = true;
2318		break;
2319
2320irq_disable:
2321		mutex_unlock(&wl->mutex);
2322		/* Unlocking the mutex in the middle of handling is
2323		   inherently unsafe. In this case we deem it safe to do,
2324		   because we need to let any possibly pending IRQ out of
2325		   the system (and while we are WLCORE_STATE_OFF the IRQ
2326		   work function will not do anything.) Also, any other
2327		   possible concurrent operations will fail due to the
2328		   current state, hence the wl1271 struct should be safe. */
2329		wlcore_disable_interrupts(wl);
2330		wl1271_flush_deferred_work(wl);
2331		cancel_work_sync(&wl->netstack_work);
2332		mutex_lock(&wl->mutex);
2333power_off:
2334		wl1271_power_off(wl);
2335	}
2336
2337	if (!booted) {
2338		wl1271_error("firmware boot failed despite %d retries",
2339			     WL1271_BOOT_RETRIES);
2340		goto out;
2341	}
2342
2343	wl1271_info("firmware booted (%s)", wl->chip.fw_ver_str);
2344
2345	/* update hw/fw version info in wiphy struct */
2346	wiphy->hw_version = wl->chip.id;
2347	strncpy(wiphy->fw_version, wl->chip.fw_ver_str,
2348		sizeof(wiphy->fw_version));
2349
2350	/*
2351	 * Now we know if 11a is supported (info from the NVS), so disable
2352	 * 11a channels if not supported
2353	 */
2354	if (!wl->enable_11a)
2355		wiphy->bands[NL80211_BAND_5GHZ]->n_channels = 0;
2356
2357	wl1271_debug(DEBUG_MAC80211, "11a is %ssupported",
2358		     wl->enable_11a ? "" : "not ");
2359
2360	wl->state = WLCORE_STATE_ON;
2361out:
2362	return ret;
2363}
2364
2365static bool wl12xx_dev_role_started(struct wl12xx_vif *wlvif)
2366{
2367	return wlvif->dev_hlid != WL12XX_INVALID_LINK_ID;
2368}
2369
2370/*
2371 * Check whether a fw switch (i.e. moving from one loaded
2372 * fw to another) is needed. This function is also responsible
2373 * for updating wl->last_vif_count, so it must be called before
2374 * loading a non-plt fw (so the correct fw (single-role/multi-role)
2375 * will be used).
2376 */
2377static bool wl12xx_need_fw_change(struct wl1271 *wl,
2378				  struct vif_counter_data vif_counter_data,
2379				  bool add)
2380{
2381	enum wl12xx_fw_type current_fw = wl->fw_type;
2382	u8 vif_count = vif_counter_data.counter;
2383
2384	if (test_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags))
2385		return false;
2386
2387	/* increase the vif count if this is a new vif */
2388	if (add && !vif_counter_data.cur_vif_running)
2389		vif_count++;
2390
2391	wl->last_vif_count = vif_count;
2392
2393	/* no need for fw change if the device is OFF */
2394	if (wl->state == WLCORE_STATE_OFF)
2395		return false;
2396
2397	/* no need for fw change if a single fw is used */
2398	if (!wl->mr_fw_name)
2399		return false;
2400
2401	if (vif_count > 1 && current_fw == WL12XX_FW_TYPE_NORMAL)
2402		return true;
2403	if (vif_count <= 1 && current_fw == WL12XX_FW_TYPE_MULTI)
2404		return true;
2405
2406	return false;
2407}
2408
2409/*
2410 * Enter "forced psm". Make sure the sta is in psm against the ap,
2411 * to make the fw switch a bit more disconnection-persistent.
2412 */
2413static void wl12xx_force_active_psm(struct wl1271 *wl)
2414{
2415	struct wl12xx_vif *wlvif;
2416
2417	wl12xx_for_each_wlvif_sta(wl, wlvif) {
2418		wl1271_ps_set_mode(wl, wlvif, STATION_POWER_SAVE_MODE);
2419	}
2420}
2421
2422struct wlcore_hw_queue_iter_data {
2423	unsigned long hw_queue_map[BITS_TO_LONGS(WLCORE_NUM_MAC_ADDRESSES)];
2424	/* current vif */
2425	struct ieee80211_vif *vif;
2426	/* is the current vif among those iterated */
2427	bool cur_running;
2428};
2429
2430static void wlcore_hw_queue_iter(void *data, u8 *mac,
2431				 struct ieee80211_vif *vif)
2432{
2433	struct wlcore_hw_queue_iter_data *iter_data = data;
2434
2435	if (vif->type == NL80211_IFTYPE_P2P_DEVICE ||
2436	    WARN_ON_ONCE(vif->hw_queue[0] == IEEE80211_INVAL_HW_QUEUE))
2437		return;
2438
2439	if (iter_data->cur_running || vif == iter_data->vif) {
2440		iter_data->cur_running = true;
2441		return;
2442	}
2443
2444	__set_bit(vif->hw_queue[0] / NUM_TX_QUEUES, iter_data->hw_queue_map);
2445}
2446
2447static int wlcore_allocate_hw_queue_base(struct wl1271 *wl,
2448					 struct wl12xx_vif *wlvif)
2449{
2450	struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2451	struct wlcore_hw_queue_iter_data iter_data = {};
2452	int i, q_base;
2453
2454	if (vif->type == NL80211_IFTYPE_P2P_DEVICE) {
2455		vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;
2456		return 0;
2457	}
2458
2459	iter_data.vif = vif;
2460
2461	/* mark all bits taken by active interfaces */
2462	ieee80211_iterate_active_interfaces_atomic(wl->hw,
2463					IEEE80211_IFACE_ITER_RESUME_ALL,
2464					wlcore_hw_queue_iter, &iter_data);
2465
2466	/* the current vif is already running in mac80211 (resume/recovery) */
2467	if (iter_data.cur_running) {
2468		wlvif->hw_queue_base = vif->hw_queue[0];
2469		wl1271_debug(DEBUG_MAC80211,
2470			     "using pre-allocated hw queue base %d",
2471			     wlvif->hw_queue_base);
2472
2473		/* interface type might have changed type */
2474		goto adjust_cab_queue;
2475	}
2476
2477	q_base = find_first_zero_bit(iter_data.hw_queue_map,
2478				     WLCORE_NUM_MAC_ADDRESSES);
2479	if (q_base >= WLCORE_NUM_MAC_ADDRESSES)
2480		return -EBUSY;
2481
2482	wlvif->hw_queue_base = q_base * NUM_TX_QUEUES;
2483	wl1271_debug(DEBUG_MAC80211, "allocating hw queue base: %d",
2484		     wlvif->hw_queue_base);
2485
2486	for (i = 0; i < NUM_TX_QUEUES; i++) {
2487		wl->queue_stop_reasons[wlvif->hw_queue_base + i] = 0;
2488		/* register hw queues in mac80211 */
2489		vif->hw_queue[i] = wlvif->hw_queue_base + i;
2490	}
2491
2492adjust_cab_queue:
2493	/* the last places are reserved for cab queues per interface */
2494	if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2495		vif->cab_queue = NUM_TX_QUEUES * WLCORE_NUM_MAC_ADDRESSES +
2496				 wlvif->hw_queue_base / NUM_TX_QUEUES;
2497	else
2498		vif->cab_queue = IEEE80211_INVAL_HW_QUEUE;
2499
2500	return 0;
2501}
2502
2503static int wl1271_op_add_interface(struct ieee80211_hw *hw,
2504				   struct ieee80211_vif *vif)
2505{
2506	struct wl1271 *wl = hw->priv;
2507	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2508	struct vif_counter_data vif_count;
2509	int ret = 0;
2510	u8 role_type;
2511
2512	if (wl->plt) {
2513		wl1271_error("Adding Interface not allowed while in PLT mode");
2514		return -EBUSY;
2515	}
2516
2517	vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER |
2518			     IEEE80211_VIF_SUPPORTS_UAPSD |
2519			     IEEE80211_VIF_SUPPORTS_CQM_RSSI;
2520
2521	wl1271_debug(DEBUG_MAC80211, "mac80211 add interface type %d mac %pM",
2522		     ieee80211_vif_type_p2p(vif), vif->addr);
2523
2524	wl12xx_get_vif_count(hw, vif, &vif_count);
2525
2526	mutex_lock(&wl->mutex);
2527
2528	/*
2529	 * in some very corner case HW recovery scenarios its possible to
2530	 * get here before __wl1271_op_remove_interface is complete, so
2531	 * opt out if that is the case.
2532	 */
2533	if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) ||
2534	    test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)) {
2535		ret = -EBUSY;
2536		goto out;
2537	}
2538
2539
2540	ret = wl12xx_init_vif_data(wl, vif);
2541	if (ret < 0)
2542		goto out;
2543
2544	wlvif->wl = wl;
2545	role_type = wl12xx_get_role_type(wl, wlvif);
2546	if (role_type == WL12XX_INVALID_ROLE_TYPE) {
2547		ret = -EINVAL;
2548		goto out;
2549	}
2550
2551	ret = wlcore_allocate_hw_queue_base(wl, wlvif);
2552	if (ret < 0)
2553		goto out;
2554
2555	/*
2556	 * TODO: after the nvs issue will be solved, move this block
2557	 * to start(), and make sure here the driver is ON.
2558	 */
2559	if (wl->state == WLCORE_STATE_OFF) {
2560		/*
2561		 * we still need this in order to configure the fw
2562		 * while uploading the nvs
2563		 */
2564		memcpy(wl->addresses[0].addr, vif->addr, ETH_ALEN);
2565
2566		ret = wl12xx_init_fw(wl);
2567		if (ret < 0)
2568			goto out;
2569	}
2570
2571	/*
2572	 * Call runtime PM only after possible wl12xx_init_fw() above
2573	 * is done. Otherwise we do not have interrupts enabled.
2574	 */
2575	ret = pm_runtime_resume_and_get(wl->dev);
2576	if (ret < 0)
 
2577		goto out_unlock;
 
2578
2579	if (wl12xx_need_fw_change(wl, vif_count, true)) {
2580		wl12xx_force_active_psm(wl);
2581		set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
2582		mutex_unlock(&wl->mutex);
2583		wl1271_recovery_work(&wl->recovery_work);
2584		return 0;
2585	}
2586
2587	if (!wlcore_is_p2p_mgmt(wlvif)) {
2588		ret = wl12xx_cmd_role_enable(wl, vif->addr,
2589					     role_type, &wlvif->role_id);
2590		if (ret < 0)
2591			goto out;
2592
2593		ret = wl1271_init_vif_specific(wl, vif);
2594		if (ret < 0)
2595			goto out;
2596
2597	} else {
2598		ret = wl12xx_cmd_role_enable(wl, vif->addr, WL1271_ROLE_DEVICE,
2599					     &wlvif->dev_role_id);
2600		if (ret < 0)
2601			goto out;
2602
2603		/* needed mainly for configuring rate policies */
2604		ret = wl1271_sta_hw_init(wl, wlvif);
2605		if (ret < 0)
2606			goto out;
2607	}
2608
2609	list_add(&wlvif->list, &wl->wlvif_list);
2610	set_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags);
2611
2612	if (wlvif->bss_type == BSS_TYPE_AP_BSS)
2613		wl->ap_count++;
2614	else
2615		wl->sta_count++;
2616out:
2617	pm_runtime_mark_last_busy(wl->dev);
2618	pm_runtime_put_autosuspend(wl->dev);
2619out_unlock:
2620	mutex_unlock(&wl->mutex);
2621
2622	return ret;
2623}
2624
2625static void __wl1271_op_remove_interface(struct wl1271 *wl,
2626					 struct ieee80211_vif *vif,
2627					 bool reset_tx_queues)
2628{
2629	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2630	int i, ret;
2631	bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
2632
2633	wl1271_debug(DEBUG_MAC80211, "mac80211 remove interface");
2634
2635	if (!test_and_clear_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2636		return;
2637
2638	/* because of hardware recovery, we may get here twice */
2639	if (wl->state == WLCORE_STATE_OFF)
2640		return;
2641
2642	wl1271_info("down");
2643
2644	if (wl->scan.state != WL1271_SCAN_STATE_IDLE &&
2645	    wl->scan_wlvif == wlvif) {
2646		struct cfg80211_scan_info info = {
2647			.aborted = true,
2648		};
2649
2650		/*
2651		 * Rearm the tx watchdog just before idling scan. This
2652		 * prevents just-finished scans from triggering the watchdog
2653		 */
2654		wl12xx_rearm_tx_watchdog_locked(wl);
2655
2656		wl->scan.state = WL1271_SCAN_STATE_IDLE;
2657		memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
2658		wl->scan_wlvif = NULL;
2659		wl->scan.req = NULL;
2660		ieee80211_scan_completed(wl->hw, &info);
2661	}
2662
2663	if (wl->sched_vif == wlvif)
2664		wl->sched_vif = NULL;
2665
2666	if (wl->roc_vif == vif) {
2667		wl->roc_vif = NULL;
2668		ieee80211_remain_on_channel_expired(wl->hw);
2669	}
2670
2671	if (!test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags)) {
2672		/* disable active roles */
2673		ret = pm_runtime_resume_and_get(wl->dev);
2674		if (ret < 0)
 
2675			goto deinit;
 
2676
2677		if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2678		    wlvif->bss_type == BSS_TYPE_IBSS) {
2679			if (wl12xx_dev_role_started(wlvif))
2680				wl12xx_stop_dev(wl, wlvif);
2681		}
2682
2683		if (!wlcore_is_p2p_mgmt(wlvif)) {
2684			ret = wl12xx_cmd_role_disable(wl, &wlvif->role_id);
2685			if (ret < 0) {
2686				pm_runtime_put_noidle(wl->dev);
2687				goto deinit;
2688			}
2689		} else {
2690			ret = wl12xx_cmd_role_disable(wl, &wlvif->dev_role_id);
2691			if (ret < 0) {
2692				pm_runtime_put_noidle(wl->dev);
2693				goto deinit;
2694			}
2695		}
2696
2697		pm_runtime_mark_last_busy(wl->dev);
2698		pm_runtime_put_autosuspend(wl->dev);
2699	}
2700deinit:
2701	wl12xx_tx_reset_wlvif(wl, wlvif);
2702
2703	/* clear all hlids (except system_hlid) */
2704	wlvif->dev_hlid = WL12XX_INVALID_LINK_ID;
2705
2706	if (wlvif->bss_type == BSS_TYPE_STA_BSS ||
2707	    wlvif->bss_type == BSS_TYPE_IBSS) {
2708		wlvif->sta.hlid = WL12XX_INVALID_LINK_ID;
2709		wl12xx_free_rate_policy(wl, &wlvif->sta.basic_rate_idx);
2710		wl12xx_free_rate_policy(wl, &wlvif->sta.ap_rate_idx);
2711		wl12xx_free_rate_policy(wl, &wlvif->sta.p2p_rate_idx);
2712		wlcore_free_klv_template(wl, &wlvif->sta.klv_template_id);
2713	} else {
2714		wlvif->ap.bcast_hlid = WL12XX_INVALID_LINK_ID;
2715		wlvif->ap.global_hlid = WL12XX_INVALID_LINK_ID;
2716		wl12xx_free_rate_policy(wl, &wlvif->ap.mgmt_rate_idx);
2717		wl12xx_free_rate_policy(wl, &wlvif->ap.bcast_rate_idx);
2718		for (i = 0; i < CONF_TX_MAX_AC_COUNT; i++)
2719			wl12xx_free_rate_policy(wl,
2720						&wlvif->ap.ucast_rate_idx[i]);
2721		wl1271_free_ap_keys(wl, wlvif);
2722	}
2723
2724	dev_kfree_skb(wlvif->probereq);
2725	wlvif->probereq = NULL;
2726	if (wl->last_wlvif == wlvif)
2727		wl->last_wlvif = NULL;
2728	list_del(&wlvif->list);
2729	memset(wlvif->ap.sta_hlid_map, 0, sizeof(wlvif->ap.sta_hlid_map));
2730	wlvif->role_id = WL12XX_INVALID_ROLE_ID;
2731	wlvif->dev_role_id = WL12XX_INVALID_ROLE_ID;
2732
2733	if (is_ap)
2734		wl->ap_count--;
2735	else
2736		wl->sta_count--;
2737
2738	/*
2739	 * Last AP, have more stations. Configure sleep auth according to STA.
2740	 * Don't do thin on unintended recovery.
2741	 */
2742	if (test_bit(WL1271_FLAG_RECOVERY_IN_PROGRESS, &wl->flags) &&
2743	    !test_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags))
2744		goto unlock;
2745
2746	if (wl->ap_count == 0 && is_ap) {
2747		/* mask ap events */
2748		wl->event_mask &= ~wl->ap_event_mask;
2749		wl1271_event_unmask(wl);
2750	}
2751
2752	if (wl->ap_count == 0 && is_ap && wl->sta_count) {
2753		u8 sta_auth = wl->conf.conn.sta_sleep_auth;
2754		/* Configure for power according to debugfs */
2755		if (sta_auth != WL1271_PSM_ILLEGAL)
2756			wl1271_acx_sleep_auth(wl, sta_auth);
2757		/* Configure for ELP power saving */
2758		else
2759			wl1271_acx_sleep_auth(wl, WL1271_PSM_ELP);
2760	}
2761
2762unlock:
2763	mutex_unlock(&wl->mutex);
2764
2765	del_timer_sync(&wlvif->rx_streaming_timer);
2766	cancel_work_sync(&wlvif->rx_streaming_enable_work);
2767	cancel_work_sync(&wlvif->rx_streaming_disable_work);
2768	cancel_work_sync(&wlvif->rc_update_work);
2769	cancel_delayed_work_sync(&wlvif->connection_loss_work);
2770	cancel_delayed_work_sync(&wlvif->channel_switch_work);
2771	cancel_delayed_work_sync(&wlvif->pending_auth_complete_work);
2772
2773	mutex_lock(&wl->mutex);
2774}
2775
2776static void wl1271_op_remove_interface(struct ieee80211_hw *hw,
2777				       struct ieee80211_vif *vif)
2778{
2779	struct wl1271 *wl = hw->priv;
2780	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
2781	struct wl12xx_vif *iter;
2782	struct vif_counter_data vif_count;
2783
2784	wl12xx_get_vif_count(hw, vif, &vif_count);
2785	mutex_lock(&wl->mutex);
2786
2787	if (wl->state == WLCORE_STATE_OFF ||
2788	    !test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
2789		goto out;
2790
2791	/*
2792	 * wl->vif can be null here if someone shuts down the interface
2793	 * just when hardware recovery has been started.
2794	 */
2795	wl12xx_for_each_wlvif(wl, iter) {
2796		if (iter != wlvif)
2797			continue;
2798
2799		__wl1271_op_remove_interface(wl, vif, true);
2800		break;
2801	}
2802	WARN_ON(iter != wlvif);
2803	if (wl12xx_need_fw_change(wl, vif_count, false)) {
2804		wl12xx_force_active_psm(wl);
2805		set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
2806		wl12xx_queue_recovery_work(wl);
2807	}
2808out:
2809	mutex_unlock(&wl->mutex);
2810}
2811
2812static int wl12xx_op_change_interface(struct ieee80211_hw *hw,
2813				      struct ieee80211_vif *vif,
2814				      enum nl80211_iftype new_type, bool p2p)
2815{
2816	struct wl1271 *wl = hw->priv;
2817	int ret;
2818
2819	set_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags);
2820	wl1271_op_remove_interface(hw, vif);
2821
2822	vif->type = new_type;
2823	vif->p2p = p2p;
2824	ret = wl1271_op_add_interface(hw, vif);
2825
2826	clear_bit(WL1271_FLAG_VIF_CHANGE_IN_PROGRESS, &wl->flags);
2827	return ret;
2828}
2829
2830static int wlcore_join(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2831{
2832	int ret;
2833	bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
2834
2835	/*
2836	 * One of the side effects of the JOIN command is that is clears
2837	 * WPA/WPA2 keys from the chipset. Performing a JOIN while associated
2838	 * to a WPA/WPA2 access point will therefore kill the data-path.
2839	 * Currently the only valid scenario for JOIN during association
2840	 * is on roaming, in which case we will also be given new keys.
2841	 * Keep the below message for now, unless it starts bothering
2842	 * users who really like to roam a lot :)
2843	 */
2844	if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2845		wl1271_info("JOIN while associated.");
2846
2847	/* clear encryption type */
2848	wlvif->encryption_type = KEY_NONE;
2849
2850	if (is_ibss)
2851		ret = wl12xx_cmd_role_start_ibss(wl, wlvif);
2852	else
 
 
 
 
 
 
 
 
 
 
 
 
2853		ret = wl12xx_cmd_role_start_sta(wl, wlvif);
 
2854
2855	return ret;
2856}
2857
2858static int wl1271_ssid_set(struct wl12xx_vif *wlvif, struct sk_buff *skb,
2859			    int offset)
2860{
2861	u8 ssid_len;
2862	const u8 *ptr = cfg80211_find_ie(WLAN_EID_SSID, skb->data + offset,
2863					 skb->len - offset);
2864
2865	if (!ptr) {
2866		wl1271_error("No SSID in IEs!");
2867		return -ENOENT;
2868	}
2869
2870	ssid_len = ptr[1];
2871	if (ssid_len > IEEE80211_MAX_SSID_LEN) {
2872		wl1271_error("SSID is too long!");
2873		return -EINVAL;
2874	}
2875
2876	wlvif->ssid_len = ssid_len;
2877	memcpy(wlvif->ssid, ptr+2, ssid_len);
2878	return 0;
2879}
2880
2881static int wlcore_set_ssid(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2882{
2883	struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
2884	struct sk_buff *skb;
2885	int ieoffset;
2886
2887	/* we currently only support setting the ssid from the ap probe req */
2888	if (wlvif->bss_type != BSS_TYPE_STA_BSS)
2889		return -EINVAL;
2890
2891	skb = ieee80211_ap_probereq_get(wl->hw, vif);
2892	if (!skb)
2893		return -EINVAL;
2894
2895	ieoffset = offsetof(struct ieee80211_mgmt,
2896			    u.probe_req.variable);
2897	wl1271_ssid_set(wlvif, skb, ieoffset);
2898	dev_kfree_skb(skb);
2899
2900	return 0;
2901}
2902
2903static int wlcore_set_assoc(struct wl1271 *wl, struct wl12xx_vif *wlvif,
2904			    struct ieee80211_bss_conf *bss_conf,
2905			    u32 sta_rate_set)
2906{
2907	struct ieee80211_vif *vif = container_of(bss_conf, struct ieee80211_vif,
2908						 bss_conf);
2909	int ieoffset;
2910	int ret;
2911
2912	wlvif->aid = vif->cfg.aid;
2913	wlvif->channel_type = cfg80211_get_chandef_type(&bss_conf->chandef);
2914	wlvif->beacon_int = bss_conf->beacon_int;
2915	wlvif->wmm_enabled = bss_conf->qos;
2916
2917	set_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags);
2918
2919	/*
2920	 * with wl1271, we don't need to update the
2921	 * beacon_int and dtim_period, because the firmware
2922	 * updates it by itself when the first beacon is
2923	 * received after a join.
2924	 */
2925	ret = wl1271_cmd_build_ps_poll(wl, wlvif, wlvif->aid);
2926	if (ret < 0)
2927		return ret;
2928
2929	/*
2930	 * Get a template for hardware connection maintenance
2931	 */
2932	dev_kfree_skb(wlvif->probereq);
2933	wlvif->probereq = wl1271_cmd_build_ap_probe_req(wl,
2934							wlvif,
2935							NULL);
2936	ieoffset = offsetof(struct ieee80211_mgmt,
2937			    u.probe_req.variable);
2938	wl1271_ssid_set(wlvif, wlvif->probereq, ieoffset);
2939
2940	/* enable the connection monitoring feature */
2941	ret = wl1271_acx_conn_monit_params(wl, wlvif, true);
2942	if (ret < 0)
2943		return ret;
2944
2945	/*
2946	 * The join command disable the keep-alive mode, shut down its process,
2947	 * and also clear the template config, so we need to reset it all after
2948	 * the join. The acx_aid starts the keep-alive process, and the order
2949	 * of the commands below is relevant.
2950	 */
2951	ret = wl1271_acx_keep_alive_mode(wl, wlvif, true);
2952	if (ret < 0)
2953		return ret;
2954
2955	ret = wl1271_acx_aid(wl, wlvif, wlvif->aid);
2956	if (ret < 0)
2957		return ret;
2958
2959	ret = wl12xx_cmd_build_klv_null_data(wl, wlvif);
2960	if (ret < 0)
2961		return ret;
2962
2963	ret = wl1271_acx_keep_alive_config(wl, wlvif,
2964					   wlvif->sta.klv_template_id,
2965					   ACX_KEEP_ALIVE_TPL_VALID);
2966	if (ret < 0)
2967		return ret;
2968
2969	/*
2970	 * The default fw psm configuration is AUTO, while mac80211 default
2971	 * setting is off (ACTIVE), so sync the fw with the correct value.
2972	 */
2973	ret = wl1271_ps_set_mode(wl, wlvif, STATION_ACTIVE_MODE);
2974	if (ret < 0)
2975		return ret;
2976
2977	if (sta_rate_set) {
2978		wlvif->rate_set =
2979			wl1271_tx_enabled_rates_get(wl,
2980						    sta_rate_set,
2981						    wlvif->band);
2982		ret = wl1271_acx_sta_rate_policies(wl, wlvif);
2983		if (ret < 0)
2984			return ret;
2985	}
2986
2987	return ret;
2988}
2989
2990static int wlcore_unset_assoc(struct wl1271 *wl, struct wl12xx_vif *wlvif)
2991{
2992	int ret;
2993	bool sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
2994
2995	/* make sure we are connected (sta) joined */
2996	if (sta &&
2997	    !test_and_clear_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
2998		return false;
2999
3000	/* make sure we are joined (ibss) */
3001	if (!sta &&
3002	    test_and_clear_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags))
3003		return false;
3004
3005	if (sta) {
3006		/* use defaults when not associated */
3007		wlvif->aid = 0;
3008
3009		/* free probe-request template */
3010		dev_kfree_skb(wlvif->probereq);
3011		wlvif->probereq = NULL;
3012
3013		/* disable connection monitor features */
3014		ret = wl1271_acx_conn_monit_params(wl, wlvif, false);
3015		if (ret < 0)
3016			return ret;
3017
3018		/* Disable the keep-alive feature */
3019		ret = wl1271_acx_keep_alive_mode(wl, wlvif, false);
3020		if (ret < 0)
3021			return ret;
3022
3023		/* disable beacon filtering */
3024		ret = wl1271_acx_beacon_filter_opt(wl, wlvif, false);
3025		if (ret < 0)
3026			return ret;
3027	}
3028
3029	if (test_and_clear_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags)) {
3030		struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
3031
3032		wl12xx_cmd_stop_channel_switch(wl, wlvif);
3033		ieee80211_chswitch_done(vif, false);
3034		cancel_delayed_work(&wlvif->channel_switch_work);
3035	}
3036
3037	/* invalidate keep-alive template */
3038	wl1271_acx_keep_alive_config(wl, wlvif,
3039				     wlvif->sta.klv_template_id,
3040				     ACX_KEEP_ALIVE_TPL_INVALID);
3041
3042	return 0;
3043}
3044
3045static void wl1271_set_band_rate(struct wl1271 *wl, struct wl12xx_vif *wlvif)
3046{
3047	wlvif->basic_rate_set = wlvif->bitrate_masks[wlvif->band];
3048	wlvif->rate_set = wlvif->basic_rate_set;
3049}
3050
3051static void wl1271_sta_handle_idle(struct wl1271 *wl, struct wl12xx_vif *wlvif,
3052				   bool idle)
3053{
3054	bool cur_idle = !test_bit(WLVIF_FLAG_ACTIVE, &wlvif->flags);
3055
3056	if (idle == cur_idle)
3057		return;
3058
3059	if (idle) {
3060		clear_bit(WLVIF_FLAG_ACTIVE, &wlvif->flags);
3061	} else {
3062		/* The current firmware only supports sched_scan in idle */
3063		if (wl->sched_vif == wlvif)
3064			wl->ops->sched_scan_stop(wl, wlvif);
3065
3066		set_bit(WLVIF_FLAG_ACTIVE, &wlvif->flags);
3067	}
3068}
3069
3070static int wl12xx_config_vif(struct wl1271 *wl, struct wl12xx_vif *wlvif,
3071			     struct ieee80211_conf *conf, u32 changed)
3072{
3073	int ret;
3074
3075	if (wlcore_is_p2p_mgmt(wlvif))
3076		return 0;
3077
3078	if (conf->power_level != wlvif->power_level) {
3079		ret = wl1271_acx_tx_power(wl, wlvif, conf->power_level);
3080		if (ret < 0)
3081			return ret;
3082
3083		wlvif->power_level = conf->power_level;
3084	}
3085
3086	return 0;
3087}
3088
3089static int wl1271_op_config(struct ieee80211_hw *hw, u32 changed)
3090{
3091	struct wl1271 *wl = hw->priv;
3092	struct wl12xx_vif *wlvif;
3093	struct ieee80211_conf *conf = &hw->conf;
3094	int ret = 0;
3095
3096	wl1271_debug(DEBUG_MAC80211, "mac80211 config psm %s power %d %s"
3097		     " changed 0x%x",
3098		     conf->flags & IEEE80211_CONF_PS ? "on" : "off",
3099		     conf->power_level,
3100		     conf->flags & IEEE80211_CONF_IDLE ? "idle" : "in use",
3101			 changed);
3102
3103	mutex_lock(&wl->mutex);
3104
3105	if (changed & IEEE80211_CONF_CHANGE_POWER)
3106		wl->power_level = conf->power_level;
3107
3108	if (unlikely(wl->state != WLCORE_STATE_ON))
3109		goto out;
3110
3111	ret = pm_runtime_resume_and_get(wl->dev);
3112	if (ret < 0)
 
3113		goto out;
 
3114
3115	/* configure each interface */
3116	wl12xx_for_each_wlvif(wl, wlvif) {
3117		ret = wl12xx_config_vif(wl, wlvif, conf, changed);
3118		if (ret < 0)
3119			goto out_sleep;
3120	}
3121
3122out_sleep:
3123	pm_runtime_mark_last_busy(wl->dev);
3124	pm_runtime_put_autosuspend(wl->dev);
3125
3126out:
3127	mutex_unlock(&wl->mutex);
3128
3129	return ret;
3130}
3131
3132struct wl1271_filter_params {
3133	bool enabled;
3134	int mc_list_length;
3135	u8 mc_list[ACX_MC_ADDRESS_GROUP_MAX][ETH_ALEN];
3136};
3137
3138static u64 wl1271_op_prepare_multicast(struct ieee80211_hw *hw,
3139				       struct netdev_hw_addr_list *mc_list)
3140{
3141	struct wl1271_filter_params *fp;
3142	struct netdev_hw_addr *ha;
3143
3144	fp = kzalloc(sizeof(*fp), GFP_ATOMIC);
3145	if (!fp) {
3146		wl1271_error("Out of memory setting filters.");
3147		return 0;
3148	}
3149
3150	/* update multicast filtering parameters */
3151	fp->mc_list_length = 0;
3152	if (netdev_hw_addr_list_count(mc_list) > ACX_MC_ADDRESS_GROUP_MAX) {
3153		fp->enabled = false;
3154	} else {
3155		fp->enabled = true;
3156		netdev_hw_addr_list_for_each(ha, mc_list) {
3157			memcpy(fp->mc_list[fp->mc_list_length],
3158					ha->addr, ETH_ALEN);
3159			fp->mc_list_length++;
3160		}
3161	}
3162
3163	return (u64)(unsigned long)fp;
3164}
3165
3166#define WL1271_SUPPORTED_FILTERS (FIF_ALLMULTI | \
3167				  FIF_FCSFAIL | \
3168				  FIF_BCN_PRBRESP_PROMISC | \
3169				  FIF_CONTROL | \
3170				  FIF_OTHER_BSS)
3171
3172static void wl1271_op_configure_filter(struct ieee80211_hw *hw,
3173				       unsigned int changed,
3174				       unsigned int *total, u64 multicast)
3175{
3176	struct wl1271_filter_params *fp = (void *)(unsigned long)multicast;
3177	struct wl1271 *wl = hw->priv;
3178	struct wl12xx_vif *wlvif;
3179
3180	int ret;
3181
3182	wl1271_debug(DEBUG_MAC80211, "mac80211 configure filter changed %x"
3183		     " total %x", changed, *total);
3184
3185	mutex_lock(&wl->mutex);
3186
3187	*total &= WL1271_SUPPORTED_FILTERS;
3188	changed &= WL1271_SUPPORTED_FILTERS;
3189
3190	if (unlikely(wl->state != WLCORE_STATE_ON))
3191		goto out;
3192
3193	ret = pm_runtime_resume_and_get(wl->dev);
3194	if (ret < 0)
 
3195		goto out;
 
3196
3197	wl12xx_for_each_wlvif(wl, wlvif) {
3198		if (wlcore_is_p2p_mgmt(wlvif))
3199			continue;
3200
3201		if (wlvif->bss_type != BSS_TYPE_AP_BSS) {
3202			if (*total & FIF_ALLMULTI)
3203				ret = wl1271_acx_group_address_tbl(wl, wlvif,
3204								   false,
3205								   NULL, 0);
3206			else if (fp)
3207				ret = wl1271_acx_group_address_tbl(wl, wlvif,
3208							fp->enabled,
3209							fp->mc_list,
3210							fp->mc_list_length);
3211			if (ret < 0)
3212				goto out_sleep;
3213		}
3214
3215		/*
3216		 * If interface in AP mode and created with allmulticast then disable
3217		 * the firmware filters so that all multicast packets are passed
3218		 * This is mandatory for MDNS based discovery protocols 
3219		 */
3220		if (wlvif->bss_type == BSS_TYPE_AP_BSS) {
3221			if (*total & FIF_ALLMULTI) {
3222				ret = wl1271_acx_group_address_tbl(wl, wlvif,
3223							false,
3224							NULL, 0);
3225				if (ret < 0)
3226					goto out_sleep;
3227			}
3228		}
3229	}
3230
3231	/*
3232	 * the fw doesn't provide an api to configure the filters. instead,
3233	 * the filters configuration is based on the active roles / ROC
3234	 * state.
3235	 */
3236
3237out_sleep:
3238	pm_runtime_mark_last_busy(wl->dev);
3239	pm_runtime_put_autosuspend(wl->dev);
3240
3241out:
3242	mutex_unlock(&wl->mutex);
3243	kfree(fp);
3244}
3245
3246static int wl1271_record_ap_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
3247				u8 id, u8 key_type, u8 key_size,
3248				const u8 *key, u8 hlid, u32 tx_seq_32,
3249				u16 tx_seq_16, bool is_pairwise)
3250{
3251	struct wl1271_ap_key *ap_key;
3252	int i;
3253
3254	wl1271_debug(DEBUG_CRYPT, "record ap key id %d", (int)id);
3255
3256	if (key_size > MAX_KEY_SIZE)
3257		return -EINVAL;
3258
3259	/*
3260	 * Find next free entry in ap_keys. Also check we are not replacing
3261	 * an existing key.
3262	 */
3263	for (i = 0; i < MAX_NUM_KEYS; i++) {
3264		if (wlvif->ap.recorded_keys[i] == NULL)
3265			break;
3266
3267		if (wlvif->ap.recorded_keys[i]->id == id) {
3268			wl1271_warning("trying to record key replacement");
3269			return -EINVAL;
3270		}
3271	}
3272
3273	if (i == MAX_NUM_KEYS)
3274		return -EBUSY;
3275
3276	ap_key = kzalloc(sizeof(*ap_key), GFP_KERNEL);
3277	if (!ap_key)
3278		return -ENOMEM;
3279
3280	ap_key->id = id;
3281	ap_key->key_type = key_type;
3282	ap_key->key_size = key_size;
3283	memcpy(ap_key->key, key, key_size);
3284	ap_key->hlid = hlid;
3285	ap_key->tx_seq_32 = tx_seq_32;
3286	ap_key->tx_seq_16 = tx_seq_16;
3287	ap_key->is_pairwise = is_pairwise;
3288
3289	wlvif->ap.recorded_keys[i] = ap_key;
3290	return 0;
3291}
3292
3293static void wl1271_free_ap_keys(struct wl1271 *wl, struct wl12xx_vif *wlvif)
3294{
3295	int i;
3296
3297	for (i = 0; i < MAX_NUM_KEYS; i++) {
3298		kfree(wlvif->ap.recorded_keys[i]);
3299		wlvif->ap.recorded_keys[i] = NULL;
3300	}
3301}
3302
3303static int wl1271_ap_init_hwenc(struct wl1271 *wl, struct wl12xx_vif *wlvif)
3304{
3305	int i, ret = 0;
3306	struct wl1271_ap_key *key;
3307	bool wep_key_added = false;
3308
3309	for (i = 0; i < MAX_NUM_KEYS; i++) {
3310		u8 hlid;
3311		if (wlvif->ap.recorded_keys[i] == NULL)
3312			break;
3313
3314		key = wlvif->ap.recorded_keys[i];
3315		hlid = key->hlid;
3316		if (hlid == WL12XX_INVALID_LINK_ID)
3317			hlid = wlvif->ap.bcast_hlid;
3318
3319		ret = wl1271_cmd_set_ap_key(wl, wlvif, KEY_ADD_OR_REPLACE,
3320					    key->id, key->key_type,
3321					    key->key_size, key->key,
3322					    hlid, key->tx_seq_32,
3323					    key->tx_seq_16, key->is_pairwise);
3324		if (ret < 0)
3325			goto out;
3326
3327		if (key->key_type == KEY_WEP)
3328			wep_key_added = true;
3329	}
3330
3331	if (wep_key_added) {
3332		ret = wl12xx_cmd_set_default_wep_key(wl, wlvif->default_key,
3333						     wlvif->ap.bcast_hlid);
3334		if (ret < 0)
3335			goto out;
3336	}
3337
3338out:
3339	wl1271_free_ap_keys(wl, wlvif);
3340	return ret;
3341}
3342
3343static int wl1271_set_key(struct wl1271 *wl, struct wl12xx_vif *wlvif,
3344		       u16 action, u8 id, u8 key_type,
3345		       u8 key_size, const u8 *key, u32 tx_seq_32,
3346		       u16 tx_seq_16, struct ieee80211_sta *sta,
3347		       bool is_pairwise)
3348{
3349	int ret;
3350	bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
3351
3352	if (is_ap) {
3353		struct wl1271_station *wl_sta;
3354		u8 hlid;
3355
3356		if (sta) {
3357			wl_sta = (struct wl1271_station *)sta->drv_priv;
3358			hlid = wl_sta->hlid;
3359		} else {
3360			hlid = wlvif->ap.bcast_hlid;
3361		}
3362
3363		if (!test_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags)) {
3364			/*
3365			 * We do not support removing keys after AP shutdown.
3366			 * Pretend we do to make mac80211 happy.
3367			 */
3368			if (action != KEY_ADD_OR_REPLACE)
3369				return 0;
3370
3371			ret = wl1271_record_ap_key(wl, wlvif, id,
3372					     key_type, key_size,
3373					     key, hlid, tx_seq_32,
3374					     tx_seq_16, is_pairwise);
3375		} else {
3376			ret = wl1271_cmd_set_ap_key(wl, wlvif, action,
3377					     id, key_type, key_size,
3378					     key, hlid, tx_seq_32,
3379					     tx_seq_16, is_pairwise);
3380		}
3381
3382		if (ret < 0)
3383			return ret;
3384	} else {
3385		const u8 *addr;
3386		static const u8 bcast_addr[ETH_ALEN] = {
3387			0xff, 0xff, 0xff, 0xff, 0xff, 0xff
3388		};
3389
3390		addr = sta ? sta->addr : bcast_addr;
3391
3392		if (is_zero_ether_addr(addr)) {
3393			/* We dont support TX only encryption */
3394			return -EOPNOTSUPP;
3395		}
3396
3397		/* The wl1271 does not allow to remove unicast keys - they
3398		   will be cleared automatically on next CMD_JOIN. Ignore the
3399		   request silently, as we dont want the mac80211 to emit
3400		   an error message. */
3401		if (action == KEY_REMOVE && !is_broadcast_ether_addr(addr))
3402			return 0;
3403
3404		/* don't remove key if hlid was already deleted */
3405		if (action == KEY_REMOVE &&
3406		    wlvif->sta.hlid == WL12XX_INVALID_LINK_ID)
3407			return 0;
3408
3409		ret = wl1271_cmd_set_sta_key(wl, wlvif, action,
3410					     id, key_type, key_size,
3411					     key, addr, tx_seq_32,
3412					     tx_seq_16);
3413		if (ret < 0)
3414			return ret;
3415
3416	}
3417
3418	return 0;
3419}
3420
3421static int wlcore_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3422			     struct ieee80211_vif *vif,
3423			     struct ieee80211_sta *sta,
3424			     struct ieee80211_key_conf *key_conf)
3425{
3426	struct wl1271 *wl = hw->priv;
3427	int ret;
3428	bool might_change_spare =
3429		key_conf->cipher == WL1271_CIPHER_SUITE_GEM ||
3430		key_conf->cipher == WLAN_CIPHER_SUITE_TKIP;
3431
3432	if (might_change_spare) {
3433		/*
3434		 * stop the queues and flush to ensure the next packets are
3435		 * in sync with FW spare block accounting
3436		 */
3437		wlcore_stop_queues(wl, WLCORE_QUEUE_STOP_REASON_SPARE_BLK);
3438		wl1271_tx_flush(wl);
3439	}
3440
3441	mutex_lock(&wl->mutex);
3442
3443	if (unlikely(wl->state != WLCORE_STATE_ON)) {
3444		ret = -EAGAIN;
3445		goto out_wake_queues;
3446	}
3447
3448	ret = pm_runtime_resume_and_get(wl->dev);
3449	if (ret < 0)
 
3450		goto out_wake_queues;
 
3451
3452	ret = wlcore_hw_set_key(wl, cmd, vif, sta, key_conf);
3453
3454	pm_runtime_mark_last_busy(wl->dev);
3455	pm_runtime_put_autosuspend(wl->dev);
3456
3457out_wake_queues:
3458	if (might_change_spare)
3459		wlcore_wake_queues(wl, WLCORE_QUEUE_STOP_REASON_SPARE_BLK);
3460
3461	mutex_unlock(&wl->mutex);
3462
3463	return ret;
3464}
3465
3466int wlcore_set_key(struct wl1271 *wl, enum set_key_cmd cmd,
3467		   struct ieee80211_vif *vif,
3468		   struct ieee80211_sta *sta,
3469		   struct ieee80211_key_conf *key_conf)
3470{
3471	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3472	int ret;
3473	u32 tx_seq_32 = 0;
3474	u16 tx_seq_16 = 0;
3475	u8 key_type;
3476	u8 hlid;
3477	bool is_pairwise;
3478
3479	wl1271_debug(DEBUG_MAC80211, "mac80211 set key");
3480
3481	wl1271_debug(DEBUG_CRYPT, "CMD: 0x%x sta: %p", cmd, sta);
3482	wl1271_debug(DEBUG_CRYPT, "Key: algo:0x%x, id:%d, len:%d flags 0x%x",
3483		     key_conf->cipher, key_conf->keyidx,
3484		     key_conf->keylen, key_conf->flags);
3485	wl1271_dump(DEBUG_CRYPT, "KEY: ", key_conf->key, key_conf->keylen);
3486
3487	if (wlvif->bss_type == BSS_TYPE_AP_BSS)
3488		if (sta) {
3489			struct wl1271_station *wl_sta = (void *)sta->drv_priv;
3490			hlid = wl_sta->hlid;
3491		} else {
3492			hlid = wlvif->ap.bcast_hlid;
3493		}
3494	else
3495		hlid = wlvif->sta.hlid;
3496
3497	if (hlid != WL12XX_INVALID_LINK_ID) {
3498		u64 tx_seq = wl->links[hlid].total_freed_pkts;
3499		tx_seq_32 = WL1271_TX_SECURITY_HI32(tx_seq);
3500		tx_seq_16 = WL1271_TX_SECURITY_LO16(tx_seq);
3501	}
3502
3503	switch (key_conf->cipher) {
3504	case WLAN_CIPHER_SUITE_WEP40:
3505	case WLAN_CIPHER_SUITE_WEP104:
3506		key_type = KEY_WEP;
3507
3508		key_conf->hw_key_idx = key_conf->keyidx;
3509		break;
3510	case WLAN_CIPHER_SUITE_TKIP:
3511		key_type = KEY_TKIP;
3512		key_conf->hw_key_idx = key_conf->keyidx;
3513		break;
3514	case WLAN_CIPHER_SUITE_CCMP:
3515		key_type = KEY_AES;
3516		key_conf->flags |= IEEE80211_KEY_FLAG_PUT_IV_SPACE;
3517		break;
3518	case WL1271_CIPHER_SUITE_GEM:
3519		key_type = KEY_GEM;
3520		break;
3521	default:
3522		wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
3523
3524		return -EOPNOTSUPP;
3525	}
3526
3527	is_pairwise = key_conf->flags & IEEE80211_KEY_FLAG_PAIRWISE;
3528
3529	switch (cmd) {
3530	case SET_KEY:
3531		ret = wl1271_set_key(wl, wlvif, KEY_ADD_OR_REPLACE,
3532				 key_conf->keyidx, key_type,
3533				 key_conf->keylen, key_conf->key,
3534				 tx_seq_32, tx_seq_16, sta, is_pairwise);
3535		if (ret < 0) {
3536			wl1271_error("Could not add or replace key");
3537			return ret;
3538		}
3539
3540		/*
3541		 * reconfiguring arp response if the unicast (or common)
3542		 * encryption key type was changed
3543		 */
3544		if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
3545		    (sta || key_type == KEY_WEP) &&
3546		    wlvif->encryption_type != key_type) {
3547			wlvif->encryption_type = key_type;
3548			ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
3549			if (ret < 0) {
3550				wl1271_warning("build arp rsp failed: %d", ret);
3551				return ret;
3552			}
3553		}
3554		break;
3555
3556	case DISABLE_KEY:
3557		ret = wl1271_set_key(wl, wlvif, KEY_REMOVE,
3558				     key_conf->keyidx, key_type,
3559				     key_conf->keylen, key_conf->key,
3560				     0, 0, sta, is_pairwise);
3561		if (ret < 0) {
3562			wl1271_error("Could not remove key");
3563			return ret;
3564		}
3565		break;
3566
3567	default:
3568		wl1271_error("Unsupported key cmd 0x%x", cmd);
3569		return -EOPNOTSUPP;
3570	}
3571
3572	return ret;
3573}
3574EXPORT_SYMBOL_GPL(wlcore_set_key);
3575
3576static void wl1271_op_set_default_key_idx(struct ieee80211_hw *hw,
3577					  struct ieee80211_vif *vif,
3578					  int key_idx)
3579{
3580	struct wl1271 *wl = hw->priv;
3581	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3582	int ret;
3583
3584	wl1271_debug(DEBUG_MAC80211, "mac80211 set default key idx %d",
3585		     key_idx);
3586
3587	/* we don't handle unsetting of default key */
3588	if (key_idx == -1)
3589		return;
3590
3591	mutex_lock(&wl->mutex);
3592
3593	if (unlikely(wl->state != WLCORE_STATE_ON)) {
3594		ret = -EAGAIN;
3595		goto out_unlock;
3596	}
3597
3598	ret = pm_runtime_resume_and_get(wl->dev);
3599	if (ret < 0)
 
3600		goto out_unlock;
 
3601
3602	wlvif->default_key = key_idx;
3603
3604	/* the default WEP key needs to be configured at least once */
3605	if (wlvif->encryption_type == KEY_WEP) {
3606		ret = wl12xx_cmd_set_default_wep_key(wl,
3607				key_idx,
3608				wlvif->sta.hlid);
3609		if (ret < 0)
3610			goto out_sleep;
3611	}
3612
3613out_sleep:
3614	pm_runtime_mark_last_busy(wl->dev);
3615	pm_runtime_put_autosuspend(wl->dev);
3616
3617out_unlock:
3618	mutex_unlock(&wl->mutex);
3619}
3620
3621void wlcore_regdomain_config(struct wl1271 *wl)
3622{
3623	int ret;
3624
3625	if (!(wl->quirks & WLCORE_QUIRK_REGDOMAIN_CONF))
3626		return;
3627
3628	mutex_lock(&wl->mutex);
3629
3630	if (unlikely(wl->state != WLCORE_STATE_ON))
3631		goto out;
3632
3633	ret = pm_runtime_resume_and_get(wl->dev);
3634	if (ret < 0)
 
3635		goto out;
 
3636
3637	ret = wlcore_cmd_regdomain_config_locked(wl);
3638	if (ret < 0) {
3639		wl12xx_queue_recovery_work(wl);
3640		goto out;
3641	}
3642
3643	pm_runtime_mark_last_busy(wl->dev);
3644	pm_runtime_put_autosuspend(wl->dev);
3645out:
3646	mutex_unlock(&wl->mutex);
3647}
3648
3649static int wl1271_op_hw_scan(struct ieee80211_hw *hw,
3650			     struct ieee80211_vif *vif,
3651			     struct ieee80211_scan_request *hw_req)
3652{
3653	struct cfg80211_scan_request *req = &hw_req->req;
3654	struct wl1271 *wl = hw->priv;
3655	int ret;
3656	u8 *ssid = NULL;
3657	size_t len = 0;
3658
3659	wl1271_debug(DEBUG_MAC80211, "mac80211 hw scan");
3660
3661	if (req->n_ssids) {
3662		ssid = req->ssids[0].ssid;
3663		len = req->ssids[0].ssid_len;
3664	}
3665
3666	mutex_lock(&wl->mutex);
3667
3668	if (unlikely(wl->state != WLCORE_STATE_ON)) {
3669		/*
3670		 * We cannot return -EBUSY here because cfg80211 will expect
3671		 * a call to ieee80211_scan_completed if we do - in this case
3672		 * there won't be any call.
3673		 */
3674		ret = -EAGAIN;
3675		goto out;
3676	}
3677
3678	ret = pm_runtime_resume_and_get(wl->dev);
3679	if (ret < 0)
 
3680		goto out;
 
3681
3682	/* fail if there is any role in ROC */
3683	if (find_first_bit(wl->roc_map, WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES) {
3684		/* don't allow scanning right now */
3685		ret = -EBUSY;
3686		goto out_sleep;
3687	}
3688
3689	ret = wlcore_scan(hw->priv, vif, ssid, len, req);
3690out_sleep:
3691	pm_runtime_mark_last_busy(wl->dev);
3692	pm_runtime_put_autosuspend(wl->dev);
3693out:
3694	mutex_unlock(&wl->mutex);
3695
3696	return ret;
3697}
3698
3699static void wl1271_op_cancel_hw_scan(struct ieee80211_hw *hw,
3700				     struct ieee80211_vif *vif)
3701{
3702	struct wl1271 *wl = hw->priv;
3703	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3704	struct cfg80211_scan_info info = {
3705		.aborted = true,
3706	};
3707	int ret;
3708
3709	wl1271_debug(DEBUG_MAC80211, "mac80211 cancel hw scan");
3710
3711	mutex_lock(&wl->mutex);
3712
3713	if (unlikely(wl->state != WLCORE_STATE_ON))
3714		goto out;
3715
3716	if (wl->scan.state == WL1271_SCAN_STATE_IDLE)
3717		goto out;
3718
3719	ret = pm_runtime_resume_and_get(wl->dev);
3720	if (ret < 0)
 
3721		goto out;
 
3722
3723	if (wl->scan.state != WL1271_SCAN_STATE_DONE) {
3724		ret = wl->ops->scan_stop(wl, wlvif);
3725		if (ret < 0)
3726			goto out_sleep;
3727	}
3728
3729	/*
3730	 * Rearm the tx watchdog just before idling scan. This
3731	 * prevents just-finished scans from triggering the watchdog
3732	 */
3733	wl12xx_rearm_tx_watchdog_locked(wl);
3734
3735	wl->scan.state = WL1271_SCAN_STATE_IDLE;
3736	memset(wl->scan.scanned_ch, 0, sizeof(wl->scan.scanned_ch));
3737	wl->scan_wlvif = NULL;
3738	wl->scan.req = NULL;
3739	ieee80211_scan_completed(wl->hw, &info);
3740
3741out_sleep:
3742	pm_runtime_mark_last_busy(wl->dev);
3743	pm_runtime_put_autosuspend(wl->dev);
3744out:
3745	mutex_unlock(&wl->mutex);
3746
3747	cancel_delayed_work_sync(&wl->scan_complete_work);
3748}
3749
3750static int wl1271_op_sched_scan_start(struct ieee80211_hw *hw,
3751				      struct ieee80211_vif *vif,
3752				      struct cfg80211_sched_scan_request *req,
3753				      struct ieee80211_scan_ies *ies)
3754{
3755	struct wl1271 *wl = hw->priv;
3756	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3757	int ret;
3758
3759	wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_start");
3760
3761	mutex_lock(&wl->mutex);
3762
3763	if (unlikely(wl->state != WLCORE_STATE_ON)) {
3764		ret = -EAGAIN;
3765		goto out;
3766	}
3767
3768	ret = pm_runtime_resume_and_get(wl->dev);
3769	if (ret < 0)
 
3770		goto out;
 
3771
3772	ret = wl->ops->sched_scan_start(wl, wlvif, req, ies);
3773	if (ret < 0)
3774		goto out_sleep;
3775
3776	wl->sched_vif = wlvif;
3777
3778out_sleep:
3779	pm_runtime_mark_last_busy(wl->dev);
3780	pm_runtime_put_autosuspend(wl->dev);
3781out:
3782	mutex_unlock(&wl->mutex);
3783	return ret;
3784}
3785
3786static int wl1271_op_sched_scan_stop(struct ieee80211_hw *hw,
3787				     struct ieee80211_vif *vif)
3788{
3789	struct wl1271 *wl = hw->priv;
3790	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3791	int ret;
3792
3793	wl1271_debug(DEBUG_MAC80211, "wl1271_op_sched_scan_stop");
3794
3795	mutex_lock(&wl->mutex);
3796
3797	if (unlikely(wl->state != WLCORE_STATE_ON))
3798		goto out;
3799
3800	ret = pm_runtime_resume_and_get(wl->dev);
3801	if (ret < 0)
 
3802		goto out;
 
3803
3804	wl->ops->sched_scan_stop(wl, wlvif);
3805
3806	pm_runtime_mark_last_busy(wl->dev);
3807	pm_runtime_put_autosuspend(wl->dev);
3808out:
3809	mutex_unlock(&wl->mutex);
3810
3811	return 0;
3812}
3813
3814static int wl1271_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3815{
3816	struct wl1271 *wl = hw->priv;
3817	int ret = 0;
3818
3819	mutex_lock(&wl->mutex);
3820
3821	if (unlikely(wl->state != WLCORE_STATE_ON)) {
3822		ret = -EAGAIN;
3823		goto out;
3824	}
3825
3826	ret = pm_runtime_resume_and_get(wl->dev);
3827	if (ret < 0)
 
3828		goto out;
 
3829
3830	ret = wl1271_acx_frag_threshold(wl, value);
3831	if (ret < 0)
3832		wl1271_warning("wl1271_op_set_frag_threshold failed: %d", ret);
3833
3834	pm_runtime_mark_last_busy(wl->dev);
3835	pm_runtime_put_autosuspend(wl->dev);
3836
3837out:
3838	mutex_unlock(&wl->mutex);
3839
3840	return ret;
3841}
3842
3843static int wl1271_op_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3844{
3845	struct wl1271 *wl = hw->priv;
3846	struct wl12xx_vif *wlvif;
3847	int ret = 0;
3848
3849	mutex_lock(&wl->mutex);
3850
3851	if (unlikely(wl->state != WLCORE_STATE_ON)) {
3852		ret = -EAGAIN;
3853		goto out;
3854	}
3855
3856	ret = pm_runtime_resume_and_get(wl->dev);
3857	if (ret < 0)
 
3858		goto out;
 
3859
3860	wl12xx_for_each_wlvif(wl, wlvif) {
3861		ret = wl1271_acx_rts_threshold(wl, wlvif, value);
3862		if (ret < 0)
3863			wl1271_warning("set rts threshold failed: %d", ret);
3864	}
3865	pm_runtime_mark_last_busy(wl->dev);
3866	pm_runtime_put_autosuspend(wl->dev);
3867
3868out:
3869	mutex_unlock(&wl->mutex);
3870
3871	return ret;
3872}
3873
3874static void wl12xx_remove_ie(struct sk_buff *skb, u8 eid, int ieoffset)
3875{
3876	int len;
3877	const u8 *next, *end = skb->data + skb->len;
3878	u8 *ie = (u8 *)cfg80211_find_ie(eid, skb->data + ieoffset,
3879					skb->len - ieoffset);
3880	if (!ie)
3881		return;
3882	len = ie[1] + 2;
3883	next = ie + len;
3884	memmove(ie, next, end - next);
3885	skb_trim(skb, skb->len - len);
3886}
3887
3888static void wl12xx_remove_vendor_ie(struct sk_buff *skb,
3889					    unsigned int oui, u8 oui_type,
3890					    int ieoffset)
3891{
3892	int len;
3893	const u8 *next, *end = skb->data + skb->len;
3894	u8 *ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
3895					       skb->data + ieoffset,
3896					       skb->len - ieoffset);
3897	if (!ie)
3898		return;
3899	len = ie[1] + 2;
3900	next = ie + len;
3901	memmove(ie, next, end - next);
3902	skb_trim(skb, skb->len - len);
3903}
3904
3905static int wl1271_ap_set_probe_resp_tmpl(struct wl1271 *wl, u32 rates,
3906					 struct ieee80211_vif *vif)
3907{
3908	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3909	struct sk_buff *skb;
3910	int ret;
3911
3912	skb = ieee80211_proberesp_get(wl->hw, vif);
3913	if (!skb)
3914		return -EOPNOTSUPP;
3915
3916	ret = wl1271_cmd_template_set(wl, wlvif->role_id,
3917				      CMD_TEMPL_AP_PROBE_RESPONSE,
3918				      skb->data,
3919				      skb->len, 0,
3920				      rates);
3921	dev_kfree_skb(skb);
3922
3923	if (ret < 0)
3924		goto out;
3925
3926	wl1271_debug(DEBUG_AP, "probe response updated");
3927	set_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags);
3928
3929out:
3930	return ret;
3931}
3932
3933static int wl1271_ap_set_probe_resp_tmpl_legacy(struct wl1271 *wl,
3934					     struct ieee80211_vif *vif,
3935					     u8 *probe_rsp_data,
3936					     size_t probe_rsp_len,
3937					     u32 rates)
3938{
3939	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
 
3940	u8 probe_rsp_templ[WL1271_CMD_TEMPL_MAX_SIZE];
3941	int ssid_ie_offset, ie_offset, templ_len;
3942	const u8 *ptr;
3943
3944	/* 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					       CMD_TEMPL_AP_PROBE_RESPONSE,
3948					       probe_rsp_data,
3949					       probe_rsp_len, 0,
3950					       rates);
3951
3952	if (probe_rsp_len + vif->cfg.ssid_len > WL1271_CMD_TEMPL_MAX_SIZE) {
3953		wl1271_error("probe_rsp template too big");
3954		return -EINVAL;
3955	}
3956
3957	/* start searching from IE offset */
3958	ie_offset = offsetof(struct ieee80211_mgmt, u.probe_resp.variable);
3959
3960	ptr = cfg80211_find_ie(WLAN_EID_SSID, probe_rsp_data + ie_offset,
3961			       probe_rsp_len - ie_offset);
3962	if (!ptr) {
3963		wl1271_error("No SSID in beacon!");
3964		return -EINVAL;
3965	}
3966
3967	ssid_ie_offset = ptr - probe_rsp_data;
3968	ptr += (ptr[1] + 2);
3969
3970	memcpy(probe_rsp_templ, probe_rsp_data, ssid_ie_offset);
3971
3972	/* insert SSID from bss_conf */
3973	probe_rsp_templ[ssid_ie_offset] = WLAN_EID_SSID;
3974	probe_rsp_templ[ssid_ie_offset + 1] = vif->cfg.ssid_len;
3975	memcpy(probe_rsp_templ + ssid_ie_offset + 2,
3976	       vif->cfg.ssid, vif->cfg.ssid_len);
3977	templ_len = ssid_ie_offset + 2 + vif->cfg.ssid_len;
3978
3979	memcpy(probe_rsp_templ + ssid_ie_offset + 2 + vif->cfg.ssid_len,
3980	       ptr, probe_rsp_len - (ptr - probe_rsp_data));
3981	templ_len += probe_rsp_len - (ptr - probe_rsp_data);
3982
3983	return wl1271_cmd_template_set(wl, wlvif->role_id,
3984				       CMD_TEMPL_AP_PROBE_RESPONSE,
3985				       probe_rsp_templ,
3986				       templ_len, 0,
3987				       rates);
3988}
3989
3990static int wl1271_bss_erp_info_changed(struct wl1271 *wl,
3991				       struct ieee80211_vif *vif,
3992				       struct ieee80211_bss_conf *bss_conf,
3993				       u32 changed)
3994{
3995	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
3996	int ret = 0;
3997
3998	if (changed & BSS_CHANGED_ERP_SLOT) {
3999		if (bss_conf->use_short_slot)
4000			ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_SHORT);
4001		else
4002			ret = wl1271_acx_slot(wl, wlvif, SLOT_TIME_LONG);
4003		if (ret < 0) {
4004			wl1271_warning("Set slot time failed %d", ret);
4005			goto out;
4006		}
4007	}
4008
4009	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
4010		if (bss_conf->use_short_preamble)
4011			wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_SHORT);
4012		else
4013			wl1271_acx_set_preamble(wl, wlvif, ACX_PREAMBLE_LONG);
4014	}
4015
4016	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
4017		if (bss_conf->use_cts_prot)
4018			ret = wl1271_acx_cts_protect(wl, wlvif,
4019						     CTSPROTECT_ENABLE);
4020		else
4021			ret = wl1271_acx_cts_protect(wl, wlvif,
4022						     CTSPROTECT_DISABLE);
4023		if (ret < 0) {
4024			wl1271_warning("Set ctsprotect failed %d", ret);
4025			goto out;
4026		}
4027	}
4028
4029out:
4030	return ret;
4031}
4032
4033static int wlcore_set_beacon_template(struct wl1271 *wl,
4034				      struct ieee80211_vif *vif,
4035				      bool is_ap)
4036{
4037	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4038	struct ieee80211_hdr *hdr;
4039	u32 min_rate;
4040	int ret;
4041	int ieoffset = offsetof(struct ieee80211_mgmt, u.beacon.variable);
4042	struct sk_buff *beacon = ieee80211_beacon_get(wl->hw, vif, 0);
4043	u16 tmpl_id;
4044
4045	if (!beacon) {
4046		ret = -EINVAL;
4047		goto out;
4048	}
4049
4050	wl1271_debug(DEBUG_MASTER, "beacon updated");
4051
4052	ret = wl1271_ssid_set(wlvif, beacon, ieoffset);
4053	if (ret < 0) {
4054		dev_kfree_skb(beacon);
4055		goto out;
4056	}
4057	min_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
4058	tmpl_id = is_ap ? CMD_TEMPL_AP_BEACON :
4059		CMD_TEMPL_BEACON;
4060	ret = wl1271_cmd_template_set(wl, wlvif->role_id, tmpl_id,
4061				      beacon->data,
4062				      beacon->len, 0,
4063				      min_rate);
4064	if (ret < 0) {
4065		dev_kfree_skb(beacon);
4066		goto out;
4067	}
4068
4069	wlvif->wmm_enabled =
4070		cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
4071					WLAN_OUI_TYPE_MICROSOFT_WMM,
4072					beacon->data + ieoffset,
4073					beacon->len - ieoffset);
4074
4075	/*
4076	 * In case we already have a probe-resp beacon set explicitly
4077	 * by usermode, don't use the beacon data.
4078	 */
4079	if (test_bit(WLVIF_FLAG_AP_PROBE_RESP_SET, &wlvif->flags))
4080		goto end_bcn;
4081
4082	/* remove TIM ie from probe response */
4083	wl12xx_remove_ie(beacon, WLAN_EID_TIM, ieoffset);
4084
4085	/*
4086	 * remove p2p ie from probe response.
4087	 * the fw reponds to probe requests that don't include
4088	 * the p2p ie. probe requests with p2p ie will be passed,
4089	 * and will be responded by the supplicant (the spec
4090	 * forbids including the p2p ie when responding to probe
4091	 * requests that didn't include it).
4092	 */
4093	wl12xx_remove_vendor_ie(beacon, WLAN_OUI_WFA,
4094				WLAN_OUI_TYPE_WFA_P2P, ieoffset);
4095
4096	hdr = (struct ieee80211_hdr *) beacon->data;
4097	hdr->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
4098					 IEEE80211_STYPE_PROBE_RESP);
4099	if (is_ap)
4100		ret = wl1271_ap_set_probe_resp_tmpl_legacy(wl, vif,
4101							   beacon->data,
4102							   beacon->len,
4103							   min_rate);
4104	else
4105		ret = wl1271_cmd_template_set(wl, wlvif->role_id,
4106					      CMD_TEMPL_PROBE_RESPONSE,
4107					      beacon->data,
4108					      beacon->len, 0,
4109					      min_rate);
4110end_bcn:
4111	dev_kfree_skb(beacon);
4112	if (ret < 0)
4113		goto out;
4114
4115out:
4116	return ret;
4117}
4118
4119static int wl1271_bss_beacon_info_changed(struct wl1271 *wl,
4120					  struct ieee80211_vif *vif,
4121					  struct ieee80211_bss_conf *bss_conf,
4122					  u32 changed)
4123{
4124	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4125	bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
4126	int ret = 0;
4127
4128	if (changed & BSS_CHANGED_BEACON_INT) {
4129		wl1271_debug(DEBUG_MASTER, "beacon interval updated: %d",
4130			bss_conf->beacon_int);
4131
4132		wlvif->beacon_int = bss_conf->beacon_int;
4133	}
4134
4135	if ((changed & BSS_CHANGED_AP_PROBE_RESP) && is_ap) {
4136		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		if (ret < 0)
4144			goto out;
4145
4146		if (test_and_clear_bit(WLVIF_FLAG_BEACON_DISABLED,
4147				       &wlvif->flags)) {
4148			ret = wlcore_hw_dfs_master_restart(wl, wlvif);
4149			if (ret < 0)
4150				goto out;
4151		}
4152	}
4153out:
4154	if (ret != 0)
4155		wl1271_error("beacon info change failed: %d", ret);
4156	return ret;
4157}
4158
4159/* AP mode changes */
4160static void wl1271_bss_info_changed_ap(struct wl1271 *wl,
4161				       struct ieee80211_vif *vif,
4162				       struct ieee80211_bss_conf *bss_conf,
4163				       u32 changed)
4164{
4165	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4166	int ret = 0;
4167
4168	if (changed & BSS_CHANGED_BASIC_RATES) {
4169		u32 rates = bss_conf->basic_rates;
4170
4171		wlvif->basic_rate_set = wl1271_tx_enabled_rates_get(wl, rates,
4172								 wlvif->band);
4173		wlvif->basic_rate = wl1271_tx_min_rate_get(wl,
4174							wlvif->basic_rate_set);
4175
4176		ret = wl1271_init_ap_rates(wl, wlvif);
4177		if (ret < 0) {
4178			wl1271_error("AP rate policy change failed %d", ret);
4179			goto out;
4180		}
4181
4182		ret = wl1271_ap_init_templates(wl, vif);
4183		if (ret < 0)
4184			goto out;
4185
4186		/* No need to set probe resp template for mesh */
4187		if (!ieee80211_vif_is_mesh(vif)) {
4188			ret = wl1271_ap_set_probe_resp_tmpl(wl,
4189							    wlvif->basic_rate,
4190							    vif);
4191			if (ret < 0)
4192				goto out;
4193		}
4194
4195		ret = wlcore_set_beacon_template(wl, vif, true);
4196		if (ret < 0)
4197			goto out;
4198	}
4199
4200	ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf, changed);
4201	if (ret < 0)
4202		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)) {
4207				ret = wl12xx_cmd_role_start_ap(wl, wlvif);
4208				if (ret < 0)
4209					goto out;
4210
4211				ret = wl1271_ap_init_hwenc(wl, wlvif);
4212				if (ret < 0)
4213					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				 * AP might be in ROC in case we have just
4222				 * sent auth reply. handle it.
4223				 */
4224				if (test_bit(wlvif->role_id, wl->roc_map))
4225					wl12xx_croc(wl, wlvif->role_id);
4226
4227				ret = wl12xx_cmd_role_stop_ap(wl, wlvif);
4228				if (ret < 0)
4229					goto out;
4230
4231				clear_bit(WLVIF_FLAG_AP_STARTED, &wlvif->flags);
4232				clear_bit(WLVIF_FLAG_AP_PROBE_RESP_SET,
4233					  &wlvif->flags);
4234				wl1271_debug(DEBUG_AP, "stopped AP");
4235			}
4236		}
4237	}
4238
4239	ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
4240	if (ret < 0)
4241		goto out;
4242
4243	/* Handle HT information change */
4244	if ((changed & BSS_CHANGED_HT) &&
4245	    (bss_conf->chandef.width != NL80211_CHAN_WIDTH_20_NOHT)) {
4246		ret = wl1271_acx_set_ht_information(wl, wlvif,
4247					bss_conf->ht_operation_mode);
4248		if (ret < 0) {
4249			wl1271_warning("Set ht information failed %d", ret);
4250			goto out;
4251		}
4252	}
4253
4254out:
4255	return;
4256}
4257
4258static int wlcore_set_bssid(struct wl1271 *wl, struct wl12xx_vif *wlvif,
4259			    struct ieee80211_vif *vif, u32 sta_rate_set)
 
4260{
4261	struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
4262	u32 rates;
4263	int ret;
4264
4265	wl1271_debug(DEBUG_MAC80211,
4266	     "changed_bssid: %pM, aid: %d, bcn_int: %d, brates: 0x%x sta_rate_set: 0x%x",
4267	     bss_conf->bssid, vif->cfg.aid,
4268	     bss_conf->beacon_int,
4269	     bss_conf->basic_rates, sta_rate_set);
4270
4271	wlvif->beacon_int = bss_conf->beacon_int;
4272	rates = bss_conf->basic_rates;
4273	wlvif->basic_rate_set =
4274		wl1271_tx_enabled_rates_get(wl, rates,
4275					    wlvif->band);
4276	wlvif->basic_rate =
4277		wl1271_tx_min_rate_get(wl,
4278				       wlvif->basic_rate_set);
4279
4280	if (sta_rate_set)
4281		wlvif->rate_set =
4282			wl1271_tx_enabled_rates_get(wl,
4283						sta_rate_set,
4284						wlvif->band);
4285
4286	/* we only support sched_scan while not connected */
4287	if (wl->sched_vif == wlvif)
4288		wl->ops->sched_scan_stop(wl, wlvif);
4289
4290	ret = wl1271_acx_sta_rate_policies(wl, wlvif);
4291	if (ret < 0)
4292		return ret;
4293
4294	ret = wl12xx_cmd_build_null_data(wl, wlvif);
4295	if (ret < 0)
4296		return ret;
4297
4298	ret = wl1271_build_qos_null_data(wl, wl12xx_wlvif_to_vif(wlvif));
4299	if (ret < 0)
4300		return ret;
4301
4302	wlcore_set_ssid(wl, wlvif);
4303
4304	set_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
4305
4306	return 0;
4307}
4308
4309static int wlcore_clear_bssid(struct wl1271 *wl, struct wl12xx_vif *wlvif)
4310{
4311	int ret;
4312
4313	/* revert back to minimum rates for the current band */
4314	wl1271_set_band_rate(wl, wlvif);
4315	wlvif->basic_rate = wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
4316
4317	ret = wl1271_acx_sta_rate_policies(wl, wlvif);
4318	if (ret < 0)
4319		return ret;
4320
4321	if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
4322	    test_bit(WLVIF_FLAG_IN_USE, &wlvif->flags)) {
4323		ret = wl12xx_cmd_role_stop_sta(wl, wlvif);
4324		if (ret < 0)
4325			return ret;
4326	}
4327
4328	clear_bit(WLVIF_FLAG_IN_USE, &wlvif->flags);
4329	return 0;
4330}
4331/* STA/IBSS mode changes */
4332static void wl1271_bss_info_changed_sta(struct wl1271 *wl,
4333					struct ieee80211_vif *vif,
4334					struct ieee80211_bss_conf *bss_conf,
4335					u32 changed)
4336{
4337	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4338	bool do_join = false;
4339	bool is_ibss = (wlvif->bss_type == BSS_TYPE_IBSS);
4340	bool ibss_joined = false;
4341	u32 sta_rate_set = 0;
4342	int ret;
4343	struct ieee80211_sta *sta;
4344	bool sta_exists = false;
4345	struct ieee80211_sta_ht_cap sta_ht_cap;
4346
4347	if (is_ibss) {
4348		ret = wl1271_bss_beacon_info_changed(wl, vif, bss_conf,
4349						     changed);
4350		if (ret < 0)
4351			goto out;
4352	}
4353
4354	if (changed & BSS_CHANGED_IBSS) {
4355		if (vif->cfg.ibss_joined) {
4356			set_bit(WLVIF_FLAG_IBSS_JOINED, &wlvif->flags);
4357			ibss_joined = true;
4358		} else {
4359			wlcore_unset_assoc(wl, wlvif);
4360			wl12xx_cmd_role_stop_sta(wl, wlvif);
4361		}
4362	}
4363
4364	if ((changed & BSS_CHANGED_BEACON_INT) && ibss_joined)
4365		do_join = true;
4366
4367	/* Need to update the SSID (for filtering etc) */
4368	if ((changed & BSS_CHANGED_BEACON) && ibss_joined)
4369		do_join = true;
4370
4371	if ((changed & BSS_CHANGED_BEACON_ENABLED) && ibss_joined) {
4372		wl1271_debug(DEBUG_ADHOC, "ad-hoc beaconing: %s",
4373			     bss_conf->enable_beacon ? "enabled" : "disabled");
4374
4375		do_join = true;
4376	}
4377
4378	if (changed & BSS_CHANGED_IDLE && !is_ibss)
4379		wl1271_sta_handle_idle(wl, wlvif, vif->cfg.idle);
4380
4381	if (changed & BSS_CHANGED_CQM) {
4382		bool enable = false;
4383		if (bss_conf->cqm_rssi_thold)
4384			enable = true;
4385		ret = wl1271_acx_rssi_snr_trigger(wl, wlvif, enable,
4386						  bss_conf->cqm_rssi_thold,
4387						  bss_conf->cqm_rssi_hyst);
4388		if (ret < 0)
4389			goto out;
4390		wlvif->rssi_thold = bss_conf->cqm_rssi_thold;
4391	}
4392
4393	if (changed & (BSS_CHANGED_BSSID | BSS_CHANGED_HT |
4394		       BSS_CHANGED_ASSOC)) {
4395		rcu_read_lock();
4396		sta = ieee80211_find_sta(vif, bss_conf->bssid);
4397		if (sta) {
4398			u8 *rx_mask = sta->deflink.ht_cap.mcs.rx_mask;
4399
4400			/* save the supp_rates of the ap */
4401			sta_rate_set = sta->deflink.supp_rates[wlvif->band];
4402			if (sta->deflink.ht_cap.ht_supported)
4403				sta_rate_set |=
4404					(rx_mask[0] << HW_HT_RATES_OFFSET) |
4405					(rx_mask[1] << HW_MIMO_RATES_OFFSET);
4406			sta_ht_cap = sta->deflink.ht_cap;
4407			sta_exists = true;
4408		}
4409
4410		rcu_read_unlock();
4411	}
4412
4413	if (changed & BSS_CHANGED_BSSID) {
4414		if (!is_zero_ether_addr(bss_conf->bssid)) {
4415			ret = wlcore_set_bssid(wl, wlvif, vif,
4416					       sta_rate_set);
4417			if (ret < 0)
4418				goto out;
4419
4420			/* Need to update the BSSID (for filtering etc) */
4421			do_join = true;
4422		} else {
4423			ret = wlcore_clear_bssid(wl, wlvif);
4424			if (ret < 0)
4425				goto out;
4426		}
4427	}
4428
4429	if (changed & BSS_CHANGED_IBSS) {
4430		wl1271_debug(DEBUG_ADHOC, "ibss_joined: %d",
4431			     vif->cfg.ibss_joined);
4432
4433		if (vif->cfg.ibss_joined) {
4434			u32 rates = bss_conf->basic_rates;
4435			wlvif->basic_rate_set =
4436				wl1271_tx_enabled_rates_get(wl, rates,
4437							    wlvif->band);
4438			wlvif->basic_rate =
4439				wl1271_tx_min_rate_get(wl,
4440						       wlvif->basic_rate_set);
4441
4442			/* by default, use 11b + OFDM rates */
4443			wlvif->rate_set = CONF_TX_IBSS_DEFAULT_RATES;
4444			ret = wl1271_acx_sta_rate_policies(wl, wlvif);
4445			if (ret < 0)
4446				goto out;
4447		}
4448	}
4449
4450	if ((changed & BSS_CHANGED_BEACON_INFO) && bss_conf->dtim_period) {
4451		/* enable beacon filtering */
4452		ret = wl1271_acx_beacon_filter_opt(wl, wlvif, true);
4453		if (ret < 0)
4454			goto out;
4455	}
4456
4457	ret = wl1271_bss_erp_info_changed(wl, vif, bss_conf, changed);
4458	if (ret < 0)
4459		goto out;
4460
4461	if (do_join) {
4462		ret = wlcore_join(wl, wlvif);
4463		if (ret < 0) {
4464			wl1271_warning("cmd join failed %d", ret);
4465			goto out;
4466		}
4467	}
4468
4469	if (changed & BSS_CHANGED_ASSOC) {
4470		if (vif->cfg.assoc) {
4471			ret = wlcore_set_assoc(wl, wlvif, bss_conf,
4472					       sta_rate_set);
4473			if (ret < 0)
4474				goto out;
4475
4476			if (test_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags))
4477				wl12xx_set_authorized(wl, wlvif);
4478		} else {
4479			wlcore_unset_assoc(wl, wlvif);
4480		}
4481	}
4482
4483	if (changed & BSS_CHANGED_PS) {
4484		if (vif->cfg.ps &&
4485		    test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags) &&
4486		    !test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
4487			int ps_mode;
4488			char *ps_mode_str;
4489
4490			if (wl->conf.conn.forced_ps) {
4491				ps_mode = STATION_POWER_SAVE_MODE;
4492				ps_mode_str = "forced";
4493			} else {
4494				ps_mode = STATION_AUTO_PS_MODE;
4495				ps_mode_str = "auto";
4496			}
4497
4498			wl1271_debug(DEBUG_PSM, "%s ps enabled", ps_mode_str);
4499
4500			ret = wl1271_ps_set_mode(wl, wlvif, ps_mode);
4501			if (ret < 0)
4502				wl1271_warning("enter %s ps failed %d",
4503					       ps_mode_str, ret);
4504		} else if (!vif->cfg.ps &&
4505			   test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags)) {
4506			wl1271_debug(DEBUG_PSM, "auto ps disabled");
4507
4508			ret = wl1271_ps_set_mode(wl, wlvif,
4509						 STATION_ACTIVE_MODE);
4510			if (ret < 0)
4511				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
4520		ret = wlcore_hw_set_peer_cap(wl,
4521					     &sta_ht_cap,
4522					     enabled,
4523					     wlvif->rate_set,
4524					     wlvif->sta.hlid);
4525		if (ret < 0) {
4526			wl1271_warning("Set ht cap failed %d", ret);
4527			goto out;
4528
4529		}
4530
4531		if (enabled) {
4532			ret = wl1271_acx_set_ht_information(wl, wlvif,
4533						bss_conf->ht_operation_mode);
4534			if (ret < 0) {
4535				wl1271_warning("Set ht information failed %d",
4536					       ret);
4537				goto out;
4538			}
4539		}
4540	}
4541
4542	/* Handle arp filtering. Done after join. */
4543	if ((changed & BSS_CHANGED_ARP_FILTER) ||
4544	    (!is_ibss && (changed & BSS_CHANGED_QOS))) {
4545		__be32 addr = vif->cfg.arp_addr_list[0];
4546		wlvif->sta.qos = bss_conf->qos;
4547		WARN_ON(wlvif->bss_type != BSS_TYPE_STA_BSS);
4548
4549		if (vif->cfg.arp_addr_cnt == 1 && vif->cfg.assoc) {
4550			wlvif->ip_addr = addr;
4551			/*
4552			 * The template should have been configured only upon
4553			 * association. however, it seems that the correct ip
4554			 * isn't being set (when sending), so we have to
4555			 * reconfigure the template upon every ip change.
4556			 */
4557			ret = wl1271_cmd_build_arp_rsp(wl, wlvif);
4558			if (ret < 0) {
4559				wl1271_warning("build arp rsp failed: %d", ret);
4560				goto out;
4561			}
4562
4563			ret = wl1271_acx_arp_ip_filter(wl, wlvif,
4564				(ACX_ARP_FILTER_ARP_FILTERING |
4565				 ACX_ARP_FILTER_AUTO_ARP),
4566				addr);
4567		} else {
4568			wlvif->ip_addr = 0;
4569			ret = wl1271_acx_arp_ip_filter(wl, wlvif, 0, addr);
4570		}
4571
4572		if (ret < 0)
4573			goto out;
4574	}
4575
4576out:
4577	return;
4578}
4579
4580static void wl1271_op_bss_info_changed(struct ieee80211_hw *hw,
4581				       struct ieee80211_vif *vif,
4582				       struct ieee80211_bss_conf *bss_conf,
4583				       u64 changed)
4584{
4585	struct wl1271 *wl = hw->priv;
4586	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4587	bool is_ap = (wlvif->bss_type == BSS_TYPE_AP_BSS);
4588	int ret;
4589
4590	wl1271_debug(DEBUG_MAC80211, "mac80211 bss info role %d changed 0x%x",
4591		     wlvif->role_id, (int)changed);
4592
4593	/*
4594	 * make sure to cancel pending disconnections if our association
4595	 * state changed
4596	 */
4597	if (!is_ap && (changed & BSS_CHANGED_ASSOC))
4598		cancel_delayed_work_sync(&wlvif->connection_loss_work);
4599
4600	if (is_ap && (changed & BSS_CHANGED_BEACON_ENABLED) &&
4601	    !bss_conf->enable_beacon)
4602		wl1271_tx_flush(wl);
4603
4604	mutex_lock(&wl->mutex);
4605
4606	if (unlikely(wl->state != WLCORE_STATE_ON))
4607		goto out;
4608
4609	if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)))
4610		goto out;
4611
4612	ret = pm_runtime_resume_and_get(wl->dev);
4613	if (ret < 0)
 
4614		goto out;
 
4615
4616	if ((changed & BSS_CHANGED_TXPOWER) &&
4617	    bss_conf->txpower != wlvif->power_level) {
4618
4619		ret = wl1271_acx_tx_power(wl, wlvif, bss_conf->txpower);
4620		if (ret < 0)
4621			goto out;
4622
4623		wlvif->power_level = bss_conf->txpower;
4624	}
4625
4626	if (is_ap)
4627		wl1271_bss_info_changed_ap(wl, vif, bss_conf, changed);
4628	else
4629		wl1271_bss_info_changed_sta(wl, vif, bss_conf, changed);
4630
4631	pm_runtime_mark_last_busy(wl->dev);
4632	pm_runtime_put_autosuspend(wl->dev);
4633
4634out:
4635	mutex_unlock(&wl->mutex);
4636}
4637
4638static int wlcore_op_add_chanctx(struct ieee80211_hw *hw,
4639				 struct ieee80211_chanctx_conf *ctx)
4640{
4641	wl1271_debug(DEBUG_MAC80211, "mac80211 add chanctx %d (type %d)",
4642		     ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
4643		     cfg80211_get_chandef_type(&ctx->def));
4644	return 0;
4645}
4646
4647static void wlcore_op_remove_chanctx(struct ieee80211_hw *hw,
4648				     struct ieee80211_chanctx_conf *ctx)
4649{
4650	wl1271_debug(DEBUG_MAC80211, "mac80211 remove chanctx %d (type %d)",
4651		     ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
4652		     cfg80211_get_chandef_type(&ctx->def));
4653}
4654
4655static void wlcore_op_change_chanctx(struct ieee80211_hw *hw,
4656				     struct ieee80211_chanctx_conf *ctx,
4657				     u32 changed)
4658{
4659	struct wl1271 *wl = hw->priv;
4660	struct wl12xx_vif *wlvif;
4661	int ret;
4662	int channel = ieee80211_frequency_to_channel(
4663		ctx->def.chan->center_freq);
4664
4665	wl1271_debug(DEBUG_MAC80211,
4666		     "mac80211 change chanctx %d (type %d) changed 0x%x",
4667		     channel, cfg80211_get_chandef_type(&ctx->def), changed);
4668
4669	mutex_lock(&wl->mutex);
4670
4671	ret = pm_runtime_resume_and_get(wl->dev);
4672	if (ret < 0)
 
4673		goto out;
 
4674
4675	wl12xx_for_each_wlvif(wl, wlvif) {
4676		struct ieee80211_vif *vif = wl12xx_wlvif_to_vif(wlvif);
4677
4678		rcu_read_lock();
4679		if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != ctx) {
4680			rcu_read_unlock();
4681			continue;
4682		}
4683		rcu_read_unlock();
4684
4685		/* start radar if needed */
4686		if (changed & IEEE80211_CHANCTX_CHANGE_RADAR &&
4687		    wlvif->bss_type == BSS_TYPE_AP_BSS &&
4688		    ctx->radar_enabled && !wlvif->radar_enabled &&
4689		    ctx->def.chan->dfs_state == NL80211_DFS_USABLE) {
4690			wl1271_debug(DEBUG_MAC80211, "Start radar detection");
4691			wlcore_hw_set_cac(wl, wlvif, true);
4692			wlvif->radar_enabled = true;
4693		}
4694	}
4695
4696	pm_runtime_mark_last_busy(wl->dev);
4697	pm_runtime_put_autosuspend(wl->dev);
4698out:
4699	mutex_unlock(&wl->mutex);
4700}
4701
4702static int wlcore_op_assign_vif_chanctx(struct ieee80211_hw *hw,
4703					struct ieee80211_vif *vif,
4704					struct ieee80211_bss_conf *link_conf,
4705					struct ieee80211_chanctx_conf *ctx)
4706{
4707	struct wl1271 *wl = hw->priv;
4708	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4709	int channel = ieee80211_frequency_to_channel(
4710		ctx->def.chan->center_freq);
4711	int ret = -EINVAL;
4712
4713	wl1271_debug(DEBUG_MAC80211,
4714		     "mac80211 assign chanctx (role %d) %d (type %d) (radar %d dfs_state %d)",
4715		     wlvif->role_id, channel,
4716		     cfg80211_get_chandef_type(&ctx->def),
4717		     ctx->radar_enabled, ctx->def.chan->dfs_state);
4718
4719	mutex_lock(&wl->mutex);
4720
4721	if (unlikely(wl->state != WLCORE_STATE_ON))
4722		goto out;
4723
4724	if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)))
4725		goto out;
4726
4727	ret = pm_runtime_resume_and_get(wl->dev);
4728	if (ret < 0)
 
4729		goto out;
 
4730
4731	wlvif->band = ctx->def.chan->band;
4732	wlvif->channel = channel;
4733	wlvif->channel_type = cfg80211_get_chandef_type(&ctx->def);
4734
4735	/* update default rates according to the band */
4736	wl1271_set_band_rate(wl, wlvif);
4737
4738	if (ctx->radar_enabled &&
4739	    ctx->def.chan->dfs_state == NL80211_DFS_USABLE) {
4740		wl1271_debug(DEBUG_MAC80211, "Start radar detection");
4741		wlcore_hw_set_cac(wl, wlvif, true);
4742		wlvif->radar_enabled = true;
4743	}
4744
4745	pm_runtime_mark_last_busy(wl->dev);
4746	pm_runtime_put_autosuspend(wl->dev);
4747out:
4748	mutex_unlock(&wl->mutex);
4749
4750	return 0;
4751}
4752
4753static void wlcore_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
4754					   struct ieee80211_vif *vif,
4755					   struct ieee80211_bss_conf *link_conf,
4756					   struct ieee80211_chanctx_conf *ctx)
4757{
4758	struct wl1271 *wl = hw->priv;
4759	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4760	int ret;
4761
4762	wl1271_debug(DEBUG_MAC80211,
4763		     "mac80211 unassign chanctx (role %d) %d (type %d)",
4764		     wlvif->role_id,
4765		     ieee80211_frequency_to_channel(ctx->def.chan->center_freq),
4766		     cfg80211_get_chandef_type(&ctx->def));
4767
4768	wl1271_tx_flush(wl);
4769
4770	mutex_lock(&wl->mutex);
4771
4772	if (unlikely(wl->state != WLCORE_STATE_ON))
4773		goto out;
4774
4775	if (unlikely(!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags)))
4776		goto out;
4777
4778	ret = pm_runtime_resume_and_get(wl->dev);
4779	if (ret < 0)
 
4780		goto out;
 
4781
4782	if (wlvif->radar_enabled) {
4783		wl1271_debug(DEBUG_MAC80211, "Stop radar detection");
4784		wlcore_hw_set_cac(wl, wlvif, false);
4785		wlvif->radar_enabled = false;
4786	}
4787
4788	pm_runtime_mark_last_busy(wl->dev);
4789	pm_runtime_put_autosuspend(wl->dev);
4790out:
4791	mutex_unlock(&wl->mutex);
4792}
4793
4794static int __wlcore_switch_vif_chan(struct wl1271 *wl,
4795				    struct wl12xx_vif *wlvif,
4796				    struct ieee80211_chanctx_conf *new_ctx)
4797{
4798	int channel = ieee80211_frequency_to_channel(
4799		new_ctx->def.chan->center_freq);
4800
4801	wl1271_debug(DEBUG_MAC80211,
4802		     "switch vif (role %d) %d -> %d chan_type: %d",
4803		     wlvif->role_id, wlvif->channel, channel,
4804		     cfg80211_get_chandef_type(&new_ctx->def));
4805
4806	if (WARN_ON_ONCE(wlvif->bss_type != BSS_TYPE_AP_BSS))
4807		return 0;
4808
4809	WARN_ON(!test_bit(WLVIF_FLAG_BEACON_DISABLED, &wlvif->flags));
4810
4811	if (wlvif->radar_enabled) {
4812		wl1271_debug(DEBUG_MAC80211, "Stop radar detection");
4813		wlcore_hw_set_cac(wl, wlvif, false);
4814		wlvif->radar_enabled = false;
4815	}
4816
4817	wlvif->band = new_ctx->def.chan->band;
4818	wlvif->channel = channel;
4819	wlvif->channel_type = cfg80211_get_chandef_type(&new_ctx->def);
4820
4821	/* start radar if needed */
4822	if (new_ctx->radar_enabled) {
4823		wl1271_debug(DEBUG_MAC80211, "Start radar detection");
4824		wlcore_hw_set_cac(wl, wlvif, true);
4825		wlvif->radar_enabled = true;
4826	}
4827
4828	return 0;
4829}
4830
4831static int
4832wlcore_op_switch_vif_chanctx(struct ieee80211_hw *hw,
4833			     struct ieee80211_vif_chanctx_switch *vifs,
4834			     int n_vifs,
4835			     enum ieee80211_chanctx_switch_mode mode)
4836{
4837	struct wl1271 *wl = hw->priv;
4838	int i, ret;
4839
4840	wl1271_debug(DEBUG_MAC80211,
4841		     "mac80211 switch chanctx n_vifs %d mode %d",
4842		     n_vifs, mode);
4843
4844	mutex_lock(&wl->mutex);
4845
4846	ret = pm_runtime_resume_and_get(wl->dev);
4847	if (ret < 0)
 
4848		goto out;
 
4849
4850	for (i = 0; i < n_vifs; i++) {
4851		struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vifs[i].vif);
4852
4853		ret = __wlcore_switch_vif_chan(wl, wlvif, vifs[i].new_ctx);
4854		if (ret)
4855			goto out_sleep;
4856	}
4857out_sleep:
4858	pm_runtime_mark_last_busy(wl->dev);
4859	pm_runtime_put_autosuspend(wl->dev);
4860out:
4861	mutex_unlock(&wl->mutex);
4862
4863	return 0;
4864}
4865
4866static int wl1271_op_conf_tx(struct ieee80211_hw *hw,
4867			     struct ieee80211_vif *vif,
4868			     unsigned int link_id, u16 queue,
4869			     const struct ieee80211_tx_queue_params *params)
4870{
4871	struct wl1271 *wl = hw->priv;
4872	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4873	u8 ps_scheme;
4874	int ret = 0;
4875
4876	if (wlcore_is_p2p_mgmt(wlvif))
4877		return 0;
4878
4879	mutex_lock(&wl->mutex);
4880
4881	wl1271_debug(DEBUG_MAC80211, "mac80211 conf tx %d", queue);
4882
4883	if (params->uapsd)
4884		ps_scheme = CONF_PS_SCHEME_UPSD_TRIGGER;
4885	else
4886		ps_scheme = CONF_PS_SCHEME_LEGACY;
4887
4888	if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
4889		goto out;
4890
4891	ret = pm_runtime_resume_and_get(wl->dev);
4892	if (ret < 0)
 
4893		goto out;
 
4894
4895	/*
4896	 * the txop is confed in units of 32us by the mac80211,
4897	 * we need us
4898	 */
4899	ret = wl1271_acx_ac_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
4900				params->cw_min, params->cw_max,
4901				params->aifs, params->txop << 5);
4902	if (ret < 0)
4903		goto out_sleep;
4904
4905	ret = wl1271_acx_tid_cfg(wl, wlvif, wl1271_tx_get_queue(queue),
4906				 CONF_CHANNEL_TYPE_EDCF,
4907				 wl1271_tx_get_queue(queue),
4908				 ps_scheme, CONF_ACK_POLICY_LEGACY,
4909				 0, 0);
4910
4911out_sleep:
4912	pm_runtime_mark_last_busy(wl->dev);
4913	pm_runtime_put_autosuspend(wl->dev);
4914
4915out:
4916	mutex_unlock(&wl->mutex);
4917
4918	return ret;
4919}
4920
4921static u64 wl1271_op_get_tsf(struct ieee80211_hw *hw,
4922			     struct ieee80211_vif *vif)
4923{
4924
4925	struct wl1271 *wl = hw->priv;
4926	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
4927	u64 mactime = ULLONG_MAX;
4928	int ret;
4929
4930	wl1271_debug(DEBUG_MAC80211, "mac80211 get tsf");
4931
4932	mutex_lock(&wl->mutex);
4933
4934	if (unlikely(wl->state != WLCORE_STATE_ON))
4935		goto out;
4936
4937	ret = pm_runtime_resume_and_get(wl->dev);
4938	if (ret < 0)
 
4939		goto out;
 
4940
4941	ret = wl12xx_acx_tsf_info(wl, wlvif, &mactime);
4942	if (ret < 0)
4943		goto out_sleep;
4944
4945out_sleep:
4946	pm_runtime_mark_last_busy(wl->dev);
4947	pm_runtime_put_autosuspend(wl->dev);
4948
4949out:
4950	mutex_unlock(&wl->mutex);
4951	return mactime;
4952}
4953
4954static int wl1271_op_get_survey(struct ieee80211_hw *hw, int idx,
4955				struct survey_info *survey)
4956{
4957	struct ieee80211_conf *conf = &hw->conf;
4958
4959	if (idx != 0)
4960		return -ENOENT;
4961
4962	survey->channel = conf->chandef.chan;
4963	survey->filled = 0;
4964	return 0;
4965}
4966
4967static int wl1271_allocate_sta(struct wl1271 *wl,
4968			     struct wl12xx_vif *wlvif,
4969			     struct ieee80211_sta *sta)
4970{
4971	struct wl1271_station *wl_sta;
4972	int ret;
4973
4974
4975	if (wl->active_sta_count >= wl->max_ap_stations) {
4976		wl1271_warning("could not allocate HLID - too much stations");
4977		return -EBUSY;
4978	}
4979
4980	wl_sta = (struct wl1271_station *)sta->drv_priv;
4981	ret = wl12xx_allocate_link(wl, wlvif, &wl_sta->hlid);
4982	if (ret < 0) {
4983		wl1271_warning("could not allocate HLID - too many links");
4984		return -EBUSY;
4985	}
4986
4987	/* use the previous security seq, if this is a recovery/resume */
4988	wl->links[wl_sta->hlid].total_freed_pkts = wl_sta->total_freed_pkts;
4989
4990	set_bit(wl_sta->hlid, wlvif->ap.sta_hlid_map);
4991	memcpy(wl->links[wl_sta->hlid].addr, sta->addr, ETH_ALEN);
4992	wl->active_sta_count++;
4993	return 0;
4994}
4995
4996void wl1271_free_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif, u8 hlid)
4997{
4998	if (!test_bit(hlid, wlvif->ap.sta_hlid_map))
4999		return;
5000
5001	clear_bit(hlid, wlvif->ap.sta_hlid_map);
5002	__clear_bit(hlid, &wl->ap_ps_map);
5003	__clear_bit(hlid, &wl->ap_fw_ps_map);
5004
5005	/*
5006	 * save the last used PN in the private part of iee80211_sta,
5007	 * in case of recovery/suspend
5008	 */
5009	wlcore_save_freed_pkts_addr(wl, wlvif, hlid, wl->links[hlid].addr);
5010
5011	wl12xx_free_link(wl, wlvif, &hlid);
5012	wl->active_sta_count--;
5013
5014	/*
5015	 * rearm the tx watchdog when the last STA is freed - give the FW a
5016	 * chance to return STA-buffered packets before complaining.
5017	 */
5018	if (wl->active_sta_count == 0)
5019		wl12xx_rearm_tx_watchdog_locked(wl);
5020}
5021
5022static int wl12xx_sta_add(struct wl1271 *wl,
5023			  struct wl12xx_vif *wlvif,
5024			  struct ieee80211_sta *sta)
5025{
5026	struct wl1271_station *wl_sta;
5027	int ret = 0;
5028	u8 hlid;
5029
5030	wl1271_debug(DEBUG_MAC80211, "mac80211 add sta %d", (int)sta->aid);
5031
5032	ret = wl1271_allocate_sta(wl, wlvif, sta);
5033	if (ret < 0)
5034		return ret;
5035
5036	wl_sta = (struct wl1271_station *)sta->drv_priv;
5037	hlid = wl_sta->hlid;
5038
5039	ret = wl12xx_cmd_add_peer(wl, wlvif, sta, hlid);
5040	if (ret < 0)
5041		wl1271_free_sta(wl, wlvif, hlid);
5042
5043	return ret;
5044}
5045
5046static int wl12xx_sta_remove(struct wl1271 *wl,
5047			     struct wl12xx_vif *wlvif,
5048			     struct ieee80211_sta *sta)
5049{
5050	struct wl1271_station *wl_sta;
5051	int ret = 0, id;
5052
5053	wl1271_debug(DEBUG_MAC80211, "mac80211 remove sta %d", (int)sta->aid);
5054
5055	wl_sta = (struct wl1271_station *)sta->drv_priv;
5056	id = wl_sta->hlid;
5057	if (WARN_ON(!test_bit(id, wlvif->ap.sta_hlid_map)))
5058		return -EINVAL;
5059
5060	ret = wl12xx_cmd_remove_peer(wl, wlvif, wl_sta->hlid);
5061	if (ret < 0)
5062		return ret;
5063
5064	wl1271_free_sta(wl, wlvif, wl_sta->hlid);
5065	return ret;
5066}
5067
5068static void wlcore_roc_if_possible(struct wl1271 *wl,
5069				   struct wl12xx_vif *wlvif)
5070{
5071	if (find_first_bit(wl->roc_map,
5072			   WL12XX_MAX_ROLES) < WL12XX_MAX_ROLES)
5073		return;
5074
5075	if (WARN_ON(wlvif->role_id == WL12XX_INVALID_ROLE_ID))
5076		return;
5077
5078	wl12xx_roc(wl, wlvif, wlvif->role_id, wlvif->band, wlvif->channel);
5079}
5080
5081/*
5082 * when wl_sta is NULL, we treat this call as if coming from a
5083 * pending auth reply.
5084 * wl->mutex must be taken and the FW must be awake when the call
5085 * takes place.
5086 */
5087void wlcore_update_inconn_sta(struct wl1271 *wl, struct wl12xx_vif *wlvif,
5088			      struct wl1271_station *wl_sta, bool in_conn)
5089{
5090	if (in_conn) {
5091		if (WARN_ON(wl_sta && wl_sta->in_connection))
5092			return;
5093
5094		if (!wlvif->ap_pending_auth_reply &&
5095		    !wlvif->inconn_count)
5096			wlcore_roc_if_possible(wl, wlvif);
5097
5098		if (wl_sta) {
5099			wl_sta->in_connection = true;
5100			wlvif->inconn_count++;
5101		} else {
5102			wlvif->ap_pending_auth_reply = true;
5103		}
5104	} else {
5105		if (wl_sta && !wl_sta->in_connection)
5106			return;
5107
5108		if (WARN_ON(!wl_sta && !wlvif->ap_pending_auth_reply))
5109			return;
5110
5111		if (WARN_ON(wl_sta && !wlvif->inconn_count))
5112			return;
5113
5114		if (wl_sta) {
5115			wl_sta->in_connection = false;
5116			wlvif->inconn_count--;
5117		} else {
5118			wlvif->ap_pending_auth_reply = false;
5119		}
5120
5121		if (!wlvif->inconn_count && !wlvif->ap_pending_auth_reply &&
5122		    test_bit(wlvif->role_id, wl->roc_map))
5123			wl12xx_croc(wl, wlvif->role_id);
5124	}
5125}
5126
5127static int wl12xx_update_sta_state(struct wl1271 *wl,
5128				   struct wl12xx_vif *wlvif,
5129				   struct ieee80211_sta *sta,
5130				   enum ieee80211_sta_state old_state,
5131				   enum ieee80211_sta_state new_state)
5132{
5133	struct wl1271_station *wl_sta;
5134	bool is_ap = wlvif->bss_type == BSS_TYPE_AP_BSS;
5135	bool is_sta = wlvif->bss_type == BSS_TYPE_STA_BSS;
5136	int ret;
5137
5138	wl_sta = (struct wl1271_station *)sta->drv_priv;
5139
5140	/* Add station (AP mode) */
5141	if (is_ap &&
5142	    old_state == IEEE80211_STA_NOTEXIST &&
5143	    new_state == IEEE80211_STA_NONE) {
5144		ret = wl12xx_sta_add(wl, wlvif, sta);
5145		if (ret)
5146			return ret;
5147
5148		wlcore_update_inconn_sta(wl, wlvif, wl_sta, true);
5149	}
5150
5151	/* Remove station (AP mode) */
5152	if (is_ap &&
5153	    old_state == IEEE80211_STA_NONE &&
5154	    new_state == IEEE80211_STA_NOTEXIST) {
5155		/* must not fail */
5156		wl12xx_sta_remove(wl, wlvif, sta);
5157
5158		wlcore_update_inconn_sta(wl, wlvif, wl_sta, false);
5159	}
5160
5161	/* Authorize station (AP mode) */
5162	if (is_ap &&
5163	    new_state == IEEE80211_STA_AUTHORIZED) {
5164		ret = wl12xx_cmd_set_peer_state(wl, wlvif, wl_sta->hlid);
5165		if (ret < 0)
5166			return ret;
5167
5168		/* reconfigure rates */
5169		ret = wl12xx_cmd_add_peer(wl, wlvif, sta, wl_sta->hlid);
5170		if (ret < 0)
5171			return ret;
5172
5173		ret = wl1271_acx_set_ht_capabilities(wl, &sta->deflink.ht_cap,
5174						     true,
5175						     wl_sta->hlid);
5176		if (ret)
5177			return ret;
5178
5179		wlcore_update_inconn_sta(wl, wlvif, wl_sta, false);
5180	}
5181
5182	/* Authorize station */
5183	if (is_sta &&
5184	    new_state == IEEE80211_STA_AUTHORIZED) {
5185		set_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
5186		ret = wl12xx_set_authorized(wl, wlvif);
5187		if (ret)
5188			return ret;
5189	}
5190
5191	if (is_sta &&
5192	    old_state == IEEE80211_STA_AUTHORIZED &&
5193	    new_state == IEEE80211_STA_ASSOC) {
5194		clear_bit(WLVIF_FLAG_STA_AUTHORIZED, &wlvif->flags);
5195		clear_bit(WLVIF_FLAG_STA_STATE_SENT, &wlvif->flags);
5196	}
5197
5198	/* save seq number on disassoc (suspend) */
5199	if (is_sta &&
5200	    old_state == IEEE80211_STA_ASSOC &&
5201	    new_state == IEEE80211_STA_AUTH) {
5202		wlcore_save_freed_pkts(wl, wlvif, wlvif->sta.hlid, sta);
5203		wlvif->total_freed_pkts = 0;
5204	}
5205
5206	/* restore seq number on assoc (resume) */
5207	if (is_sta &&
5208	    old_state == IEEE80211_STA_AUTH &&
5209	    new_state == IEEE80211_STA_ASSOC) {
5210		wlvif->total_freed_pkts = wl_sta->total_freed_pkts;
5211	}
5212
5213	/* clear ROCs on failure or authorization */
5214	if (is_sta &&
5215	    (new_state == IEEE80211_STA_AUTHORIZED ||
5216	     new_state == IEEE80211_STA_NOTEXIST)) {
5217		if (test_bit(wlvif->role_id, wl->roc_map))
5218			wl12xx_croc(wl, wlvif->role_id);
5219	}
5220
5221	if (is_sta &&
5222	    old_state == IEEE80211_STA_NOTEXIST &&
5223	    new_state == IEEE80211_STA_NONE) {
5224		if (find_first_bit(wl->roc_map,
5225				   WL12XX_MAX_ROLES) >= WL12XX_MAX_ROLES) {
5226			WARN_ON(wlvif->role_id == WL12XX_INVALID_ROLE_ID);
5227			wl12xx_roc(wl, wlvif, wlvif->role_id,
5228				   wlvif->band, wlvif->channel);
5229		}
5230	}
5231	return 0;
5232}
5233
5234static int wl12xx_op_sta_state(struct ieee80211_hw *hw,
5235			       struct ieee80211_vif *vif,
5236			       struct ieee80211_sta *sta,
5237			       enum ieee80211_sta_state old_state,
5238			       enum ieee80211_sta_state new_state)
5239{
5240	struct wl1271 *wl = hw->priv;
5241	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5242	int ret;
5243
5244	wl1271_debug(DEBUG_MAC80211, "mac80211 sta %d state=%d->%d",
5245		     sta->aid, old_state, new_state);
5246
5247	mutex_lock(&wl->mutex);
5248
5249	if (unlikely(wl->state != WLCORE_STATE_ON)) {
5250		ret = -EBUSY;
5251		goto out;
5252	}
5253
5254	ret = pm_runtime_resume_and_get(wl->dev);
5255	if (ret < 0)
 
5256		goto out;
 
5257
5258	ret = wl12xx_update_sta_state(wl, wlvif, sta, old_state, new_state);
5259
5260	pm_runtime_mark_last_busy(wl->dev);
5261	pm_runtime_put_autosuspend(wl->dev);
5262out:
5263	mutex_unlock(&wl->mutex);
5264	if (new_state < old_state)
5265		return 0;
5266	return ret;
5267}
5268
5269static int wl1271_op_ampdu_action(struct ieee80211_hw *hw,
5270				  struct ieee80211_vif *vif,
5271				  struct ieee80211_ampdu_params *params)
5272{
5273	struct wl1271 *wl = hw->priv;
5274	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5275	int ret;
5276	u8 hlid, *ba_bitmap;
5277	struct ieee80211_sta *sta = params->sta;
5278	enum ieee80211_ampdu_mlme_action action = params->action;
5279	u16 tid = params->tid;
5280	u16 *ssn = &params->ssn;
5281
5282	wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu action %d tid %d", action,
5283		     tid);
5284
5285	/* sanity check - the fields in FW are only 8bits wide */
5286	if (WARN_ON(tid > 0xFF))
5287		return -ENOTSUPP;
5288
5289	mutex_lock(&wl->mutex);
5290
5291	if (unlikely(wl->state != WLCORE_STATE_ON)) {
5292		ret = -EAGAIN;
5293		goto out;
5294	}
5295
5296	if (wlvif->bss_type == BSS_TYPE_STA_BSS) {
5297		hlid = wlvif->sta.hlid;
5298	} else if (wlvif->bss_type == BSS_TYPE_AP_BSS) {
5299		struct wl1271_station *wl_sta;
5300
5301		wl_sta = (struct wl1271_station *)sta->drv_priv;
5302		hlid = wl_sta->hlid;
5303	} else {
5304		ret = -EINVAL;
5305		goto out;
5306	}
5307
5308	ba_bitmap = &wl->links[hlid].ba_bitmap;
5309
5310	ret = pm_runtime_resume_and_get(wl->dev);
5311	if (ret < 0)
 
5312		goto out;
 
5313
5314	wl1271_debug(DEBUG_MAC80211, "mac80211 ampdu: Rx tid %d action %d",
5315		     tid, action);
5316
5317	switch (action) {
5318	case IEEE80211_AMPDU_RX_START:
5319		if (!wlvif->ba_support || !wlvif->ba_allowed) {
5320			ret = -ENOTSUPP;
5321			break;
5322		}
5323
5324		if (wl->ba_rx_session_count >= wl->ba_rx_session_count_max) {
5325			ret = -EBUSY;
5326			wl1271_debug(DEBUG_RX, "exceeded max RX BA sessions");
5327			break;
5328		}
5329
5330		if (*ba_bitmap & BIT(tid)) {
5331			ret = -EINVAL;
5332			wl1271_error("cannot enable RX BA session on active "
5333				     "tid: %d", tid);
5334			break;
5335		}
5336
5337		ret = wl12xx_acx_set_ba_receiver_session(wl, tid, *ssn, true,
5338				hlid,
5339				params->buf_size);
5340
5341		if (!ret) {
5342			*ba_bitmap |= BIT(tid);
5343			wl->ba_rx_session_count++;
5344		}
5345		break;
5346
5347	case IEEE80211_AMPDU_RX_STOP:
5348		if (!(*ba_bitmap & BIT(tid))) {
5349			/*
5350			 * this happens on reconfig - so only output a debug
5351			 * message for now, and don't fail the function.
5352			 */
5353			wl1271_debug(DEBUG_MAC80211,
5354				     "no active RX BA session on tid: %d",
5355				     tid);
5356			ret = 0;
5357			break;
5358		}
5359
5360		ret = wl12xx_acx_set_ba_receiver_session(wl, tid, 0, false,
5361							 hlid, 0);
5362		if (!ret) {
5363			*ba_bitmap &= ~BIT(tid);
5364			wl->ba_rx_session_count--;
5365		}
5366		break;
5367
5368	/*
5369	 * The BA initiator session management in FW independently.
5370	 * Falling break here on purpose for all TX APDU commands.
5371	 */
5372	case IEEE80211_AMPDU_TX_START:
5373	case IEEE80211_AMPDU_TX_STOP_CONT:
5374	case IEEE80211_AMPDU_TX_STOP_FLUSH:
5375	case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
5376	case IEEE80211_AMPDU_TX_OPERATIONAL:
5377		ret = -EINVAL;
5378		break;
5379
5380	default:
5381		wl1271_error("Incorrect ampdu action id=%x\n", action);
5382		ret = -EINVAL;
5383	}
5384
5385	pm_runtime_mark_last_busy(wl->dev);
5386	pm_runtime_put_autosuspend(wl->dev);
5387
5388out:
5389	mutex_unlock(&wl->mutex);
5390
5391	return ret;
5392}
5393
5394static int wl12xx_set_bitrate_mask(struct ieee80211_hw *hw,
5395				   struct ieee80211_vif *vif,
5396				   const struct cfg80211_bitrate_mask *mask)
5397{
5398	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5399	struct wl1271 *wl = hw->priv;
5400	int i, ret = 0;
5401
5402	wl1271_debug(DEBUG_MAC80211, "mac80211 set_bitrate_mask 0x%x 0x%x",
5403		mask->control[NL80211_BAND_2GHZ].legacy,
5404		mask->control[NL80211_BAND_5GHZ].legacy);
5405
5406	mutex_lock(&wl->mutex);
5407
5408	for (i = 0; i < WLCORE_NUM_BANDS; i++)
5409		wlvif->bitrate_masks[i] =
5410			wl1271_tx_enabled_rates_get(wl,
5411						    mask->control[i].legacy,
5412						    i);
5413
5414	if (unlikely(wl->state != WLCORE_STATE_ON))
5415		goto out;
5416
5417	if (wlvif->bss_type == BSS_TYPE_STA_BSS &&
5418	    !test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
5419
5420		ret = pm_runtime_resume_and_get(wl->dev);
5421		if (ret < 0)
 
5422			goto out;
 
5423
5424		wl1271_set_band_rate(wl, wlvif);
5425		wlvif->basic_rate =
5426			wl1271_tx_min_rate_get(wl, wlvif->basic_rate_set);
5427		ret = wl1271_acx_sta_rate_policies(wl, wlvif);
5428
5429		pm_runtime_mark_last_busy(wl->dev);
5430		pm_runtime_put_autosuspend(wl->dev);
5431	}
5432out:
5433	mutex_unlock(&wl->mutex);
5434
5435	return ret;
5436}
5437
5438static void wl12xx_op_channel_switch(struct ieee80211_hw *hw,
5439				     struct ieee80211_vif *vif,
5440				     struct ieee80211_channel_switch *ch_switch)
5441{
5442	struct wl1271 *wl = hw->priv;
5443	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5444	int ret;
5445
5446	wl1271_debug(DEBUG_MAC80211, "mac80211 channel switch");
5447
5448	wl1271_tx_flush(wl);
5449
5450	mutex_lock(&wl->mutex);
5451
5452	if (unlikely(wl->state == WLCORE_STATE_OFF)) {
5453		if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags))
5454			ieee80211_chswitch_done(vif, false);
5455		goto out;
5456	} else if (unlikely(wl->state != WLCORE_STATE_ON)) {
5457		goto out;
5458	}
5459
5460	ret = pm_runtime_resume_and_get(wl->dev);
5461	if (ret < 0)
 
5462		goto out;
 
5463
5464	/* TODO: change mac80211 to pass vif as param */
5465
5466	if (test_bit(WLVIF_FLAG_STA_ASSOCIATED, &wlvif->flags)) {
5467		unsigned long delay_usec;
5468
5469		ret = wl->ops->channel_switch(wl, wlvif, ch_switch);
5470		if (ret)
5471			goto out_sleep;
5472
5473		set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags);
5474
5475		/* indicate failure 5 seconds after channel switch time */
5476		delay_usec = ieee80211_tu_to_usec(wlvif->beacon_int) *
5477			ch_switch->count;
5478		ieee80211_queue_delayed_work(hw, &wlvif->channel_switch_work,
5479					     usecs_to_jiffies(delay_usec) +
5480					     msecs_to_jiffies(5000));
5481	}
5482
5483out_sleep:
5484	pm_runtime_mark_last_busy(wl->dev);
5485	pm_runtime_put_autosuspend(wl->dev);
5486
5487out:
5488	mutex_unlock(&wl->mutex);
5489}
5490
5491static const void *wlcore_get_beacon_ie(struct wl1271 *wl,
5492					struct wl12xx_vif *wlvif,
5493					u8 eid)
5494{
5495	int ieoffset = offsetof(struct ieee80211_mgmt, u.beacon.variable);
5496	struct sk_buff *beacon =
5497		ieee80211_beacon_get(wl->hw, wl12xx_wlvif_to_vif(wlvif), 0);
5498
5499	if (!beacon)
5500		return NULL;
5501
5502	return cfg80211_find_ie(eid,
5503				beacon->data + ieoffset,
5504				beacon->len - ieoffset);
5505}
5506
5507static int wlcore_get_csa_count(struct wl1271 *wl, struct wl12xx_vif *wlvif,
5508				u8 *csa_count)
5509{
5510	const u8 *ie;
5511	const struct ieee80211_channel_sw_ie *ie_csa;
5512
5513	ie = wlcore_get_beacon_ie(wl, wlvif, WLAN_EID_CHANNEL_SWITCH);
5514	if (!ie)
5515		return -EINVAL;
5516
5517	ie_csa = (struct ieee80211_channel_sw_ie *)&ie[2];
5518	*csa_count = ie_csa->count;
5519
5520	return 0;
5521}
5522
5523static void wlcore_op_channel_switch_beacon(struct ieee80211_hw *hw,
5524					    struct ieee80211_vif *vif,
5525					    struct cfg80211_chan_def *chandef)
5526{
5527	struct wl1271 *wl = hw->priv;
5528	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5529	struct ieee80211_channel_switch ch_switch = {
5530		.block_tx = true,
5531		.chandef = *chandef,
5532	};
5533	int ret;
5534
5535	wl1271_debug(DEBUG_MAC80211,
5536		     "mac80211 channel switch beacon (role %d)",
5537		     wlvif->role_id);
5538
5539	ret = wlcore_get_csa_count(wl, wlvif, &ch_switch.count);
5540	if (ret < 0) {
5541		wl1271_error("error getting beacon (for CSA counter)");
5542		return;
5543	}
5544
5545	mutex_lock(&wl->mutex);
5546
5547	if (unlikely(wl->state != WLCORE_STATE_ON)) {
5548		ret = -EBUSY;
5549		goto out;
5550	}
5551
5552	ret = pm_runtime_resume_and_get(wl->dev);
5553	if (ret < 0)
 
5554		goto out;
 
5555
5556	ret = wl->ops->channel_switch(wl, wlvif, &ch_switch);
5557	if (ret)
5558		goto out_sleep;
5559
5560	set_bit(WLVIF_FLAG_CS_PROGRESS, &wlvif->flags);
5561
5562out_sleep:
5563	pm_runtime_mark_last_busy(wl->dev);
5564	pm_runtime_put_autosuspend(wl->dev);
5565out:
5566	mutex_unlock(&wl->mutex);
5567}
5568
5569static void wlcore_op_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
5570			    u32 queues, bool drop)
5571{
5572	struct wl1271 *wl = hw->priv;
5573
5574	wl1271_tx_flush(wl);
5575}
5576
5577static int wlcore_op_remain_on_channel(struct ieee80211_hw *hw,
5578				       struct ieee80211_vif *vif,
5579				       struct ieee80211_channel *chan,
5580				       int duration,
5581				       enum ieee80211_roc_type type)
5582{
5583	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5584	struct wl1271 *wl = hw->priv;
5585	int channel, active_roc, ret = 0;
5586
5587	channel = ieee80211_frequency_to_channel(chan->center_freq);
5588
5589	wl1271_debug(DEBUG_MAC80211, "mac80211 roc %d (%d)",
5590		     channel, wlvif->role_id);
5591
5592	mutex_lock(&wl->mutex);
5593
5594	if (unlikely(wl->state != WLCORE_STATE_ON))
5595		goto out;
5596
5597	/* return EBUSY if we can't ROC right now */
5598	active_roc = find_first_bit(wl->roc_map, WL12XX_MAX_ROLES);
5599	if (wl->roc_vif || active_roc < WL12XX_MAX_ROLES) {
5600		wl1271_warning("active roc on role %d", active_roc);
5601		ret = -EBUSY;
5602		goto out;
5603	}
5604
5605	ret = pm_runtime_resume_and_get(wl->dev);
5606	if (ret < 0)
 
5607		goto out;
 
5608
5609	ret = wl12xx_start_dev(wl, wlvif, chan->band, channel);
5610	if (ret < 0)
5611		goto out_sleep;
5612
5613	wl->roc_vif = vif;
5614	ieee80211_queue_delayed_work(hw, &wl->roc_complete_work,
5615				     msecs_to_jiffies(duration));
5616out_sleep:
5617	pm_runtime_mark_last_busy(wl->dev);
5618	pm_runtime_put_autosuspend(wl->dev);
5619out:
5620	mutex_unlock(&wl->mutex);
5621	return ret;
5622}
5623
5624static int __wlcore_roc_completed(struct wl1271 *wl)
5625{
5626	struct wl12xx_vif *wlvif;
5627	int ret;
5628
5629	/* already completed */
5630	if (unlikely(!wl->roc_vif))
5631		return 0;
5632
5633	wlvif = wl12xx_vif_to_data(wl->roc_vif);
5634
5635	if (!test_bit(WLVIF_FLAG_INITIALIZED, &wlvif->flags))
5636		return -EBUSY;
5637
5638	ret = wl12xx_stop_dev(wl, wlvif);
5639	if (ret < 0)
5640		return ret;
5641
5642	wl->roc_vif = NULL;
5643
5644	return 0;
5645}
5646
5647static int wlcore_roc_completed(struct wl1271 *wl)
5648{
5649	int ret;
5650
5651	wl1271_debug(DEBUG_MAC80211, "roc complete");
5652
5653	mutex_lock(&wl->mutex);
5654
5655	if (unlikely(wl->state != WLCORE_STATE_ON)) {
5656		ret = -EBUSY;
5657		goto out;
5658	}
5659
5660	ret = pm_runtime_resume_and_get(wl->dev);
5661	if (ret < 0)
 
5662		goto out;
 
5663
5664	ret = __wlcore_roc_completed(wl);
5665
5666	pm_runtime_mark_last_busy(wl->dev);
5667	pm_runtime_put_autosuspend(wl->dev);
5668out:
5669	mutex_unlock(&wl->mutex);
5670
5671	return ret;
5672}
5673
5674static void wlcore_roc_complete_work(struct work_struct *work)
5675{
5676	struct delayed_work *dwork;
5677	struct wl1271 *wl;
5678	int ret;
5679
5680	dwork = to_delayed_work(work);
5681	wl = container_of(dwork, struct wl1271, roc_complete_work);
5682
5683	ret = wlcore_roc_completed(wl);
5684	if (!ret)
5685		ieee80211_remain_on_channel_expired(wl->hw);
5686}
5687
5688static int wlcore_op_cancel_remain_on_channel(struct ieee80211_hw *hw,
5689					      struct ieee80211_vif *vif)
5690{
5691	struct wl1271 *wl = hw->priv;
5692
5693	wl1271_debug(DEBUG_MAC80211, "mac80211 croc");
5694
5695	/* TODO: per-vif */
5696	wl1271_tx_flush(wl);
5697
5698	/*
5699	 * we can't just flush_work here, because it might deadlock
5700	 * (as we might get called from the same workqueue)
5701	 */
5702	cancel_delayed_work_sync(&wl->roc_complete_work);
5703	wlcore_roc_completed(wl);
5704
5705	return 0;
5706}
5707
5708static void wlcore_op_sta_rc_update(struct ieee80211_hw *hw,
5709				    struct ieee80211_vif *vif,
5710				    struct ieee80211_sta *sta,
5711				    u32 changed)
5712{
5713	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5714
5715	wl1271_debug(DEBUG_MAC80211, "mac80211 sta_rc_update");
5716
5717	if (!(changed & IEEE80211_RC_BW_CHANGED))
5718		return;
5719
5720	/* this callback is atomic, so schedule a new work */
5721	wlvif->rc_update_bw = sta->deflink.bandwidth;
5722	memcpy(&wlvif->rc_ht_cap, &sta->deflink.ht_cap,
5723	       sizeof(sta->deflink.ht_cap));
5724	ieee80211_queue_work(hw, &wlvif->rc_update_work);
5725}
5726
5727static void wlcore_op_sta_statistics(struct ieee80211_hw *hw,
5728				     struct ieee80211_vif *vif,
5729				     struct ieee80211_sta *sta,
5730				     struct station_info *sinfo)
5731{
5732	struct wl1271 *wl = hw->priv;
5733	struct wl12xx_vif *wlvif = wl12xx_vif_to_data(vif);
5734	s8 rssi_dbm;
5735	int ret;
5736
5737	wl1271_debug(DEBUG_MAC80211, "mac80211 get_rssi");
5738
5739	mutex_lock(&wl->mutex);
5740
5741	if (unlikely(wl->state != WLCORE_STATE_ON))
5742		goto out;
5743
5744	ret = pm_runtime_resume_and_get(wl->dev);
5745	if (ret < 0)
 
5746		goto out_sleep;
 
5747
5748	ret = wlcore_acx_average_rssi(wl, wlvif, &rssi_dbm);
5749	if (ret < 0)
5750		goto out_sleep;
5751
5752	sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
5753	sinfo->signal = rssi_dbm;
5754
5755out_sleep:
5756	pm_runtime_mark_last_busy(wl->dev);
5757	pm_runtime_put_autosuspend(wl->dev);
5758
5759out:
5760	mutex_unlock(&wl->mutex);
5761}
5762
5763static u32 wlcore_op_get_expected_throughput(struct ieee80211_hw *hw,
5764					     struct ieee80211_sta *sta)
5765{
5766	struct wl1271_station *wl_sta = (struct wl1271_station *)sta->drv_priv;
5767	struct wl1271 *wl = hw->priv;
5768	u8 hlid = wl_sta->hlid;
5769
5770	/* return in units of Kbps */
5771	return (wl->links[hlid].fw_rate_mbps * 1000);
5772}
5773
5774static bool wl1271_tx_frames_pending(struct ieee80211_hw *hw)
5775{
5776	struct wl1271 *wl = hw->priv;
5777	bool ret = false;
5778
5779	mutex_lock(&wl->mutex);
5780
5781	if (unlikely(wl->state != WLCORE_STATE_ON))
5782		goto out;
5783
5784	/* packets are considered pending if in the TX queue or the FW */
5785	ret = (wl1271_tx_total_queue_count(wl) > 0) || (wl->tx_frames_cnt > 0);
5786out:
5787	mutex_unlock(&wl->mutex);
5788
5789	return ret;
5790}
5791
5792/* can't be const, mac80211 writes to this */
5793static struct ieee80211_rate wl1271_rates[] = {
5794	{ .bitrate = 10,
5795	  .hw_value = CONF_HW_BIT_RATE_1MBPS,
5796	  .hw_value_short = CONF_HW_BIT_RATE_1MBPS, },
5797	{ .bitrate = 20,
5798	  .hw_value = CONF_HW_BIT_RATE_2MBPS,
5799	  .hw_value_short = CONF_HW_BIT_RATE_2MBPS,
5800	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
5801	{ .bitrate = 55,
5802	  .hw_value = CONF_HW_BIT_RATE_5_5MBPS,
5803	  .hw_value_short = CONF_HW_BIT_RATE_5_5MBPS,
5804	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
5805	{ .bitrate = 110,
5806	  .hw_value = CONF_HW_BIT_RATE_11MBPS,
5807	  .hw_value_short = CONF_HW_BIT_RATE_11MBPS,
5808	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
5809	{ .bitrate = 60,
5810	  .hw_value = CONF_HW_BIT_RATE_6MBPS,
5811	  .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
5812	{ .bitrate = 90,
5813	  .hw_value = CONF_HW_BIT_RATE_9MBPS,
5814	  .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
5815	{ .bitrate = 120,
5816	  .hw_value = CONF_HW_BIT_RATE_12MBPS,
5817	  .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
5818	{ .bitrate = 180,
5819	  .hw_value = CONF_HW_BIT_RATE_18MBPS,
5820	  .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
5821	{ .bitrate = 240,
5822	  .hw_value = CONF_HW_BIT_RATE_24MBPS,
5823	  .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
5824	{ .bitrate = 360,
5825	 .hw_value = CONF_HW_BIT_RATE_36MBPS,
5826	 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
5827	{ .bitrate = 480,
5828	  .hw_value = CONF_HW_BIT_RATE_48MBPS,
5829	  .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
5830	{ .bitrate = 540,
5831	  .hw_value = CONF_HW_BIT_RATE_54MBPS,
5832	  .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
5833};
5834
5835/* can't be const, mac80211 writes to this */
5836static struct ieee80211_channel wl1271_channels[] = {
5837	{ .hw_value = 1, .center_freq = 2412, .max_power = WLCORE_MAX_TXPWR },
5838	{ .hw_value = 2, .center_freq = 2417, .max_power = WLCORE_MAX_TXPWR },
5839	{ .hw_value = 3, .center_freq = 2422, .max_power = WLCORE_MAX_TXPWR },
5840	{ .hw_value = 4, .center_freq = 2427, .max_power = WLCORE_MAX_TXPWR },
5841	{ .hw_value = 5, .center_freq = 2432, .max_power = WLCORE_MAX_TXPWR },
5842	{ .hw_value = 6, .center_freq = 2437, .max_power = WLCORE_MAX_TXPWR },
5843	{ .hw_value = 7, .center_freq = 2442, .max_power = WLCORE_MAX_TXPWR },
5844	{ .hw_value = 8, .center_freq = 2447, .max_power = WLCORE_MAX_TXPWR },
5845	{ .hw_value = 9, .center_freq = 2452, .max_power = WLCORE_MAX_TXPWR },
5846	{ .hw_value = 10, .center_freq = 2457, .max_power = WLCORE_MAX_TXPWR },
5847	{ .hw_value = 11, .center_freq = 2462, .max_power = WLCORE_MAX_TXPWR },
5848	{ .hw_value = 12, .center_freq = 2467, .max_power = WLCORE_MAX_TXPWR },
5849	{ .hw_value = 13, .center_freq = 2472, .max_power = WLCORE_MAX_TXPWR },
5850	{ .hw_value = 14, .center_freq = 2484, .max_power = WLCORE_MAX_TXPWR },
5851};
5852
5853/* can't be const, mac80211 writes to this */
5854static struct ieee80211_supported_band wl1271_band_2ghz = {
5855	.channels = wl1271_channels,
5856	.n_channels = ARRAY_SIZE(wl1271_channels),
5857	.bitrates = wl1271_rates,
5858	.n_bitrates = ARRAY_SIZE(wl1271_rates),
5859};
5860
5861/* 5 GHz data rates for WL1273 */
5862static struct ieee80211_rate wl1271_rates_5ghz[] = {
5863	{ .bitrate = 60,
5864	  .hw_value = CONF_HW_BIT_RATE_6MBPS,
5865	  .hw_value_short = CONF_HW_BIT_RATE_6MBPS, },
5866	{ .bitrate = 90,
5867	  .hw_value = CONF_HW_BIT_RATE_9MBPS,
5868	  .hw_value_short = CONF_HW_BIT_RATE_9MBPS, },
5869	{ .bitrate = 120,
5870	  .hw_value = CONF_HW_BIT_RATE_12MBPS,
5871	  .hw_value_short = CONF_HW_BIT_RATE_12MBPS, },
5872	{ .bitrate = 180,
5873	  .hw_value = CONF_HW_BIT_RATE_18MBPS,
5874	  .hw_value_short = CONF_HW_BIT_RATE_18MBPS, },
5875	{ .bitrate = 240,
5876	  .hw_value = CONF_HW_BIT_RATE_24MBPS,
5877	  .hw_value_short = CONF_HW_BIT_RATE_24MBPS, },
5878	{ .bitrate = 360,
5879	 .hw_value = CONF_HW_BIT_RATE_36MBPS,
5880	 .hw_value_short = CONF_HW_BIT_RATE_36MBPS, },
5881	{ .bitrate = 480,
5882	  .hw_value = CONF_HW_BIT_RATE_48MBPS,
5883	  .hw_value_short = CONF_HW_BIT_RATE_48MBPS, },
5884	{ .bitrate = 540,
5885	  .hw_value = CONF_HW_BIT_RATE_54MBPS,
5886	  .hw_value_short = CONF_HW_BIT_RATE_54MBPS, },
5887};
5888
5889/* 5 GHz band channels for WL1273 */
5890static struct ieee80211_channel wl1271_channels_5ghz[] = {
5891	{ .hw_value = 8, .center_freq = 5040, .max_power = WLCORE_MAX_TXPWR },
5892	{ .hw_value = 12, .center_freq = 5060, .max_power = WLCORE_MAX_TXPWR },
5893	{ .hw_value = 16, .center_freq = 5080, .max_power = WLCORE_MAX_TXPWR },
5894	{ .hw_value = 34, .center_freq = 5170, .max_power = WLCORE_MAX_TXPWR },
5895	{ .hw_value = 36, .center_freq = 5180, .max_power = WLCORE_MAX_TXPWR },
5896	{ .hw_value = 38, .center_freq = 5190, .max_power = WLCORE_MAX_TXPWR },
5897	{ .hw_value = 40, .center_freq = 5200, .max_power = WLCORE_MAX_TXPWR },
5898	{ .hw_value = 42, .center_freq = 5210, .max_power = WLCORE_MAX_TXPWR },
5899	{ .hw_value = 44, .center_freq = 5220, .max_power = WLCORE_MAX_TXPWR },
5900	{ .hw_value = 46, .center_freq = 5230, .max_power = WLCORE_MAX_TXPWR },
5901	{ .hw_value = 48, .center_freq = 5240, .max_power = WLCORE_MAX_TXPWR },
5902	{ .hw_value = 52, .center_freq = 5260, .max_power = WLCORE_MAX_TXPWR },
5903	{ .hw_value = 56, .center_freq = 5280, .max_power = WLCORE_MAX_TXPWR },
5904	{ .hw_value = 60, .center_freq = 5300, .max_power = WLCORE_MAX_TXPWR },
5905	{ .hw_value = 64, .center_freq = 5320, .max_power = WLCORE_MAX_TXPWR },
5906	{ .hw_value = 100, .center_freq = 5500, .max_power = WLCORE_MAX_TXPWR },
5907	{ .hw_value = 104, .center_freq = 5520, .max_power = WLCORE_MAX_TXPWR },
5908	{ .hw_value = 108, .center_freq = 5540, .max_power = WLCORE_MAX_TXPWR },
5909	{ .hw_value = 112, .center_freq = 5560, .max_power = WLCORE_MAX_TXPWR },
5910	{ .hw_value = 116, .center_freq = 5580, .max_power = WLCORE_MAX_TXPWR },
5911	{ .hw_value = 120, .center_freq = 5600, .max_power = WLCORE_MAX_TXPWR },
5912	{ .hw_value = 124, .center_freq = 5620, .max_power = WLCORE_MAX_TXPWR },
5913	{ .hw_value = 128, .center_freq = 5640, .max_power = WLCORE_MAX_TXPWR },
5914	{ .hw_value = 132, .center_freq = 5660, .max_power = WLCORE_MAX_TXPWR },
5915	{ .hw_value = 136, .center_freq = 5680, .max_power = WLCORE_MAX_TXPWR },
5916	{ .hw_value = 140, .center_freq = 5700, .max_power = WLCORE_MAX_TXPWR },
5917	{ .hw_value = 149, .center_freq = 5745, .max_power = WLCORE_MAX_TXPWR },
5918	{ .hw_value = 153, .center_freq = 5765, .max_power = WLCORE_MAX_TXPWR },
5919	{ .hw_value = 157, .center_freq = 5785, .max_power = WLCORE_MAX_TXPWR },
5920	{ .hw_value = 161, .center_freq = 5805, .max_power = WLCORE_MAX_TXPWR },
5921	{ .hw_value = 165, .center_freq = 5825, .max_power = WLCORE_MAX_TXPWR },
5922};
5923
5924static struct ieee80211_supported_band wl1271_band_5ghz = {
5925	.channels = wl1271_channels_5ghz,
5926	.n_channels = ARRAY_SIZE(wl1271_channels_5ghz),
5927	.bitrates = wl1271_rates_5ghz,
5928	.n_bitrates = ARRAY_SIZE(wl1271_rates_5ghz),
5929};
5930
5931static const struct ieee80211_ops wl1271_ops = {
5932	.start = wl1271_op_start,
5933	.stop = wlcore_op_stop,
5934	.add_interface = wl1271_op_add_interface,
5935	.remove_interface = wl1271_op_remove_interface,
5936	.change_interface = wl12xx_op_change_interface,
5937#ifdef CONFIG_PM
5938	.suspend = wl1271_op_suspend,
5939	.resume = wl1271_op_resume,
5940#endif
5941	.config = wl1271_op_config,
5942	.prepare_multicast = wl1271_op_prepare_multicast,
5943	.configure_filter = wl1271_op_configure_filter,
5944	.tx = wl1271_op_tx,
5945	.wake_tx_queue = ieee80211_handle_wake_tx_queue,
5946	.set_key = wlcore_op_set_key,
5947	.hw_scan = wl1271_op_hw_scan,
5948	.cancel_hw_scan = wl1271_op_cancel_hw_scan,
5949	.sched_scan_start = wl1271_op_sched_scan_start,
5950	.sched_scan_stop = wl1271_op_sched_scan_stop,
5951	.bss_info_changed = wl1271_op_bss_info_changed,
5952	.set_frag_threshold = wl1271_op_set_frag_threshold,
5953	.set_rts_threshold = wl1271_op_set_rts_threshold,
5954	.conf_tx = wl1271_op_conf_tx,
5955	.get_tsf = wl1271_op_get_tsf,
5956	.get_survey = wl1271_op_get_survey,
5957	.sta_state = wl12xx_op_sta_state,
5958	.ampdu_action = wl1271_op_ampdu_action,
5959	.tx_frames_pending = wl1271_tx_frames_pending,
5960	.set_bitrate_mask = wl12xx_set_bitrate_mask,
5961	.set_default_unicast_key = wl1271_op_set_default_key_idx,
5962	.channel_switch = wl12xx_op_channel_switch,
5963	.channel_switch_beacon = wlcore_op_channel_switch_beacon,
5964	.flush = wlcore_op_flush,
5965	.remain_on_channel = wlcore_op_remain_on_channel,
5966	.cancel_remain_on_channel = wlcore_op_cancel_remain_on_channel,
5967	.add_chanctx = wlcore_op_add_chanctx,
5968	.remove_chanctx = wlcore_op_remove_chanctx,
5969	.change_chanctx = wlcore_op_change_chanctx,
5970	.assign_vif_chanctx = wlcore_op_assign_vif_chanctx,
5971	.unassign_vif_chanctx = wlcore_op_unassign_vif_chanctx,
5972	.switch_vif_chanctx = wlcore_op_switch_vif_chanctx,
5973	.sta_rc_update = wlcore_op_sta_rc_update,
5974	.sta_statistics = wlcore_op_sta_statistics,
5975	.get_expected_throughput = wlcore_op_get_expected_throughput,
5976	CFG80211_TESTMODE_CMD(wl1271_tm_cmd)
5977};
5978
5979
5980u8 wlcore_rate_to_idx(struct wl1271 *wl, u8 rate, enum nl80211_band band)
5981{
5982	u8 idx;
5983
5984	BUG_ON(band >= 2);
5985
5986	if (unlikely(rate >= wl->hw_tx_rate_tbl_size)) {
5987		wl1271_error("Illegal RX rate from HW: %d", rate);
5988		return 0;
5989	}
5990
5991	idx = wl->band_rate_to_idx[band][rate];
5992	if (unlikely(idx == CONF_HW_RXTX_RATE_UNSUPPORTED)) {
5993		wl1271_error("Unsupported RX rate from HW: %d", rate);
5994		return 0;
5995	}
5996
5997	return idx;
5998}
5999
6000static void wl12xx_derive_mac_addresses(struct wl1271 *wl, u32 oui, u32 nic)
6001{
6002	int i;
6003
6004	wl1271_debug(DEBUG_PROBE, "base address: oui %06x nic %06x",
6005		     oui, nic);
6006
6007	if (nic + WLCORE_NUM_MAC_ADDRESSES - wl->num_mac_addr > 0xffffff)
6008		wl1271_warning("NIC part of the MAC address wraps around!");
6009
6010	for (i = 0; i < wl->num_mac_addr; i++) {
6011		wl->addresses[i].addr[0] = (u8)(oui >> 16);
6012		wl->addresses[i].addr[1] = (u8)(oui >> 8);
6013		wl->addresses[i].addr[2] = (u8) oui;
6014		wl->addresses[i].addr[3] = (u8)(nic >> 16);
6015		wl->addresses[i].addr[4] = (u8)(nic >> 8);
6016		wl->addresses[i].addr[5] = (u8) nic;
6017		nic++;
6018	}
6019
6020	/* we may be one address short at the most */
6021	WARN_ON(wl->num_mac_addr + 1 < WLCORE_NUM_MAC_ADDRESSES);
6022
6023	/*
6024	 * turn on the LAA bit in the first address and use it as
6025	 * the last address.
6026	 */
6027	if (wl->num_mac_addr < WLCORE_NUM_MAC_ADDRESSES) {
6028		int idx = WLCORE_NUM_MAC_ADDRESSES - 1;
6029		memcpy(&wl->addresses[idx], &wl->addresses[0],
6030		       sizeof(wl->addresses[0]));
6031		/* LAA bit */
6032		wl->addresses[idx].addr[0] |= BIT(1);
6033	}
6034
6035	wl->hw->wiphy->n_addresses = WLCORE_NUM_MAC_ADDRESSES;
6036	wl->hw->wiphy->addresses = wl->addresses;
6037}
6038
6039static int wl12xx_get_hw_info(struct wl1271 *wl)
6040{
6041	int ret;
6042
6043	ret = wlcore_read_reg(wl, REG_CHIP_ID_B, &wl->chip.id);
6044	if (ret < 0)
6045		goto out;
6046
6047	wl->fuse_oui_addr = 0;
6048	wl->fuse_nic_addr = 0;
6049
6050	ret = wl->ops->get_pg_ver(wl, &wl->hw_pg_ver);
6051	if (ret < 0)
6052		goto out;
6053
6054	if (wl->ops->get_mac)
6055		ret = wl->ops->get_mac(wl);
6056
6057out:
6058	return ret;
6059}
6060
6061static int wl1271_register_hw(struct wl1271 *wl)
6062{
6063	int ret;
6064	u32 oui_addr = 0, nic_addr = 0;
6065	struct platform_device *pdev = wl->pdev;
6066	struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev);
6067
6068	if (wl->mac80211_registered)
6069		return 0;
6070
6071	if (wl->nvs_len >= 12) {
6072		/* NOTE: The wl->nvs->nvs element must be first, in
6073		 * order to simplify the casting, we assume it is at
6074		 * the beginning of the wl->nvs structure.
6075		 */
6076		u8 *nvs_ptr = (u8 *)wl->nvs;
6077
6078		oui_addr =
6079			(nvs_ptr[11] << 16) + (nvs_ptr[10] << 8) + nvs_ptr[6];
6080		nic_addr =
6081			(nvs_ptr[5] << 16) + (nvs_ptr[4] << 8) + nvs_ptr[3];
6082	}
6083
6084	/* if the MAC address is zeroed in the NVS derive from fuse */
6085	if (oui_addr == 0 && nic_addr == 0) {
6086		oui_addr = wl->fuse_oui_addr;
6087		/* fuse has the BD_ADDR, the WLAN addresses are the next two */
6088		nic_addr = wl->fuse_nic_addr + 1;
6089	}
6090
6091	if (oui_addr == 0xdeadbe && nic_addr == 0xef0000) {
6092		wl1271_warning("Detected unconfigured mac address in nvs, derive from fuse instead.");
6093		if (!strcmp(pdev_data->family->name, "wl18xx")) {
6094			wl1271_warning("This default nvs file can be removed from the file system");
6095		} else {
6096			wl1271_warning("Your device performance is not optimized.");
6097			wl1271_warning("Please use the calibrator tool to configure your device.");
6098		}
6099
6100		if (wl->fuse_oui_addr == 0 && wl->fuse_nic_addr == 0) {
6101			wl1271_warning("Fuse mac address is zero. using random mac");
6102			/* Use TI oui and a random nic */
6103			oui_addr = WLCORE_TI_OUI_ADDRESS;
6104			nic_addr = get_random_u32();
6105		} else {
6106			oui_addr = wl->fuse_oui_addr;
6107			/* fuse has the BD_ADDR, the WLAN addresses are the next two */
6108			nic_addr = wl->fuse_nic_addr + 1;
6109		}
6110	}
6111
6112	wl12xx_derive_mac_addresses(wl, oui_addr, nic_addr);
6113
6114	ret = ieee80211_register_hw(wl->hw);
6115	if (ret < 0) {
6116		wl1271_error("unable to register mac80211 hw: %d", ret);
6117		goto out;
6118	}
6119
6120	wl->mac80211_registered = true;
6121
6122	wl1271_debugfs_init(wl);
6123
6124	wl1271_notice("loaded");
6125
6126out:
6127	return ret;
6128}
6129
6130static void wl1271_unregister_hw(struct wl1271 *wl)
6131{
6132	if (wl->plt)
6133		wl1271_plt_stop(wl);
6134
6135	ieee80211_unregister_hw(wl->hw);
6136	wl->mac80211_registered = false;
6137
6138}
6139
6140static int wl1271_init_ieee80211(struct wl1271 *wl)
6141{
6142	int i;
6143	static const u32 cipher_suites[] = {
6144		WLAN_CIPHER_SUITE_WEP40,
6145		WLAN_CIPHER_SUITE_WEP104,
6146		WLAN_CIPHER_SUITE_TKIP,
6147		WLAN_CIPHER_SUITE_CCMP,
6148		WL1271_CIPHER_SUITE_GEM,
6149	};
6150
6151	/* The tx descriptor buffer */
6152	wl->hw->extra_tx_headroom = sizeof(struct wl1271_tx_hw_descr);
6153
6154	if (wl->quirks & WLCORE_QUIRK_TKIP_HEADER_SPACE)
6155		wl->hw->extra_tx_headroom += WL1271_EXTRA_SPACE_TKIP;
6156
6157	/* unit us */
6158	/* FIXME: find a proper value */
6159	wl->hw->max_listen_interval = wl->conf.conn.max_listen_interval;
6160
6161	ieee80211_hw_set(wl->hw, SUPPORT_FAST_XMIT);
6162	ieee80211_hw_set(wl->hw, CHANCTX_STA_CSA);
6163	ieee80211_hw_set(wl->hw, SUPPORTS_PER_STA_GTK);
6164	ieee80211_hw_set(wl->hw, QUEUE_CONTROL);
6165	ieee80211_hw_set(wl->hw, TX_AMPDU_SETUP_IN_HW);
6166	ieee80211_hw_set(wl->hw, AMPDU_AGGREGATION);
6167	ieee80211_hw_set(wl->hw, AP_LINK_PS);
6168	ieee80211_hw_set(wl->hw, SPECTRUM_MGMT);
6169	ieee80211_hw_set(wl->hw, REPORTS_TX_ACK_STATUS);
6170	ieee80211_hw_set(wl->hw, CONNECTION_MONITOR);
6171	ieee80211_hw_set(wl->hw, HAS_RATE_CONTROL);
6172	ieee80211_hw_set(wl->hw, SUPPORTS_DYNAMIC_PS);
6173	ieee80211_hw_set(wl->hw, SIGNAL_DBM);
6174	ieee80211_hw_set(wl->hw, SUPPORTS_PS);
6175	ieee80211_hw_set(wl->hw, SUPPORTS_TX_FRAG);
6176
6177	wl->hw->wiphy->cipher_suites = cipher_suites;
6178	wl->hw->wiphy->n_cipher_suites = ARRAY_SIZE(cipher_suites);
6179
6180	wl->hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) |
6181					 BIT(NL80211_IFTYPE_AP) |
6182					 BIT(NL80211_IFTYPE_P2P_DEVICE) |
6183					 BIT(NL80211_IFTYPE_P2P_CLIENT) |
6184#ifdef CONFIG_MAC80211_MESH
6185					 BIT(NL80211_IFTYPE_MESH_POINT) |
6186#endif
6187					 BIT(NL80211_IFTYPE_P2P_GO);
6188
6189	wl->hw->wiphy->max_scan_ssids = 1;
6190	wl->hw->wiphy->max_sched_scan_ssids = 16;
6191	wl->hw->wiphy->max_match_sets = 16;
6192	/*
6193	 * Maximum length of elements in scanning probe request templates
6194	 * should be the maximum length possible for a template, without
6195	 * the IEEE80211 header of the template
6196	 */
6197	wl->hw->wiphy->max_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
6198			sizeof(struct ieee80211_header);
6199
6200	wl->hw->wiphy->max_sched_scan_reqs = 1;
6201	wl->hw->wiphy->max_sched_scan_ie_len = WL1271_CMD_TEMPL_MAX_SIZE -
6202		sizeof(struct ieee80211_header);
6203
6204	wl->hw->wiphy->max_remain_on_channel_duration = 30000;
6205
6206	wl->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD |
6207				WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL |
6208				WIPHY_FLAG_HAS_CHANNEL_SWITCH |
6209				WIPHY_FLAG_IBSS_RSN;
6210
6211	wl->hw->wiphy->features |= NL80211_FEATURE_AP_SCAN;
6212
6213	/* make sure all our channels fit in the scanned_ch bitmask */
6214	BUILD_BUG_ON(ARRAY_SIZE(wl1271_channels) +
6215		     ARRAY_SIZE(wl1271_channels_5ghz) >
6216		     WL1271_MAX_CHANNELS);
6217	/*
6218	* clear channel flags from the previous usage
6219	* and restore max_power & max_antenna_gain values.
6220	*/
6221	for (i = 0; i < ARRAY_SIZE(wl1271_channels); i++) {
6222		wl1271_band_2ghz.channels[i].flags = 0;
6223		wl1271_band_2ghz.channels[i].max_power = WLCORE_MAX_TXPWR;
6224		wl1271_band_2ghz.channels[i].max_antenna_gain = 0;
6225	}
6226
6227	for (i = 0; i < ARRAY_SIZE(wl1271_channels_5ghz); i++) {
6228		wl1271_band_5ghz.channels[i].flags = 0;
6229		wl1271_band_5ghz.channels[i].max_power = WLCORE_MAX_TXPWR;
6230		wl1271_band_5ghz.channels[i].max_antenna_gain = 0;
6231	}
6232
6233	/*
6234	 * We keep local copies of the band structs because we need to
6235	 * modify them on a per-device basis.
6236	 */
6237	memcpy(&wl->bands[NL80211_BAND_2GHZ], &wl1271_band_2ghz,
6238	       sizeof(wl1271_band_2ghz));
6239	memcpy(&wl->bands[NL80211_BAND_2GHZ].ht_cap,
6240	       &wl->ht_cap[NL80211_BAND_2GHZ],
6241	       sizeof(*wl->ht_cap));
6242	memcpy(&wl->bands[NL80211_BAND_5GHZ], &wl1271_band_5ghz,
6243	       sizeof(wl1271_band_5ghz));
6244	memcpy(&wl->bands[NL80211_BAND_5GHZ].ht_cap,
6245	       &wl->ht_cap[NL80211_BAND_5GHZ],
6246	       sizeof(*wl->ht_cap));
6247
6248	wl->hw->wiphy->bands[NL80211_BAND_2GHZ] =
6249		&wl->bands[NL80211_BAND_2GHZ];
6250	wl->hw->wiphy->bands[NL80211_BAND_5GHZ] =
6251		&wl->bands[NL80211_BAND_5GHZ];
6252
6253	/*
6254	 * allow 4 queues per mac address we support +
6255	 * 1 cab queue per mac + one global offchannel Tx queue
6256	 */
6257	wl->hw->queues = (NUM_TX_QUEUES + 1) * WLCORE_NUM_MAC_ADDRESSES + 1;
6258
6259	/* the last queue is the offchannel queue */
6260	wl->hw->offchannel_tx_hw_queue = wl->hw->queues - 1;
6261	wl->hw->max_rates = 1;
6262
6263	wl->hw->wiphy->reg_notifier = wl1271_reg_notify;
6264
6265	/* the FW answers probe-requests in AP-mode */
6266	wl->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
6267	wl->hw->wiphy->probe_resp_offload =
6268		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
6269		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
6270		NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
6271
6272	/* allowed interface combinations */
6273	wl->hw->wiphy->iface_combinations = wl->iface_combinations;
6274	wl->hw->wiphy->n_iface_combinations = wl->n_iface_combinations;
6275
6276	/* register vendor commands */
6277	wlcore_set_vendor_commands(wl->hw->wiphy);
6278
6279	SET_IEEE80211_DEV(wl->hw, wl->dev);
6280
6281	wl->hw->sta_data_size = sizeof(struct wl1271_station);
6282	wl->hw->vif_data_size = sizeof(struct wl12xx_vif);
6283
6284	wl->hw->max_rx_aggregation_subframes = wl->conf.ht.rx_ba_win_size;
6285
6286	return 0;
6287}
6288
6289struct ieee80211_hw *wlcore_alloc_hw(size_t priv_size, u32 aggr_buf_size,
6290				     u32 mbox_size)
6291{
6292	struct ieee80211_hw *hw;
6293	struct wl1271 *wl;
6294	int i, j, ret;
6295	unsigned int order;
6296
6297	hw = ieee80211_alloc_hw(sizeof(*wl), &wl1271_ops);
6298	if (!hw) {
6299		wl1271_error("could not alloc ieee80211_hw");
6300		ret = -ENOMEM;
6301		goto err_hw_alloc;
6302	}
6303
6304	wl = hw->priv;
6305	memset(wl, 0, sizeof(*wl));
6306
6307	wl->priv = kzalloc(priv_size, GFP_KERNEL);
6308	if (!wl->priv) {
6309		wl1271_error("could not alloc wl priv");
6310		ret = -ENOMEM;
6311		goto err_priv_alloc;
6312	}
6313
6314	INIT_LIST_HEAD(&wl->wlvif_list);
6315
6316	wl->hw = hw;
6317
6318	/*
6319	 * wl->num_links is not configured yet, so just use WLCORE_MAX_LINKS.
6320	 * we don't allocate any additional resource here, so that's fine.
6321	 */
6322	for (i = 0; i < NUM_TX_QUEUES; i++)
6323		for (j = 0; j < WLCORE_MAX_LINKS; j++)
6324			skb_queue_head_init(&wl->links[j].tx_queue[i]);
6325
6326	skb_queue_head_init(&wl->deferred_rx_queue);
6327	skb_queue_head_init(&wl->deferred_tx_queue);
6328
6329	INIT_WORK(&wl->netstack_work, wl1271_netstack_work);
6330	INIT_WORK(&wl->tx_work, wl1271_tx_work);
6331	INIT_WORK(&wl->recovery_work, wl1271_recovery_work);
6332	INIT_DELAYED_WORK(&wl->scan_complete_work, wl1271_scan_complete_work);
6333	INIT_DELAYED_WORK(&wl->roc_complete_work, wlcore_roc_complete_work);
6334	INIT_DELAYED_WORK(&wl->tx_watchdog_work, wl12xx_tx_watchdog_work);
6335
6336	wl->freezable_wq = create_freezable_workqueue("wl12xx_wq");
6337	if (!wl->freezable_wq) {
6338		ret = -ENOMEM;
6339		goto err_hw;
6340	}
6341
6342	wl->channel = 0;
6343	wl->rx_counter = 0;
6344	wl->power_level = WL1271_DEFAULT_POWER_LEVEL;
6345	wl->band = NL80211_BAND_2GHZ;
6346	wl->channel_type = NL80211_CHAN_NO_HT;
6347	wl->flags = 0;
6348	wl->sg_enabled = true;
6349	wl->sleep_auth = WL1271_PSM_ILLEGAL;
6350	wl->recovery_count = 0;
6351	wl->hw_pg_ver = -1;
6352	wl->ap_ps_map = 0;
6353	wl->ap_fw_ps_map = 0;
6354	wl->quirks = 0;
6355	wl->system_hlid = WL12XX_SYSTEM_HLID;
6356	wl->active_sta_count = 0;
6357	wl->active_link_count = 0;
6358	wl->fwlog_size = 0;
6359
6360	/* The system link is always allocated */
6361	__set_bit(WL12XX_SYSTEM_HLID, wl->links_map);
6362
6363	memset(wl->tx_frames_map, 0, sizeof(wl->tx_frames_map));
6364	for (i = 0; i < wl->num_tx_desc; i++)
6365		wl->tx_frames[i] = NULL;
6366
6367	spin_lock_init(&wl->wl_lock);
6368
6369	wl->state = WLCORE_STATE_OFF;
6370	wl->fw_type = WL12XX_FW_TYPE_NONE;
6371	mutex_init(&wl->mutex);
6372	mutex_init(&wl->flush_mutex);
6373	init_completion(&wl->nvs_loading_complete);
6374
6375	order = get_order(aggr_buf_size);
6376	wl->aggr_buf = (u8 *)__get_free_pages(GFP_KERNEL, order);
6377	if (!wl->aggr_buf) {
6378		ret = -ENOMEM;
6379		goto err_wq;
6380	}
6381	wl->aggr_buf_size = aggr_buf_size;
6382
6383	wl->dummy_packet = wl12xx_alloc_dummy_packet(wl);
6384	if (!wl->dummy_packet) {
6385		ret = -ENOMEM;
6386		goto err_aggr;
6387	}
6388
6389	/* Allocate one page for the FW log */
6390	wl->fwlog = (u8 *)get_zeroed_page(GFP_KERNEL);
6391	if (!wl->fwlog) {
6392		ret = -ENOMEM;
6393		goto err_dummy_packet;
6394	}
6395
6396	wl->mbox_size = mbox_size;
6397	wl->mbox = kmalloc(wl->mbox_size, GFP_KERNEL | GFP_DMA);
6398	if (!wl->mbox) {
6399		ret = -ENOMEM;
6400		goto err_fwlog;
6401	}
6402
6403	wl->buffer_32 = kmalloc(sizeof(*wl->buffer_32), GFP_KERNEL);
6404	if (!wl->buffer_32) {
6405		ret = -ENOMEM;
6406		goto err_mbox;
6407	}
6408
6409	return hw;
6410
6411err_mbox:
6412	kfree(wl->mbox);
6413
6414err_fwlog:
6415	free_page((unsigned long)wl->fwlog);
6416
6417err_dummy_packet:
6418	dev_kfree_skb(wl->dummy_packet);
6419
6420err_aggr:
6421	free_pages((unsigned long)wl->aggr_buf, order);
6422
6423err_wq:
6424	destroy_workqueue(wl->freezable_wq);
6425
6426err_hw:
6427	wl1271_debugfs_exit(wl);
6428	kfree(wl->priv);
6429
6430err_priv_alloc:
6431	ieee80211_free_hw(hw);
6432
6433err_hw_alloc:
6434
6435	return ERR_PTR(ret);
6436}
6437EXPORT_SYMBOL_GPL(wlcore_alloc_hw);
6438
6439int wlcore_free_hw(struct wl1271 *wl)
6440{
6441	/* Unblock any fwlog readers */
6442	mutex_lock(&wl->mutex);
6443	wl->fwlog_size = -1;
6444	mutex_unlock(&wl->mutex);
6445
6446	wlcore_sysfs_free(wl);
6447
6448	kfree(wl->buffer_32);
6449	kfree(wl->mbox);
6450	free_page((unsigned long)wl->fwlog);
6451	dev_kfree_skb(wl->dummy_packet);
6452	free_pages((unsigned long)wl->aggr_buf, get_order(wl->aggr_buf_size));
6453
6454	wl1271_debugfs_exit(wl);
6455
6456	vfree(wl->fw);
6457	wl->fw = NULL;
6458	wl->fw_type = WL12XX_FW_TYPE_NONE;
6459	kfree(wl->nvs);
6460	wl->nvs = NULL;
6461
6462	kfree(wl->raw_fw_status);
6463	kfree(wl->fw_status);
6464	kfree(wl->tx_res_if);
6465	destroy_workqueue(wl->freezable_wq);
6466
6467	kfree(wl->priv);
6468	ieee80211_free_hw(wl->hw);
6469
6470	return 0;
6471}
6472EXPORT_SYMBOL_GPL(wlcore_free_hw);
6473
6474#ifdef CONFIG_PM
6475static const struct wiphy_wowlan_support wlcore_wowlan_support = {
6476	.flags = WIPHY_WOWLAN_ANY,
6477	.n_patterns = WL1271_MAX_RX_FILTERS,
6478	.pattern_min_len = 1,
6479	.pattern_max_len = WL1271_RX_FILTER_MAX_PATTERN_SIZE,
6480};
6481#endif
6482
6483static irqreturn_t wlcore_hardirq(int irq, void *cookie)
6484{
6485	return IRQ_WAKE_THREAD;
6486}
6487
6488static void wlcore_nvs_cb(const struct firmware *fw, void *context)
6489{
6490	struct wl1271 *wl = context;
6491	struct platform_device *pdev = wl->pdev;
6492	struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev);
6493	struct resource *res;
6494
6495	int ret;
6496	irq_handler_t hardirq_fn = NULL;
6497
6498	if (fw) {
6499		wl->nvs = kmemdup(fw->data, fw->size, GFP_KERNEL);
6500		if (!wl->nvs) {
6501			wl1271_error("Could not allocate nvs data");
6502			goto out;
6503		}
6504		wl->nvs_len = fw->size;
6505	} else if (pdev_data->family->nvs_name) {
6506		wl1271_debug(DEBUG_BOOT, "Could not get nvs file %s",
6507			     pdev_data->family->nvs_name);
6508		wl->nvs = NULL;
6509		wl->nvs_len = 0;
6510	} else {
6511		wl->nvs = NULL;
6512		wl->nvs_len = 0;
6513	}
6514
6515	ret = wl->ops->setup(wl);
6516	if (ret < 0)
6517		goto out_free_nvs;
6518
6519	BUG_ON(wl->num_tx_desc > WLCORE_MAX_TX_DESCRIPTORS);
6520
6521	/* adjust some runtime configuration parameters */
6522	wlcore_adjust_conf(wl);
6523
6524	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
6525	if (!res) {
6526		wl1271_error("Could not get IRQ resource");
6527		goto out_free_nvs;
6528	}
6529
6530	wl->irq = res->start;
6531	wl->irq_flags = res->flags & IRQF_TRIGGER_MASK;
6532	wl->if_ops = pdev_data->if_ops;
6533
6534	if (wl->irq_flags & (IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING))
6535		hardirq_fn = wlcore_hardirq;
6536	else
6537		wl->irq_flags |= IRQF_ONESHOT;
6538
6539	ret = wl12xx_set_power_on(wl);
6540	if (ret < 0)
6541		goto out_free_nvs;
6542
6543	ret = wl12xx_get_hw_info(wl);
6544	if (ret < 0) {
6545		wl1271_error("couldn't get hw info");
6546		wl1271_power_off(wl);
6547		goto out_free_nvs;
6548	}
6549
6550	ret = request_threaded_irq(wl->irq, hardirq_fn, wlcore_irq,
6551				   wl->irq_flags, pdev->name, wl);
6552	if (ret < 0) {
6553		wl1271_error("interrupt configuration failed");
6554		wl1271_power_off(wl);
6555		goto out_free_nvs;
6556	}
6557
6558#ifdef CONFIG_PM
6559	device_init_wakeup(wl->dev, true);
6560
6561	ret = enable_irq_wake(wl->irq);
6562	if (!ret) {
6563		wl->irq_wake_enabled = true;
6564		if (pdev_data->pwr_in_suspend)
6565			wl->hw->wiphy->wowlan = &wlcore_wowlan_support;
6566	}
6567
6568	res = platform_get_resource(pdev, IORESOURCE_IRQ, 1);
6569	if (res) {
6570		wl->wakeirq = res->start;
6571		wl->wakeirq_flags = res->flags & IRQF_TRIGGER_MASK;
6572		ret = dev_pm_set_dedicated_wake_irq(wl->dev, wl->wakeirq);
6573		if (ret)
6574			wl->wakeirq = -ENODEV;
6575	} else {
6576		wl->wakeirq = -ENODEV;
6577	}
6578#endif
6579	disable_irq(wl->irq);
6580	wl1271_power_off(wl);
6581
6582	ret = wl->ops->identify_chip(wl);
6583	if (ret < 0)
6584		goto out_irq;
6585
6586	ret = wl1271_init_ieee80211(wl);
6587	if (ret)
6588		goto out_irq;
6589
6590	ret = wl1271_register_hw(wl);
6591	if (ret)
6592		goto out_irq;
6593
6594	ret = wlcore_sysfs_init(wl);
6595	if (ret)
6596		goto out_unreg;
6597
6598	wl->initialized = true;
6599	goto out;
6600
6601out_unreg:
6602	wl1271_unregister_hw(wl);
6603
6604out_irq:
6605	if (wl->wakeirq >= 0)
6606		dev_pm_clear_wake_irq(wl->dev);
6607	device_init_wakeup(wl->dev, false);
6608	free_irq(wl->irq, wl);
6609
6610out_free_nvs:
6611	kfree(wl->nvs);
6612
6613out:
6614	release_firmware(fw);
6615	complete_all(&wl->nvs_loading_complete);
6616}
6617
6618static int __maybe_unused wlcore_runtime_suspend(struct device *dev)
6619{
6620	struct wl1271 *wl = dev_get_drvdata(dev);
6621	struct wl12xx_vif *wlvif;
6622	int error;
6623
6624	/* We do not enter elp sleep in PLT mode */
6625	if (wl->plt)
6626		return 0;
6627
6628	/* Nothing to do if no ELP mode requested */
6629	if (wl->sleep_auth != WL1271_PSM_ELP)
6630		return 0;
6631
6632	wl12xx_for_each_wlvif(wl, wlvif) {
6633		if (!test_bit(WLVIF_FLAG_IN_PS, &wlvif->flags) &&
6634		    test_bit(WLVIF_FLAG_IN_USE, &wlvif->flags))
6635			return -EBUSY;
6636	}
6637
6638	wl1271_debug(DEBUG_PSM, "chip to elp");
6639	error = wlcore_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG, ELPCTRL_SLEEP);
6640	if (error < 0) {
6641		wl12xx_queue_recovery_work(wl);
6642
6643		return error;
6644	}
6645
6646	set_bit(WL1271_FLAG_IN_ELP, &wl->flags);
6647
6648	return 0;
6649}
6650
6651static int __maybe_unused wlcore_runtime_resume(struct device *dev)
6652{
6653	struct wl1271 *wl = dev_get_drvdata(dev);
6654	DECLARE_COMPLETION_ONSTACK(compl);
6655	unsigned long flags;
6656	int ret;
6657	unsigned long start_time = jiffies;
6658	bool recovery = false;
6659
6660	/* Nothing to do if no ELP mode requested */
6661	if (!test_bit(WL1271_FLAG_IN_ELP, &wl->flags))
6662		return 0;
6663
6664	wl1271_debug(DEBUG_PSM, "waking up chip from elp");
6665
6666	spin_lock_irqsave(&wl->wl_lock, flags);
6667	wl->elp_compl = &compl;
6668	spin_unlock_irqrestore(&wl->wl_lock, flags);
6669
6670	ret = wlcore_raw_write32(wl, HW_ACCESS_ELP_CTRL_REG, ELPCTRL_WAKE_UP);
6671	if (ret < 0) {
6672		recovery = true;
6673	} else if (!test_bit(WL1271_FLAG_IRQ_RUNNING, &wl->flags)) {
6674		ret = wait_for_completion_timeout(&compl,
6675			msecs_to_jiffies(WL1271_WAKEUP_TIMEOUT));
6676		if (ret == 0) {
6677			wl1271_warning("ELP wakeup timeout!");
6678			recovery = true;
6679		}
6680	}
6681
6682	spin_lock_irqsave(&wl->wl_lock, flags);
6683	wl->elp_compl = NULL;
6684	spin_unlock_irqrestore(&wl->wl_lock, flags);
6685	clear_bit(WL1271_FLAG_IN_ELP, &wl->flags);
6686
6687	if (recovery) {
6688		set_bit(WL1271_FLAG_INTENDED_FW_RECOVERY, &wl->flags);
6689		wl12xx_queue_recovery_work(wl);
6690	} else {
6691		wl1271_debug(DEBUG_PSM, "wakeup time: %u ms",
6692			     jiffies_to_msecs(jiffies - start_time));
6693	}
6694
6695	return 0;
6696}
6697
6698static const struct dev_pm_ops wlcore_pm_ops = {
6699	SET_RUNTIME_PM_OPS(wlcore_runtime_suspend,
6700			   wlcore_runtime_resume,
6701			   NULL)
6702};
6703
6704int wlcore_probe(struct wl1271 *wl, struct platform_device *pdev)
6705{
6706	struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev);
6707	const char *nvs_name;
6708	int ret = 0;
6709
6710	if (!wl->ops || !wl->ptable || !pdev_data)
6711		return -EINVAL;
6712
6713	wl->dev = &pdev->dev;
6714	wl->pdev = pdev;
6715	platform_set_drvdata(pdev, wl);
6716
6717	if (pdev_data->family && pdev_data->family->nvs_name) {
6718		nvs_name = pdev_data->family->nvs_name;
6719		ret = request_firmware_nowait(THIS_MODULE, FW_ACTION_UEVENT,
6720					      nvs_name, &pdev->dev, GFP_KERNEL,
6721					      wl, wlcore_nvs_cb);
6722		if (ret < 0) {
6723			wl1271_error("request_firmware_nowait failed for %s: %d",
6724				     nvs_name, ret);
6725			complete_all(&wl->nvs_loading_complete);
6726		}
6727	} else {
6728		wlcore_nvs_cb(NULL, wl);
6729	}
6730
6731	wl->dev->driver->pm = &wlcore_pm_ops;
6732	pm_runtime_set_autosuspend_delay(wl->dev, 50);
6733	pm_runtime_use_autosuspend(wl->dev);
6734	pm_runtime_enable(wl->dev);
6735
6736	return ret;
6737}
6738EXPORT_SYMBOL_GPL(wlcore_probe);
6739
6740int wlcore_remove(struct platform_device *pdev)
6741{
6742	struct wlcore_platdev_data *pdev_data = dev_get_platdata(&pdev->dev);
6743	struct wl1271 *wl = platform_get_drvdata(pdev);
6744	int error;
6745
6746	error = pm_runtime_get_sync(wl->dev);
6747	if (error < 0)
6748		dev_warn(wl->dev, "PM runtime failed: %i\n", error);
6749
6750	wl->dev->driver->pm = NULL;
6751
6752	if (pdev_data->family && pdev_data->family->nvs_name)
6753		wait_for_completion(&wl->nvs_loading_complete);
6754	if (!wl->initialized)
6755		return 0;
6756
6757	if (wl->wakeirq >= 0) {
6758		dev_pm_clear_wake_irq(wl->dev);
6759		wl->wakeirq = -ENODEV;
6760	}
6761
6762	device_init_wakeup(wl->dev, false);
6763
6764	if (wl->irq_wake_enabled)
6765		disable_irq_wake(wl->irq);
6766
6767	wl1271_unregister_hw(wl);
6768
6769	pm_runtime_put_sync(wl->dev);
6770	pm_runtime_dont_use_autosuspend(wl->dev);
6771	pm_runtime_disable(wl->dev);
6772
6773	free_irq(wl->irq, wl);
6774	wlcore_free_hw(wl);
6775
6776	return 0;
6777}
6778EXPORT_SYMBOL_GPL(wlcore_remove);
6779
6780u32 wl12xx_debug_level = DEBUG_NONE;
6781EXPORT_SYMBOL_GPL(wl12xx_debug_level);
6782module_param_named(debug_level, wl12xx_debug_level, uint, 0600);
6783MODULE_PARM_DESC(debug_level, "wl12xx debugging level");
6784
6785module_param_named(fwlog, fwlog_param, charp, 0);
6786MODULE_PARM_DESC(fwlog,
6787		 "FW logger options: continuous, dbgpins or disable");
6788
6789module_param(fwlog_mem_blocks, int, 0600);
6790MODULE_PARM_DESC(fwlog_mem_blocks, "fwlog mem_blocks");
6791
6792module_param(bug_on_recovery, int, 0600);
6793MODULE_PARM_DESC(bug_on_recovery, "BUG() on fw recovery");
6794
6795module_param(no_recovery, int, 0600);
6796MODULE_PARM_DESC(no_recovery, "Prevent HW recovery. FW will remain stuck.");
6797
6798MODULE_LICENSE("GPL");
6799MODULE_AUTHOR("Luciano Coelho <coelho@ti.com>");
6800MODULE_AUTHOR("Juuso Oikarinen <juuso.oikarinen@nokia.com>");