drivers/net/wireless/ti/wlcore/main.c

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